// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_NP2STRUCTS_H_
#define FLATBUFFERS_GENERATED_NP2STRUCTS_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
              FLATBUFFERS_VERSION_MINOR == 0 &&
              FLATBUFFERS_VERSION_REVISION == 8,
             "Non-compatible flatbuffers version included");

struct BinAttr;
struct BinAttrBuilder;

struct IntAttr;
struct IntAttrBuilder;

struct RoomMemberBinAttrInternal;
struct RoomMemberBinAttrInternalBuilder;

struct BinAttrInternal;
struct BinAttrInternalBuilder;

struct OptParam;
struct OptParamBuilder;

struct GroupConfig;
struct GroupConfigBuilder;

struct UserInfo2;
struct UserInfo2Builder;

struct RoomMemberDataInternal;
struct RoomMemberDataInternalBuilder;

struct RoomGroup;
struct RoomGroupBuilder;

struct RoomDataInternal;
struct RoomDataInternalBuilder;

struct RoomDataExternal;
struct RoomDataExternalBuilder;

struct IntSearchFilter;
struct IntSearchFilterBuilder;

struct BinSearchFilter;
struct BinSearchFilterBuilder;

struct PresenceOptionData;
struct PresenceOptionDataBuilder;

struct RoomGroupPasswordConfig;
struct RoomGroupPasswordConfigBuilder;

struct SearchRoomRequest;
struct SearchRoomRequestBuilder;

struct SearchRoomResponse;
struct SearchRoomResponseBuilder;

struct CreateJoinRoomRequest;
struct CreateJoinRoomRequestBuilder;

struct JoinRoomRequest;
struct JoinRoomRequestBuilder;

struct LeaveRoomRequest;
struct LeaveRoomRequestBuilder;

struct GetRoomDataExternalListRequest;
struct GetRoomDataExternalListRequestBuilder;

struct GetRoomDataExternalListResponse;
struct GetRoomDataExternalListResponseBuilder;

struct SetRoomDataExternalRequest;
struct SetRoomDataExternalRequestBuilder;

struct SetRoomDataInternalRequest;
struct SetRoomDataInternalRequestBuilder;

struct SetRoomMemberDataInternalRequest;
struct SetRoomMemberDataInternalRequestBuilder;

struct GetRoomDataInternalRequest;
struct GetRoomDataInternalRequestBuilder;

struct RoomMemberUpdateInfo;
struct RoomMemberUpdateInfoBuilder;

struct RoomUpdateInfo;
struct RoomUpdateInfoBuilder;

struct RoomDataInternalUpdateInfo;
struct RoomDataInternalUpdateInfoBuilder;

struct RoomMemberDataInternalUpdateInfo;
struct RoomMemberDataInternalUpdateInfoBuilder;

struct GetPingInfoResponse;
struct GetPingInfoResponseBuilder;

struct SendRoomMessageRequest;
struct SendRoomMessageRequestBuilder;

struct RoomMessageInfo;
struct RoomMessageInfoBuilder;

struct MessageDetails;
struct MessageDetailsBuilder;

struct SendMessageRequest;
struct SendMessageRequestBuilder;

struct BoardInfo;
struct BoardInfoBuilder;

struct RecordScoreRequest;
struct RecordScoreRequestBuilder;

struct GetScoreRangeRequest;
struct GetScoreRangeRequestBuilder;

struct ScoreNpIdPcId;
struct ScoreNpIdPcIdBuilder;

struct GetScoreNpIdRequest;
struct GetScoreNpIdRequestBuilder;

struct GetScoreFriendsRequest;
struct GetScoreFriendsRequestBuilder;

struct ScoreRankData;
struct ScoreRankDataBuilder;

struct ScoreInfo;
struct ScoreInfoBuilder;

struct GetScoreResponse;
struct GetScoreResponseBuilder;

struct RecordScoreGameDataRequest;
struct RecordScoreGameDataRequestBuilder;

struct GetScoreGameDataRequest;
struct GetScoreGameDataRequestBuilder;

struct BinAttr FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BinAttrBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_DATA = 6
  };
  uint16_t id() const {
    return GetField<uint16_t>(VT_ID, 0);
  }
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct BinAttrBuilder {
  typedef BinAttr Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint16_t id) {
    fbb_.AddElement<uint16_t>(BinAttr::VT_ID, id, 0);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(BinAttr::VT_DATA, data);
  }
  explicit BinAttrBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BinAttr> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BinAttr>(end);
    return o;
  }
};

inline flatbuffers::Offset<BinAttr> CreateBinAttr(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
  BinAttrBuilder builder_(_fbb);
  builder_.add_data(data);
  builder_.add_id(id);
  return builder_.Finish();
}

inline flatbuffers::Offset<BinAttr> CreateBinAttrDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return CreateBinAttr(
      _fbb,
      id,
      data__);
}

struct IntAttr FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef IntAttrBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ID = 4,
    VT_NUM = 6
  };
  uint16_t id() const {
    return GetField<uint16_t>(VT_ID, 0);
  }
  uint32_t num() const {
    return GetField<uint32_t>(VT_NUM, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_ID, 2) &&
           VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
           verifier.EndTable();
  }
};

struct IntAttrBuilder {
  typedef IntAttr Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_id(uint16_t id) {
    fbb_.AddElement<uint16_t>(IntAttr::VT_ID, id, 0);
  }
  void add_num(uint32_t num) {
    fbb_.AddElement<uint32_t>(IntAttr::VT_NUM, num, 0);
  }
  explicit IntAttrBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<IntAttr> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<IntAttr>(end);
    return o;
  }
};

inline flatbuffers::Offset<IntAttr> CreateIntAttr(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t id = 0,
    uint32_t num = 0) {
  IntAttrBuilder builder_(_fbb);
  builder_.add_num(num);
  builder_.add_id(id);
  return builder_.Finish();
}

struct RoomMemberBinAttrInternal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomMemberBinAttrInternalBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_UPDATEDATE = 4,
    VT_DATA = 6
  };
  uint64_t updateDate() const {
    return GetField<uint64_t>(VT_UPDATEDATE, 0);
  }
  const BinAttr *data() const {
    return GetPointer<const BinAttr *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyTable(data()) &&
           verifier.EndTable();
  }
};

struct RoomMemberBinAttrInternalBuilder {
  typedef RoomMemberBinAttrInternal Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_updateDate(uint64_t updateDate) {
    fbb_.AddElement<uint64_t>(RoomMemberBinAttrInternal::VT_UPDATEDATE, updateDate, 0);
  }
  void add_data(flatbuffers::Offset<BinAttr> data) {
    fbb_.AddOffset(RoomMemberBinAttrInternal::VT_DATA, data);
  }
  explicit RoomMemberBinAttrInternalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomMemberBinAttrInternal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomMemberBinAttrInternal>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomMemberBinAttrInternal> CreateRoomMemberBinAttrInternal(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t updateDate = 0,
    flatbuffers::Offset<BinAttr> data = 0) {
  RoomMemberBinAttrInternalBuilder builder_(_fbb);
  builder_.add_updateDate(updateDate);
  builder_.add_data(data);
  return builder_.Finish();
}

struct BinAttrInternal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BinAttrInternalBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_UPDATEDATE = 4,
    VT_UPDATEMEMBERID = 6,
    VT_DATA = 8
  };
  uint64_t updateDate() const {
    return GetField<uint64_t>(VT_UPDATEDATE, 0);
  }
  uint16_t updateMemberId() const {
    return GetField<uint16_t>(VT_UPDATEMEMBERID, 0);
  }
  const BinAttr *data() const {
    return GetPointer<const BinAttr *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
           VerifyField<uint16_t>(verifier, VT_UPDATEMEMBERID, 2) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyTable(data()) &&
           verifier.EndTable();
  }
};

struct BinAttrInternalBuilder {
  typedef BinAttrInternal Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_updateDate(uint64_t updateDate) {
    fbb_.AddElement<uint64_t>(BinAttrInternal::VT_UPDATEDATE, updateDate, 0);
  }
  void add_updateMemberId(uint16_t updateMemberId) {
    fbb_.AddElement<uint16_t>(BinAttrInternal::VT_UPDATEMEMBERID, updateMemberId, 0);
  }
  void add_data(flatbuffers::Offset<BinAttr> data) {
    fbb_.AddOffset(BinAttrInternal::VT_DATA, data);
  }
  explicit BinAttrInternalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BinAttrInternal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BinAttrInternal>(end);
    return o;
  }
};

inline flatbuffers::Offset<BinAttrInternal> CreateBinAttrInternal(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t updateDate = 0,
    uint16_t updateMemberId = 0,
    flatbuffers::Offset<BinAttr> data = 0) {
  BinAttrInternalBuilder builder_(_fbb);
  builder_.add_updateDate(updateDate);
  builder_.add_data(data);
  builder_.add_updateMemberId(updateMemberId);
  return builder_.Finish();
}

struct OptParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef OptParamBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_FLAG = 6,
    VT_HUBMEMBERID = 8
  };
  uint8_t type() const {
    return GetField<uint8_t>(VT_TYPE, 0);
  }
  uint8_t flag() const {
    return GetField<uint8_t>(VT_FLAG, 0);
  }
  uint16_t hubMemberId() const {
    return GetField<uint16_t>(VT_HUBMEMBERID, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
           VerifyField<uint8_t>(verifier, VT_FLAG, 1) &&
           VerifyField<uint16_t>(verifier, VT_HUBMEMBERID, 2) &&
           verifier.EndTable();
  }
};

struct OptParamBuilder {
  typedef OptParam Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_type(uint8_t type) {
    fbb_.AddElement<uint8_t>(OptParam::VT_TYPE, type, 0);
  }
  void add_flag(uint8_t flag) {
    fbb_.AddElement<uint8_t>(OptParam::VT_FLAG, flag, 0);
  }
  void add_hubMemberId(uint16_t hubMemberId) {
    fbb_.AddElement<uint16_t>(OptParam::VT_HUBMEMBERID, hubMemberId, 0);
  }
  explicit OptParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<OptParam> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<OptParam>(end);
    return o;
  }
};

inline flatbuffers::Offset<OptParam> CreateOptParam(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t type = 0,
    uint8_t flag = 0,
    uint16_t hubMemberId = 0) {
  OptParamBuilder builder_(_fbb);
  builder_.add_hubMemberId(hubMemberId);
  builder_.add_flag(flag);
  builder_.add_type(type);
  return builder_.Finish();
}

struct GroupConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GroupConfigBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SLOTNUM = 4,
    VT_WITHLABEL = 6,
    VT_LABEL = 8,
    VT_WITHPASSWORD = 10
  };
  uint32_t slotNum() const {
    return GetField<uint32_t>(VT_SLOTNUM, 0);
  }
  bool withLabel() const {
    return GetField<uint8_t>(VT_WITHLABEL, 0) != 0;
  }
  const flatbuffers::Vector<uint8_t> *label() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LABEL);
  }
  bool withPassword() const {
    return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
           VerifyField<uint8_t>(verifier, VT_WITHLABEL, 1) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyVector(label()) &&
           VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
           verifier.EndTable();
  }
};

struct GroupConfigBuilder {
  typedef GroupConfig Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_slotNum(uint32_t slotNum) {
    fbb_.AddElement<uint32_t>(GroupConfig::VT_SLOTNUM, slotNum, 0);
  }
  void add_withLabel(bool withLabel) {
    fbb_.AddElement<uint8_t>(GroupConfig::VT_WITHLABEL, static_cast<uint8_t>(withLabel), 0);
  }
  void add_label(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> label) {
    fbb_.AddOffset(GroupConfig::VT_LABEL, label);
  }
  void add_withPassword(bool withPassword) {
    fbb_.AddElement<uint8_t>(GroupConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
  }
  explicit GroupConfigBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GroupConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GroupConfig>(end);
    return o;
  }
};

inline flatbuffers::Offset<GroupConfig> CreateGroupConfig(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t slotNum = 0,
    bool withLabel = false,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> label = 0,
    bool withPassword = false) {
  GroupConfigBuilder builder_(_fbb);
  builder_.add_label(label);
  builder_.add_slotNum(slotNum);
  builder_.add_withPassword(withPassword);
  builder_.add_withLabel(withLabel);
  return builder_.Finish();
}

inline flatbuffers::Offset<GroupConfig> CreateGroupConfigDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t slotNum = 0,
    bool withLabel = false,
    const std::vector<uint8_t> *label = nullptr,
    bool withPassword = false) {
  auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
  return CreateGroupConfig(
      _fbb,
      slotNum,
      withLabel,
      label__,
      withPassword);
}

struct UserInfo2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef UserInfo2Builder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NPID = 4,
    VT_ONLINENAME = 6,
    VT_AVATARURL = 8
  };
  const flatbuffers::String *npId() const {
    return GetPointer<const flatbuffers::String *>(VT_NPID);
  }
  const flatbuffers::String *onlineName() const {
    return GetPointer<const flatbuffers::String *>(VT_ONLINENAME);
  }
  const flatbuffers::String *avatarUrl() const {
    return GetPointer<const flatbuffers::String *>(VT_AVATARURL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NPID) &&
           verifier.VerifyString(npId()) &&
           VerifyOffset(verifier, VT_ONLINENAME) &&
           verifier.VerifyString(onlineName()) &&
           VerifyOffset(verifier, VT_AVATARURL) &&
           verifier.VerifyString(avatarUrl()) &&
           verifier.EndTable();
  }
};

struct UserInfo2Builder {
  typedef UserInfo2 Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_npId(flatbuffers::Offset<flatbuffers::String> npId) {
    fbb_.AddOffset(UserInfo2::VT_NPID, npId);
  }
  void add_onlineName(flatbuffers::Offset<flatbuffers::String> onlineName) {
    fbb_.AddOffset(UserInfo2::VT_ONLINENAME, onlineName);
  }
  void add_avatarUrl(flatbuffers::Offset<flatbuffers::String> avatarUrl) {
    fbb_.AddOffset(UserInfo2::VT_AVATARURL, avatarUrl);
  }
  explicit UserInfo2Builder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<UserInfo2> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<UserInfo2>(end);
    return o;
  }
};

inline flatbuffers::Offset<UserInfo2> CreateUserInfo2(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> npId = 0,
    flatbuffers::Offset<flatbuffers::String> onlineName = 0,
    flatbuffers::Offset<flatbuffers::String> avatarUrl = 0) {
  UserInfo2Builder builder_(_fbb);
  builder_.add_avatarUrl(avatarUrl);
  builder_.add_onlineName(onlineName);
  builder_.add_npId(npId);
  return builder_.Finish();
}

inline flatbuffers::Offset<UserInfo2> CreateUserInfo2Direct(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *npId = nullptr,
    const char *onlineName = nullptr,
    const char *avatarUrl = nullptr) {
  auto npId__ = npId ? _fbb.CreateString(npId) : 0;
  auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
  auto avatarUrl__ = avatarUrl ? _fbb.CreateString(avatarUrl) : 0;
  return CreateUserInfo2(
      _fbb,
      npId__,
      onlineName__,
      avatarUrl__);
}

struct RoomMemberDataInternal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomMemberDataInternalBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_USERINFO = 4,
    VT_JOINDATE = 6,
    VT_MEMBERID = 8,
    VT_TEAMID = 10,
    VT_ROOMGROUP = 12,
    VT_NATTYPE = 14,
    VT_FLAGATTR = 16,
    VT_ROOMMEMBERBINATTRINTERNAL = 18
  };
  const UserInfo2 *userInfo() const {
    return GetPointer<const UserInfo2 *>(VT_USERINFO);
  }
  uint64_t joinDate() const {
    return GetField<uint64_t>(VT_JOINDATE, 0);
  }
  uint16_t memberId() const {
    return GetField<uint16_t>(VT_MEMBERID, 0);
  }
  uint8_t teamId() const {
    return GetField<uint8_t>(VT_TEAMID, 0);
  }
  const RoomGroup *roomGroup() const {
    return GetPointer<const RoomGroup *>(VT_ROOMGROUP);
  }
  uint8_t natType() const {
    return GetField<uint8_t>(VT_NATTYPE, 0);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomMemberBinAttrInternal>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_USERINFO) &&
           verifier.VerifyTable(userInfo()) &&
           VerifyField<uint64_t>(verifier, VT_JOINDATE, 8) &&
           VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
           VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
           VerifyOffset(verifier, VT_ROOMGROUP) &&
           verifier.VerifyTable(roomGroup()) &&
           VerifyField<uint8_t>(verifier, VT_NATTYPE, 1) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
           verifier.VerifyVector(roomMemberBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
           verifier.EndTable();
  }
};

struct RoomMemberDataInternalBuilder {
  typedef RoomMemberDataInternal Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_userInfo(flatbuffers::Offset<UserInfo2> userInfo) {
    fbb_.AddOffset(RoomMemberDataInternal::VT_USERINFO, userInfo);
  }
  void add_joinDate(uint64_t joinDate) {
    fbb_.AddElement<uint64_t>(RoomMemberDataInternal::VT_JOINDATE, joinDate, 0);
  }
  void add_memberId(uint16_t memberId) {
    fbb_.AddElement<uint16_t>(RoomMemberDataInternal::VT_MEMBERID, memberId, 0);
  }
  void add_teamId(uint8_t teamId) {
    fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_TEAMID, teamId, 0);
  }
  void add_roomGroup(flatbuffers::Offset<RoomGroup> roomGroup) {
    fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMGROUP, roomGroup);
  }
  void add_natType(uint8_t natType) {
    fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_NATTYPE, natType, 0);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(RoomMemberDataInternal::VT_FLAGATTR, flagAttr, 0);
  }
  void add_roomMemberBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal) {
    fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
  }
  explicit RoomMemberDataInternalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomMemberDataInternal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomMemberDataInternal>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternal(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<UserInfo2> userInfo = 0,
    uint64_t joinDate = 0,
    uint16_t memberId = 0,
    uint8_t teamId = 0,
    flatbuffers::Offset<RoomGroup> roomGroup = 0,
    uint8_t natType = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal = 0) {
  RoomMemberDataInternalBuilder builder_(_fbb);
  builder_.add_joinDate(joinDate);
  builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
  builder_.add_flagAttr(flagAttr);
  builder_.add_roomGroup(roomGroup);
  builder_.add_userInfo(userInfo);
  builder_.add_memberId(memberId);
  builder_.add_natType(natType);
  builder_.add_teamId(teamId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternalDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<UserInfo2> userInfo = 0,
    uint64_t joinDate = 0,
    uint16_t memberId = 0,
    uint8_t teamId = 0,
    flatbuffers::Offset<RoomGroup> roomGroup = 0,
    uint8_t natType = 0,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal = nullptr) {
  auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<RoomMemberBinAttrInternal>>(*roomMemberBinAttrInternal) : 0;
  return CreateRoomMemberDataInternal(
      _fbb,
      userInfo,
      joinDate,
      memberId,
      teamId,
      roomGroup,
      natType,
      flagAttr,
      roomMemberBinAttrInternal__);
}

struct RoomGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomGroupBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GROUPID = 4,
    VT_WITHPASSWORD = 6,
    VT_WITHLABEL = 8,
    VT_LABEL = 10,
    VT_SLOTNUM = 12,
    VT_CURGROUPMEMBERNUM = 14
  };
  uint8_t groupId() const {
    return GetField<uint8_t>(VT_GROUPID, 0);
  }
  bool withPassword() const {
    return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
  }
  bool withLabel() const {
    return GetField<uint8_t>(VT_WITHLABEL, 0) != 0;
  }
  const flatbuffers::Vector<uint8_t> *label() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LABEL);
  }
  uint32_t slotNum() const {
    return GetField<uint32_t>(VT_SLOTNUM, 0);
  }
  uint32_t curGroupMemberNum() const {
    return GetField<uint32_t>(VT_CURGROUPMEMBERNUM, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_GROUPID, 1) &&
           VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
           VerifyField<uint8_t>(verifier, VT_WITHLABEL, 1) &&
           VerifyOffset(verifier, VT_LABEL) &&
           verifier.VerifyVector(label()) &&
           VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
           VerifyField<uint32_t>(verifier, VT_CURGROUPMEMBERNUM, 4) &&
           verifier.EndTable();
  }
};

struct RoomGroupBuilder {
  typedef RoomGroup Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_groupId(uint8_t groupId) {
    fbb_.AddElement<uint8_t>(RoomGroup::VT_GROUPID, groupId, 0);
  }
  void add_withPassword(bool withPassword) {
    fbb_.AddElement<uint8_t>(RoomGroup::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
  }
  void add_withLabel(bool withLabel) {
    fbb_.AddElement<uint8_t>(RoomGroup::VT_WITHLABEL, static_cast<uint8_t>(withLabel), 0);
  }
  void add_label(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> label) {
    fbb_.AddOffset(RoomGroup::VT_LABEL, label);
  }
  void add_slotNum(uint32_t slotNum) {
    fbb_.AddElement<uint32_t>(RoomGroup::VT_SLOTNUM, slotNum, 0);
  }
  void add_curGroupMemberNum(uint32_t curGroupMemberNum) {
    fbb_.AddElement<uint32_t>(RoomGroup::VT_CURGROUPMEMBERNUM, curGroupMemberNum, 0);
  }
  explicit RoomGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomGroup> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomGroup>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomGroup> CreateRoomGroup(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t groupId = 0,
    bool withPassword = false,
    bool withLabel = false,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> label = 0,
    uint32_t slotNum = 0,
    uint32_t curGroupMemberNum = 0) {
  RoomGroupBuilder builder_(_fbb);
  builder_.add_curGroupMemberNum(curGroupMemberNum);
  builder_.add_slotNum(slotNum);
  builder_.add_label(label);
  builder_.add_withLabel(withLabel);
  builder_.add_withPassword(withPassword);
  builder_.add_groupId(groupId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomGroup> CreateRoomGroupDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t groupId = 0,
    bool withPassword = false,
    bool withLabel = false,
    const std::vector<uint8_t> *label = nullptr,
    uint32_t slotNum = 0,
    uint32_t curGroupMemberNum = 0) {
  auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
  return CreateRoomGroup(
      _fbb,
      groupId,
      withPassword,
      withLabel,
      label__,
      slotNum,
      curGroupMemberNum);
}

struct RoomDataInternal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomDataInternalBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SERVERID = 4,
    VT_WORLDID = 6,
    VT_LOBBYID = 8,
    VT_ROOMID = 10,
    VT_PASSWORDSLOTMASK = 12,
    VT_MAXSLOT = 14,
    VT_MEMBERLIST = 16,
    VT_OWNERID = 18,
    VT_ROOMGROUP = 20,
    VT_FLAGATTR = 22,
    VT_ROOMBINATTRINTERNAL = 24
  };
  uint16_t serverId() const {
    return GetField<uint16_t>(VT_SERVERID, 0);
  }
  uint32_t worldId() const {
    return GetField<uint32_t>(VT_WORLDID, 0);
  }
  uint64_t lobbyId() const {
    return GetField<uint64_t>(VT_LOBBYID, 0);
  }
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint64_t passwordSlotMask() const {
    return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
  }
  uint32_t maxSlot() const {
    return GetField<uint32_t>(VT_MAXSLOT, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomMemberDataInternal>> *memberList() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomMemberDataInternal>> *>(VT_MEMBERLIST);
  }
  uint16_t ownerId() const {
    return GetField<uint16_t>(VT_OWNERID, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomGroup>> *roomGroup() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttrInternal>> *>(VT_ROOMBINATTRINTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
           VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
           VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
           VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
           VerifyOffset(verifier, VT_MEMBERLIST) &&
           verifier.VerifyVector(memberList()) &&
           verifier.VerifyVectorOfTables(memberList()) &&
           VerifyField<uint16_t>(verifier, VT_OWNERID, 2) &&
           VerifyOffset(verifier, VT_ROOMGROUP) &&
           verifier.VerifyVector(roomGroup()) &&
           verifier.VerifyVectorOfTables(roomGroup()) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
           verifier.VerifyVector(roomBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
           verifier.EndTable();
  }
};

struct RoomDataInternalBuilder {
  typedef RoomDataInternal Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_serverId(uint16_t serverId) {
    fbb_.AddElement<uint16_t>(RoomDataInternal::VT_SERVERID, serverId, 0);
  }
  void add_worldId(uint32_t worldId) {
    fbb_.AddElement<uint32_t>(RoomDataInternal::VT_WORLDID, worldId, 0);
  }
  void add_lobbyId(uint64_t lobbyId) {
    fbb_.AddElement<uint64_t>(RoomDataInternal::VT_LOBBYID, lobbyId, 0);
  }
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(RoomDataInternal::VT_ROOMID, roomId, 0);
  }
  void add_passwordSlotMask(uint64_t passwordSlotMask) {
    fbb_.AddElement<uint64_t>(RoomDataInternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
  }
  void add_maxSlot(uint32_t maxSlot) {
    fbb_.AddElement<uint32_t>(RoomDataInternal::VT_MAXSLOT, maxSlot, 0);
  }
  void add_memberList(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomMemberDataInternal>>> memberList) {
    fbb_.AddOffset(RoomDataInternal::VT_MEMBERLIST, memberList);
  }
  void add_ownerId(uint16_t ownerId) {
    fbb_.AddElement<uint16_t>(RoomDataInternal::VT_OWNERID, ownerId, 0);
  }
  void add_roomGroup(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroup>>> roomGroup) {
    fbb_.AddOffset(RoomDataInternal::VT_ROOMGROUP, roomGroup);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(RoomDataInternal::VT_FLAGATTR, flagAttr, 0);
  }
  void add_roomBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal) {
    fbb_.AddOffset(RoomDataInternal::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
  }
  explicit RoomDataInternalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomDataInternal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomDataInternal>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternal(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t serverId = 0,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint64_t roomId = 0,
    uint64_t passwordSlotMask = 0,
    uint32_t maxSlot = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomMemberDataInternal>>> memberList = 0,
    uint16_t ownerId = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal = 0) {
  RoomDataInternalBuilder builder_(_fbb);
  builder_.add_passwordSlotMask(passwordSlotMask);
  builder_.add_roomId(roomId);
  builder_.add_lobbyId(lobbyId);
  builder_.add_roomBinAttrInternal(roomBinAttrInternal);
  builder_.add_flagAttr(flagAttr);
  builder_.add_roomGroup(roomGroup);
  builder_.add_memberList(memberList);
  builder_.add_maxSlot(maxSlot);
  builder_.add_worldId(worldId);
  builder_.add_ownerId(ownerId);
  builder_.add_serverId(serverId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternalDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t serverId = 0,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint64_t roomId = 0,
    uint64_t passwordSlotMask = 0,
    uint32_t maxSlot = 0,
    const std::vector<flatbuffers::Offset<RoomMemberDataInternal>> *memberList = nullptr,
    uint16_t ownerId = 0,
    const std::vector<flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal = nullptr) {
  auto memberList__ = memberList ? _fbb.CreateVector<flatbuffers::Offset<RoomMemberDataInternal>>(*memberList) : 0;
  auto roomGroup__ = roomGroup ? _fbb.CreateVector<flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
  auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttrInternal>>(*roomBinAttrInternal) : 0;
  return CreateRoomDataInternal(
      _fbb,
      serverId,
      worldId,
      lobbyId,
      roomId,
      passwordSlotMask,
      maxSlot,
      memberList__,
      ownerId,
      roomGroup__,
      flagAttr,
      roomBinAttrInternal__);
}

struct RoomDataExternal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomDataExternalBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SERVERID = 4,
    VT_WORLDID = 6,
    VT_PUBLICSLOTNUM = 8,
    VT_PRIVATESLOTNUM = 10,
    VT_LOBBYID = 12,
    VT_ROOMID = 14,
    VT_OPENPUBLICSLOTNUM = 16,
    VT_MAXSLOT = 18,
    VT_OPENPRIVATESLOTNUM = 20,
    VT_CURMEMBERNUM = 22,
    VT_PASSWORDSLOTMASK = 24,
    VT_OWNER = 26,
    VT_ROOMGROUP = 28,
    VT_FLAGATTR = 30,
    VT_ROOMSEARCHABLEINTATTREXTERNAL = 32,
    VT_ROOMSEARCHABLEBINATTREXTERNAL = 34,
    VT_ROOMBINATTREXTERNAL = 36
  };
  uint16_t serverId() const {
    return GetField<uint16_t>(VT_SERVERID, 0);
  }
  uint32_t worldId() const {
    return GetField<uint32_t>(VT_WORLDID, 0);
  }
  uint16_t publicSlotNum() const {
    return GetField<uint16_t>(VT_PUBLICSLOTNUM, 0);
  }
  uint16_t privateSlotNum() const {
    return GetField<uint16_t>(VT_PRIVATESLOTNUM, 0);
  }
  uint64_t lobbyId() const {
    return GetField<uint64_t>(VT_LOBBYID, 0);
  }
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint16_t openPublicSlotNum() const {
    return GetField<uint16_t>(VT_OPENPUBLICSLOTNUM, 0);
  }
  uint16_t maxSlot() const {
    return GetField<uint16_t>(VT_MAXSLOT, 0);
  }
  uint16_t openPrivateSlotNum() const {
    return GetField<uint16_t>(VT_OPENPRIVATESLOTNUM, 0);
  }
  uint16_t curMemberNum() const {
    return GetField<uint16_t>(VT_CURMEMBERNUM, 0);
  }
  uint64_t passwordSlotMask() const {
    return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
  }
  const UserInfo2 *owner() const {
    return GetPointer<const UserInfo2 *>(VT_OWNER);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomGroup>> *roomGroup() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
           VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
           VerifyField<uint16_t>(verifier, VT_PUBLICSLOTNUM, 2) &&
           VerifyField<uint16_t>(verifier, VT_PRIVATESLOTNUM, 2) &&
           VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint16_t>(verifier, VT_OPENPUBLICSLOTNUM, 2) &&
           VerifyField<uint16_t>(verifier, VT_MAXSLOT, 2) &&
           VerifyField<uint16_t>(verifier, VT_OPENPRIVATESLOTNUM, 2) &&
           VerifyField<uint16_t>(verifier, VT_CURMEMBERNUM, 2) &&
           VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
           VerifyOffset(verifier, VT_OWNER) &&
           verifier.VerifyTable(owner()) &&
           VerifyOffset(verifier, VT_ROOMGROUP) &&
           verifier.VerifyVector(roomGroup()) &&
           verifier.VerifyVectorOfTables(roomGroup()) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
           verifier.VerifyVector(roomBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
           verifier.EndTable();
  }
};

struct RoomDataExternalBuilder {
  typedef RoomDataExternal Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_serverId(uint16_t serverId) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_SERVERID, serverId, 0);
  }
  void add_worldId(uint32_t worldId) {
    fbb_.AddElement<uint32_t>(RoomDataExternal::VT_WORLDID, worldId, 0);
  }
  void add_publicSlotNum(uint16_t publicSlotNum) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PUBLICSLOTNUM, publicSlotNum, 0);
  }
  void add_privateSlotNum(uint16_t privateSlotNum) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PRIVATESLOTNUM, privateSlotNum, 0);
  }
  void add_lobbyId(uint64_t lobbyId) {
    fbb_.AddElement<uint64_t>(RoomDataExternal::VT_LOBBYID, lobbyId, 0);
  }
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(RoomDataExternal::VT_ROOMID, roomId, 0);
  }
  void add_openPublicSlotNum(uint16_t openPublicSlotNum) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPUBLICSLOTNUM, openPublicSlotNum, 0);
  }
  void add_maxSlot(uint16_t maxSlot) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_MAXSLOT, maxSlot, 0);
  }
  void add_openPrivateSlotNum(uint16_t openPrivateSlotNum) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPRIVATESLOTNUM, openPrivateSlotNum, 0);
  }
  void add_curMemberNum(uint16_t curMemberNum) {
    fbb_.AddElement<uint16_t>(RoomDataExternal::VT_CURMEMBERNUM, curMemberNum, 0);
  }
  void add_passwordSlotMask(uint64_t passwordSlotMask) {
    fbb_.AddElement<uint64_t>(RoomDataExternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
  }
  void add_owner(flatbuffers::Offset<UserInfo2> owner) {
    fbb_.AddOffset(RoomDataExternal::VT_OWNER, owner);
  }
  void add_roomGroup(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroup>>> roomGroup) {
    fbb_.AddOffset(RoomDataExternal::VT_ROOMGROUP, roomGroup);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(RoomDataExternal::VT_FLAGATTR, flagAttr, 0);
  }
  void add_roomSearchableIntAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
    fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
  }
  void add_roomSearchableBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
    fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
  }
  void add_roomBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
    fbb_.AddOffset(RoomDataExternal::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
  }
  explicit RoomDataExternalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomDataExternal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomDataExternal>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternal(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t serverId = 0,
    uint32_t worldId = 0,
    uint16_t publicSlotNum = 0,
    uint16_t privateSlotNum = 0,
    uint64_t lobbyId = 0,
    uint64_t roomId = 0,
    uint16_t openPublicSlotNum = 0,
    uint16_t maxSlot = 0,
    uint16_t openPrivateSlotNum = 0,
    uint16_t curMemberNum = 0,
    uint64_t passwordSlotMask = 0,
    flatbuffers::Offset<UserInfo2> owner = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
  RoomDataExternalBuilder builder_(_fbb);
  builder_.add_passwordSlotMask(passwordSlotMask);
  builder_.add_roomId(roomId);
  builder_.add_lobbyId(lobbyId);
  builder_.add_roomBinAttrExternal(roomBinAttrExternal);
  builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
  builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
  builder_.add_flagAttr(flagAttr);
  builder_.add_roomGroup(roomGroup);
  builder_.add_owner(owner);
  builder_.add_worldId(worldId);
  builder_.add_curMemberNum(curMemberNum);
  builder_.add_openPrivateSlotNum(openPrivateSlotNum);
  builder_.add_maxSlot(maxSlot);
  builder_.add_openPublicSlotNum(openPublicSlotNum);
  builder_.add_privateSlotNum(privateSlotNum);
  builder_.add_publicSlotNum(publicSlotNum);
  builder_.add_serverId(serverId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternalDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t serverId = 0,
    uint32_t worldId = 0,
    uint16_t publicSlotNum = 0,
    uint16_t privateSlotNum = 0,
    uint64_t lobbyId = 0,
    uint64_t roomId = 0,
    uint16_t openPublicSlotNum = 0,
    uint16_t maxSlot = 0,
    uint16_t openPrivateSlotNum = 0,
    uint16_t curMemberNum = 0,
    uint64_t passwordSlotMask = 0,
    flatbuffers::Offset<UserInfo2> owner = 0,
    const std::vector<flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
  auto roomGroup__ = roomGroup ? _fbb.CreateVector<flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
  auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
  auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
  auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
  return CreateRoomDataExternal(
      _fbb,
      serverId,
      worldId,
      publicSlotNum,
      privateSlotNum,
      lobbyId,
      roomId,
      openPublicSlotNum,
      maxSlot,
      openPrivateSlotNum,
      curMemberNum,
      passwordSlotMask,
      owner,
      roomGroup__,
      flagAttr,
      roomSearchableIntAttrExternal__,
      roomSearchableBinAttrExternal__,
      roomBinAttrExternal__);
}

struct IntSearchFilter FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef IntSearchFilterBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEARCHOPERATOR = 4,
    VT_ATTR = 6
  };
  uint8_t searchOperator() const {
    return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
  }
  const IntAttr *attr() const {
    return GetPointer<const IntAttr *>(VT_ATTR);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
           VerifyOffset(verifier, VT_ATTR) &&
           verifier.VerifyTable(attr()) &&
           verifier.EndTable();
  }
};

struct IntSearchFilterBuilder {
  typedef IntSearchFilter Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_searchOperator(uint8_t searchOperator) {
    fbb_.AddElement<uint8_t>(IntSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
  }
  void add_attr(flatbuffers::Offset<IntAttr> attr) {
    fbb_.AddOffset(IntSearchFilter::VT_ATTR, attr);
  }
  explicit IntSearchFilterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<IntSearchFilter> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<IntSearchFilter>(end);
    return o;
  }
};

inline flatbuffers::Offset<IntSearchFilter> CreateIntSearchFilter(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t searchOperator = 0,
    flatbuffers::Offset<IntAttr> attr = 0) {
  IntSearchFilterBuilder builder_(_fbb);
  builder_.add_attr(attr);
  builder_.add_searchOperator(searchOperator);
  return builder_.Finish();
}

struct BinSearchFilter FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BinSearchFilterBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SEARCHOPERATOR = 4,
    VT_ATTR = 6
  };
  uint8_t searchOperator() const {
    return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
  }
  const BinAttr *attr() const {
    return GetPointer<const BinAttr *>(VT_ATTR);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
           VerifyOffset(verifier, VT_ATTR) &&
           verifier.VerifyTable(attr()) &&
           verifier.EndTable();
  }
};

struct BinSearchFilterBuilder {
  typedef BinSearchFilter Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_searchOperator(uint8_t searchOperator) {
    fbb_.AddElement<uint8_t>(BinSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
  }
  void add_attr(flatbuffers::Offset<BinAttr> attr) {
    fbb_.AddOffset(BinSearchFilter::VT_ATTR, attr);
  }
  explicit BinSearchFilterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BinSearchFilter> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BinSearchFilter>(end);
    return o;
  }
};

inline flatbuffers::Offset<BinSearchFilter> CreateBinSearchFilter(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t searchOperator = 0,
    flatbuffers::Offset<BinAttr> attr = 0) {
  BinSearchFilterBuilder builder_(_fbb);
  builder_.add_attr(attr);
  builder_.add_searchOperator(searchOperator);
  return builder_.Finish();
}

struct PresenceOptionData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PresenceOptionDataBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4,
    VT_LEN = 6
  };
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  uint32_t len() const {
    return GetField<uint32_t>(VT_LEN, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           VerifyField<uint32_t>(verifier, VT_LEN, 4) &&
           verifier.EndTable();
  }
};

struct PresenceOptionDataBuilder {
  typedef PresenceOptionData Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(PresenceOptionData::VT_DATA, data);
  }
  void add_len(uint32_t len) {
    fbb_.AddElement<uint32_t>(PresenceOptionData::VT_LEN, len, 0);
  }
  explicit PresenceOptionDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<PresenceOptionData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<PresenceOptionData>(end);
    return o;
  }
};

inline flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionData(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
    uint32_t len = 0) {
  PresenceOptionDataBuilder builder_(_fbb);
  builder_.add_len(len);
  builder_.add_data(data);
  return builder_.Finish();
}

inline flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionDataDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr,
    uint32_t len = 0) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return CreatePresenceOptionData(
      _fbb,
      data__,
      len);
}

struct RoomGroupPasswordConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomGroupPasswordConfigBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GROUPID = 4,
    VT_WITHPASSWORD = 6
  };
  const flatbuffers::Vector<uint8_t> *groupId() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_GROUPID);
  }
  bool withPassword() const {
    return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_GROUPID) &&
           verifier.VerifyVector(groupId()) &&
           VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
           verifier.EndTable();
  }
};

struct RoomGroupPasswordConfigBuilder {
  typedef RoomGroupPasswordConfig Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_groupId(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> groupId) {
    fbb_.AddOffset(RoomGroupPasswordConfig::VT_GROUPID, groupId);
  }
  void add_withPassword(bool withPassword) {
    fbb_.AddElement<uint8_t>(RoomGroupPasswordConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
  }
  explicit RoomGroupPasswordConfigBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomGroupPasswordConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomGroupPasswordConfig>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomGroupPasswordConfig> CreateRoomGroupPasswordConfig(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> groupId = 0,
    bool withPassword = false) {
  RoomGroupPasswordConfigBuilder builder_(_fbb);
  builder_.add_groupId(groupId);
  builder_.add_withPassword(withPassword);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomGroupPasswordConfig> CreateRoomGroupPasswordConfigDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *groupId = nullptr,
    bool withPassword = false) {
  auto groupId__ = groupId ? _fbb.CreateVector<uint8_t>(*groupId) : 0;
  return CreateRoomGroupPasswordConfig(
      _fbb,
      groupId__,
      withPassword);
}

struct SearchRoomRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SearchRoomRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OPTION = 4,
    VT_WORLDID = 6,
    VT_LOBBYID = 8,
    VT_RANGEFILTER_STARTINDEX = 10,
    VT_RANGEFILTER_MAX = 12,
    VT_FLAGFILTER = 14,
    VT_FLAGATTR = 16,
    VT_INTFILTER = 18,
    VT_BINFILTER = 20,
    VT_ATTRID = 22
  };
  int32_t option() const {
    return GetField<int32_t>(VT_OPTION, 0);
  }
  uint32_t worldId() const {
    return GetField<uint32_t>(VT_WORLDID, 0);
  }
  uint64_t lobbyId() const {
    return GetField<uint64_t>(VT_LOBBYID, 0);
  }
  uint32_t rangeFilter_startIndex() const {
    return GetField<uint32_t>(VT_RANGEFILTER_STARTINDEX, 0);
  }
  uint32_t rangeFilter_max() const {
    return GetField<uint32_t>(VT_RANGEFILTER_MAX, 0);
  }
  uint32_t flagFilter() const {
    return GetField<uint32_t>(VT_FLAGFILTER, 0);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<IntSearchFilter>> *intFilter() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<IntSearchFilter>> *>(VT_INTFILTER);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinSearchFilter>> *binFilter() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinSearchFilter>> *>(VT_BINFILTER);
  }
  const flatbuffers::Vector<uint16_t> *attrId() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_OPTION, 4) &&
           VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
           VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
           VerifyField<uint32_t>(verifier, VT_RANGEFILTER_STARTINDEX, 4) &&
           VerifyField<uint32_t>(verifier, VT_RANGEFILTER_MAX, 4) &&
           VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_INTFILTER) &&
           verifier.VerifyVector(intFilter()) &&
           verifier.VerifyVectorOfTables(intFilter()) &&
           VerifyOffset(verifier, VT_BINFILTER) &&
           verifier.VerifyVector(binFilter()) &&
           verifier.VerifyVectorOfTables(binFilter()) &&
           VerifyOffset(verifier, VT_ATTRID) &&
           verifier.VerifyVector(attrId()) &&
           verifier.EndTable();
  }
};

struct SearchRoomRequestBuilder {
  typedef SearchRoomRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_option(int32_t option) {
    fbb_.AddElement<int32_t>(SearchRoomRequest::VT_OPTION, option, 0);
  }
  void add_worldId(uint32_t worldId) {
    fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_WORLDID, worldId, 0);
  }
  void add_lobbyId(uint64_t lobbyId) {
    fbb_.AddElement<uint64_t>(SearchRoomRequest::VT_LOBBYID, lobbyId, 0);
  }
  void add_rangeFilter_startIndex(uint32_t rangeFilter_startIndex) {
    fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_STARTINDEX, rangeFilter_startIndex, 0);
  }
  void add_rangeFilter_max(uint32_t rangeFilter_max) {
    fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_MAX, rangeFilter_max, 0);
  }
  void add_flagFilter(uint32_t flagFilter) {
    fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGFILTER, flagFilter, 0);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGATTR, flagAttr, 0);
  }
  void add_intFilter(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntSearchFilter>>> intFilter) {
    fbb_.AddOffset(SearchRoomRequest::VT_INTFILTER, intFilter);
  }
  void add_binFilter(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinSearchFilter>>> binFilter) {
    fbb_.AddOffset(SearchRoomRequest::VT_BINFILTER, binFilter);
  }
  void add_attrId(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrId) {
    fbb_.AddOffset(SearchRoomRequest::VT_ATTRID, attrId);
  }
  explicit SearchRoomRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SearchRoomRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SearchRoomRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t option = 0,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint32_t rangeFilter_startIndex = 0,
    uint32_t rangeFilter_max = 0,
    uint32_t flagFilter = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntSearchFilter>>> intFilter = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinSearchFilter>>> binFilter = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrId = 0) {
  SearchRoomRequestBuilder builder_(_fbb);
  builder_.add_lobbyId(lobbyId);
  builder_.add_attrId(attrId);
  builder_.add_binFilter(binFilter);
  builder_.add_intFilter(intFilter);
  builder_.add_flagAttr(flagAttr);
  builder_.add_flagFilter(flagFilter);
  builder_.add_rangeFilter_max(rangeFilter_max);
  builder_.add_rangeFilter_startIndex(rangeFilter_startIndex);
  builder_.add_worldId(worldId);
  builder_.add_option(option);
  return builder_.Finish();
}

inline flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t option = 0,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint32_t rangeFilter_startIndex = 0,
    uint32_t rangeFilter_max = 0,
    uint32_t flagFilter = 0,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<IntSearchFilter>> *intFilter = nullptr,
    const std::vector<flatbuffers::Offset<BinSearchFilter>> *binFilter = nullptr,
    const std::vector<uint16_t> *attrId = nullptr) {
  auto intFilter__ = intFilter ? _fbb.CreateVector<flatbuffers::Offset<IntSearchFilter>>(*intFilter) : 0;
  auto binFilter__ = binFilter ? _fbb.CreateVector<flatbuffers::Offset<BinSearchFilter>>(*binFilter) : 0;
  auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
  return CreateSearchRoomRequest(
      _fbb,
      option,
      worldId,
      lobbyId,
      rangeFilter_startIndex,
      rangeFilter_max,
      flagFilter,
      flagAttr,
      intFilter__,
      binFilter__,
      attrId__);
}

struct SearchRoomResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SearchRoomResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STARTINDEX = 4,
    VT_TOTAL = 6,
    VT_SIZE = 8,
    VT_ROOMS = 10
  };
  uint32_t startIndex() const {
    return GetField<uint32_t>(VT_STARTINDEX, 0);
  }
  uint32_t total() const {
    return GetField<uint32_t>(VT_TOTAL, 0);
  }
  uint32_t size() const {
    return GetField<uint32_t>(VT_SIZE, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>> *rooms() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_STARTINDEX, 4) &&
           VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
           VerifyField<uint32_t>(verifier, VT_SIZE, 4) &&
           VerifyOffset(verifier, VT_ROOMS) &&
           verifier.VerifyVector(rooms()) &&
           verifier.VerifyVectorOfTables(rooms()) &&
           verifier.EndTable();
  }
};

struct SearchRoomResponseBuilder {
  typedef SearchRoomResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_startIndex(uint32_t startIndex) {
    fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_STARTINDEX, startIndex, 0);
  }
  void add_total(uint32_t total) {
    fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_TOTAL, total, 0);
  }
  void add_size(uint32_t size) {
    fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_SIZE, size, 0);
  }
  void add_rooms(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>>> rooms) {
    fbb_.AddOffset(SearchRoomResponse::VT_ROOMS, rooms);
  }
  explicit SearchRoomResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SearchRoomResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SearchRoomResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t startIndex = 0,
    uint32_t total = 0,
    uint32_t size = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
  SearchRoomResponseBuilder builder_(_fbb);
  builder_.add_rooms(rooms);
  builder_.add_size(size);
  builder_.add_total(total);
  builder_.add_startIndex(startIndex);
  return builder_.Finish();
}

inline flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t startIndex = 0,
    uint32_t total = 0,
    uint32_t size = 0,
    const std::vector<flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
  auto rooms__ = rooms ? _fbb.CreateVector<flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
  return CreateSearchRoomResponse(
      _fbb,
      startIndex,
      total,
      size,
      rooms__);
}

struct CreateJoinRoomRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef CreateJoinRoomRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WORLDID = 4,
    VT_LOBBYID = 6,
    VT_MAXSLOT = 8,
    VT_FLAGATTR = 10,
    VT_ROOMBINATTRINTERNAL = 12,
    VT_ROOMSEARCHABLEINTATTREXTERNAL = 14,
    VT_ROOMSEARCHABLEBINATTREXTERNAL = 16,
    VT_ROOMBINATTREXTERNAL = 18,
    VT_ROOMPASSWORD = 20,
    VT_GROUPCONFIG = 22,
    VT_PASSWORDSLOTMASK = 24,
    VT_ALLOWEDUSER = 26,
    VT_BLOCKEDUSER = 28,
    VT_JOINROOMGROUPLABEL = 30,
    VT_ROOMMEMBERBINATTRINTERNAL = 32,
    VT_TEAMID = 34,
    VT_SIGOPTPARAM = 36
  };
  uint32_t worldId() const {
    return GetField<uint32_t>(VT_WORLDID, 0);
  }
  uint64_t lobbyId() const {
    return GetField<uint64_t>(VT_LOBBYID, 0);
  }
  uint32_t maxSlot() const {
    return GetField<uint32_t>(VT_MAXSLOT, 0);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
  }
  const flatbuffers::Vector<uint8_t> *roomPassword() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
  }
  const flatbuffers::Vector<flatbuffers::Offset<GroupConfig>> *groupConfig() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<GroupConfig>> *>(VT_GROUPCONFIG);
  }
  uint64_t passwordSlotMask() const {
    return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *allowedUser() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_ALLOWEDUSER);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *blockedUser() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_BLOCKEDUSER);
  }
  const flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
  }
  uint8_t teamId() const {
    return GetField<uint8_t>(VT_TEAMID, 0);
  }
  const OptParam *sigOptParam() const {
    return GetPointer<const OptParam *>(VT_SIGOPTPARAM);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
           VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
           VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
           verifier.VerifyVector(roomBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
           verifier.VerifyVector(roomBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMPASSWORD) &&
           verifier.VerifyVector(roomPassword()) &&
           VerifyOffset(verifier, VT_GROUPCONFIG) &&
           verifier.VerifyVector(groupConfig()) &&
           verifier.VerifyVectorOfTables(groupConfig()) &&
           VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
           VerifyOffset(verifier, VT_ALLOWEDUSER) &&
           verifier.VerifyVector(allowedUser()) &&
           verifier.VerifyVectorOfStrings(allowedUser()) &&
           VerifyOffset(verifier, VT_BLOCKEDUSER) &&
           verifier.VerifyVector(blockedUser()) &&
           verifier.VerifyVectorOfStrings(blockedUser()) &&
           VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
           verifier.VerifyVector(joinRoomGroupLabel()) &&
           VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
           verifier.VerifyVector(roomMemberBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
           VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
           VerifyOffset(verifier, VT_SIGOPTPARAM) &&
           verifier.VerifyTable(sigOptParam()) &&
           verifier.EndTable();
  }
};

struct CreateJoinRoomRequestBuilder {
  typedef CreateJoinRoomRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_worldId(uint32_t worldId) {
    fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_WORLDID, worldId, 0);
  }
  void add_lobbyId(uint64_t lobbyId) {
    fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_LOBBYID, lobbyId, 0);
  }
  void add_maxSlot(uint32_t maxSlot) {
    fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_MAXSLOT, maxSlot, 0);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_FLAGATTR, flagAttr, 0);
  }
  void add_roomBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
  }
  void add_roomSearchableIntAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
  }
  void add_roomSearchableBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
  }
  void add_roomBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
  }
  void add_roomPassword(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> roomPassword) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
  }
  void add_groupConfig(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<GroupConfig>>> groupConfig) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_GROUPCONFIG, groupConfig);
  }
  void add_passwordSlotMask(uint64_t passwordSlotMask) {
    fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
  }
  void add_allowedUser(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> allowedUser) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ALLOWEDUSER, allowedUser);
  }
  void add_blockedUser(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> blockedUser) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_BLOCKEDUSER, blockedUser);
  }
  void add_joinRoomGroupLabel(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
  }
  void add_roomMemberBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
  }
  void add_teamId(uint8_t teamId) {
    fbb_.AddElement<uint8_t>(CreateJoinRoomRequest::VT_TEAMID, teamId, 0);
  }
  void add_sigOptParam(flatbuffers::Offset<OptParam> sigOptParam) {
    fbb_.AddOffset(CreateJoinRoomRequest::VT_SIGOPTPARAM, sigOptParam);
  }
  explicit CreateJoinRoomRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<CreateJoinRoomRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<CreateJoinRoomRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint32_t maxSlot = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> roomPassword = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<GroupConfig>>> groupConfig = 0,
    uint64_t passwordSlotMask = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> allowedUser = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> blockedUser = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
    uint8_t teamId = 0,
    flatbuffers::Offset<OptParam> sigOptParam = 0) {
  CreateJoinRoomRequestBuilder builder_(_fbb);
  builder_.add_passwordSlotMask(passwordSlotMask);
  builder_.add_lobbyId(lobbyId);
  builder_.add_sigOptParam(sigOptParam);
  builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
  builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
  builder_.add_blockedUser(blockedUser);
  builder_.add_allowedUser(allowedUser);
  builder_.add_groupConfig(groupConfig);
  builder_.add_roomPassword(roomPassword);
  builder_.add_roomBinAttrExternal(roomBinAttrExternal);
  builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
  builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
  builder_.add_roomBinAttrInternal(roomBinAttrInternal);
  builder_.add_flagAttr(flagAttr);
  builder_.add_maxSlot(maxSlot);
  builder_.add_worldId(worldId);
  builder_.add_teamId(teamId);
  return builder_.Finish();
}

inline flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t worldId = 0,
    uint64_t lobbyId = 0,
    uint32_t maxSlot = 0,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
    const std::vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr,
    const std::vector<uint8_t> *roomPassword = nullptr,
    const std::vector<flatbuffers::Offset<GroupConfig>> *groupConfig = nullptr,
    uint64_t passwordSlotMask = 0,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *allowedUser = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *blockedUser = nullptr,
    const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
    uint8_t teamId = 0,
    flatbuffers::Offset<OptParam> sigOptParam = 0) {
  auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
  auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
  auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
  auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
  auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
  auto groupConfig__ = groupConfig ? _fbb.CreateVector<flatbuffers::Offset<GroupConfig>>(*groupConfig) : 0;
  auto allowedUser__ = allowedUser ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*allowedUser) : 0;
  auto blockedUser__ = blockedUser ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*blockedUser) : 0;
  auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
  auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
  return CreateCreateJoinRoomRequest(
      _fbb,
      worldId,
      lobbyId,
      maxSlot,
      flagAttr,
      roomBinAttrInternal__,
      roomSearchableIntAttrExternal__,
      roomSearchableBinAttrExternal__,
      roomBinAttrExternal__,
      roomPassword__,
      groupConfig__,
      passwordSlotMask,
      allowedUser__,
      blockedUser__,
      joinRoomGroupLabel__,
      roomMemberBinAttrInternal__,
      teamId,
      sigOptParam);
}

struct JoinRoomRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef JoinRoomRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_ROOMPASSWORD = 6,
    VT_JOINROOMGROUPLABEL = 8,
    VT_ROOMMEMBERBINATTRINTERNAL = 10,
    VT_OPTDATA = 12,
    VT_TEAMID = 14
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  const flatbuffers::Vector<uint8_t> *roomPassword() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
  }
  const flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
  }
  const PresenceOptionData *optData() const {
    return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
  }
  uint8_t teamId() const {
    return GetField<uint8_t>(VT_TEAMID, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyOffset(verifier, VT_ROOMPASSWORD) &&
           verifier.VerifyVector(roomPassword()) &&
           VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
           verifier.VerifyVector(joinRoomGroupLabel()) &&
           VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
           verifier.VerifyVector(roomMemberBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
           VerifyOffset(verifier, VT_OPTDATA) &&
           verifier.VerifyTable(optData()) &&
           VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
           verifier.EndTable();
  }
};

struct JoinRoomRequestBuilder {
  typedef JoinRoomRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(JoinRoomRequest::VT_ROOMID, roomId, 0);
  }
  void add_roomPassword(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> roomPassword) {
    fbb_.AddOffset(JoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
  }
  void add_joinRoomGroupLabel(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
    fbb_.AddOffset(JoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
  }
  void add_roomMemberBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
    fbb_.AddOffset(JoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
  }
  void add_optData(flatbuffers::Offset<PresenceOptionData> optData) {
    fbb_.AddOffset(JoinRoomRequest::VT_OPTDATA, optData);
  }
  void add_teamId(uint8_t teamId) {
    fbb_.AddElement<uint8_t>(JoinRoomRequest::VT_TEAMID, teamId, 0);
  }
  explicit JoinRoomRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<JoinRoomRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<JoinRoomRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> roomPassword = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
    flatbuffers::Offset<PresenceOptionData> optData = 0,
    uint8_t teamId = 0) {
  JoinRoomRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_optData(optData);
  builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
  builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
  builder_.add_roomPassword(roomPassword);
  builder_.add_teamId(teamId);
  return builder_.Finish();
}

inline flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    const std::vector<uint8_t> *roomPassword = nullptr,
    const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
    flatbuffers::Offset<PresenceOptionData> optData = 0,
    uint8_t teamId = 0) {
  auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
  auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
  auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
  return CreateJoinRoomRequest(
      _fbb,
      roomId,
      roomPassword__,
      joinRoomGroupLabel__,
      roomMemberBinAttrInternal__,
      optData,
      teamId);
}

struct LeaveRoomRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef LeaveRoomRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_OPTDATA = 6
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  const PresenceOptionData *optData() const {
    return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyOffset(verifier, VT_OPTDATA) &&
           verifier.VerifyTable(optData()) &&
           verifier.EndTable();
  }
};

struct LeaveRoomRequestBuilder {
  typedef LeaveRoomRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(LeaveRoomRequest::VT_ROOMID, roomId, 0);
  }
  void add_optData(flatbuffers::Offset<PresenceOptionData> optData) {
    fbb_.AddOffset(LeaveRoomRequest::VT_OPTDATA, optData);
  }
  explicit LeaveRoomRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<LeaveRoomRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<LeaveRoomRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<LeaveRoomRequest> CreateLeaveRoomRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    flatbuffers::Offset<PresenceOptionData> optData = 0) {
  LeaveRoomRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_optData(optData);
  return builder_.Finish();
}

struct GetRoomDataExternalListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetRoomDataExternalListRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMIDS = 4,
    VT_ATTRIDS = 6
  };
  const flatbuffers::Vector<uint64_t> *roomIds() const {
    return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_ROOMIDS);
  }
  const flatbuffers::Vector<uint16_t> *attrIds() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_ATTRIDS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ROOMIDS) &&
           verifier.VerifyVector(roomIds()) &&
           VerifyOffset(verifier, VT_ATTRIDS) &&
           verifier.VerifyVector(attrIds()) &&
           verifier.EndTable();
  }
};

struct GetRoomDataExternalListRequestBuilder {
  typedef GetRoomDataExternalListRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomIds(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> roomIds) {
    fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ROOMIDS, roomIds);
  }
  void add_attrIds(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrIds) {
    fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ATTRIDS, attrIds);
  }
  explicit GetRoomDataExternalListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetRoomDataExternalListRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetRoomDataExternalListRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint64_t>> roomIds = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrIds = 0) {
  GetRoomDataExternalListRequestBuilder builder_(_fbb);
  builder_.add_attrIds(attrIds);
  builder_.add_roomIds(roomIds);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint64_t> *roomIds = nullptr,
    const std::vector<uint16_t> *attrIds = nullptr) {
  auto roomIds__ = roomIds ? _fbb.CreateVector<uint64_t>(*roomIds) : 0;
  auto attrIds__ = attrIds ? _fbb.CreateVector<uint16_t>(*attrIds) : 0;
  return CreateGetRoomDataExternalListRequest(
      _fbb,
      roomIds__,
      attrIds__);
}

struct GetRoomDataExternalListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetRoomDataExternalListResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>> *rooms() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ROOMS) &&
           verifier.VerifyVector(rooms()) &&
           verifier.VerifyVectorOfTables(rooms()) &&
           verifier.EndTable();
  }
};

struct GetRoomDataExternalListResponseBuilder {
  typedef GetRoomDataExternalListResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_rooms(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>>> rooms) {
    fbb_.AddOffset(GetRoomDataExternalListResponse::VT_ROOMS, rooms);
  }
  explicit GetRoomDataExternalListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetRoomDataExternalListResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetRoomDataExternalListResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
  GetRoomDataExternalListResponseBuilder builder_(_fbb);
  builder_.add_rooms(rooms);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
  auto rooms__ = rooms ? _fbb.CreateVector<flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
  return CreateGetRoomDataExternalListResponse(
      _fbb,
      rooms__);
}

struct SetRoomDataExternalRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetRoomDataExternalRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_ROOMSEARCHABLEINTATTREXTERNAL = 6,
    VT_ROOMSEARCHABLEBINATTREXTERNAL = 8,
    VT_ROOMBINATTREXTERNAL = 10
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
           verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
           VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
           verifier.VerifyVector(roomBinAttrExternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
           verifier.EndTable();
  }
};

struct SetRoomDataExternalRequestBuilder {
  typedef SetRoomDataExternalRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(SetRoomDataExternalRequest::VT_ROOMID, roomId, 0);
  }
  void add_roomSearchableIntAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
    fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
  }
  void add_roomSearchableBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
    fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
  }
  void add_roomBinAttrExternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
    fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
  }
  explicit SetRoomDataExternalRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetRoomDataExternalRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetRoomDataExternalRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
  SetRoomDataExternalRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_roomBinAttrExternal(roomBinAttrExternal);
  builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
  builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
  return builder_.Finish();
}

inline flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    const std::vector<flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
  auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
  auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
  auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
  return CreateSetRoomDataExternalRequest(
      _fbb,
      roomId,
      roomSearchableIntAttrExternal__,
      roomSearchableBinAttrExternal__,
      roomBinAttrExternal__);
}

struct SetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetRoomDataInternalRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_FLAGFILTER = 6,
    VT_FLAGATTR = 8,
    VT_ROOMBINATTRINTERNAL = 10,
    VT_PASSWORDCONFIG = 12,
    VT_PASSWORDSLOTMASK = 14,
    VT_OWNERPRIVILEGERANK = 16
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint32_t flagFilter() const {
    return GetField<uint32_t>(VT_FLAGFILTER, 0);
  }
  uint32_t flagAttr() const {
    return GetField<uint32_t>(VT_FLAGATTR, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RoomGroupPasswordConfig>> *>(VT_PASSWORDCONFIG);
  }
  uint64_t passwordSlotMask() const {
    return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
  }
  const flatbuffers::Vector<uint16_t> *ownerPrivilegeRank() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_OWNERPRIVILEGERANK);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
           VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
           VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
           verifier.VerifyVector(roomBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
           VerifyOffset(verifier, VT_PASSWORDCONFIG) &&
           verifier.VerifyVector(passwordConfig()) &&
           verifier.VerifyVectorOfTables(passwordConfig()) &&
           VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
           VerifyOffset(verifier, VT_OWNERPRIVILEGERANK) &&
           verifier.VerifyVector(ownerPrivilegeRank()) &&
           verifier.EndTable();
  }
};

struct SetRoomDataInternalRequestBuilder {
  typedef SetRoomDataInternalRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
  }
  void add_flagFilter(uint32_t flagFilter) {
    fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGFILTER, flagFilter, 0);
  }
  void add_flagAttr(uint32_t flagAttr) {
    fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGATTR, flagAttr, 0);
  }
  void add_roomBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
    fbb_.AddOffset(SetRoomDataInternalRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
  }
  void add_passwordConfig(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig) {
    fbb_.AddOffset(SetRoomDataInternalRequest::VT_PASSWORDCONFIG, passwordConfig);
  }
  void add_passwordSlotMask(uint64_t passwordSlotMask) {
    fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
  }
  void add_ownerPrivilegeRank(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> ownerPrivilegeRank) {
    fbb_.AddOffset(SetRoomDataInternalRequest::VT_OWNERPRIVILEGERANK, ownerPrivilegeRank);
  }
  explicit SetRoomDataInternalRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetRoomDataInternalRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetRoomDataInternalRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint32_t flagFilter = 0,
    uint32_t flagAttr = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig = 0,
    uint64_t passwordSlotMask = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> ownerPrivilegeRank = 0) {
  SetRoomDataInternalRequestBuilder builder_(_fbb);
  builder_.add_passwordSlotMask(passwordSlotMask);
  builder_.add_roomId(roomId);
  builder_.add_ownerPrivilegeRank(ownerPrivilegeRank);
  builder_.add_passwordConfig(passwordConfig);
  builder_.add_roomBinAttrInternal(roomBinAttrInternal);
  builder_.add_flagAttr(flagAttr);
  builder_.add_flagFilter(flagFilter);
  return builder_.Finish();
}

inline flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint32_t flagFilter = 0,
    uint32_t flagAttr = 0,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
    const std::vector<flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig = nullptr,
    uint64_t passwordSlotMask = 0,
    const std::vector<uint16_t> *ownerPrivilegeRank = nullptr) {
  auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
  auto passwordConfig__ = passwordConfig ? _fbb.CreateVector<flatbuffers::Offset<RoomGroupPasswordConfig>>(*passwordConfig) : 0;
  auto ownerPrivilegeRank__ = ownerPrivilegeRank ? _fbb.CreateVector<uint16_t>(*ownerPrivilegeRank) : 0;
  return CreateSetRoomDataInternalRequest(
      _fbb,
      roomId,
      flagFilter,
      flagAttr,
      roomBinAttrInternal__,
      passwordConfig__,
      passwordSlotMask,
      ownerPrivilegeRank__);
}

struct SetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SetRoomMemberDataInternalRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_MEMBERID = 6,
    VT_TEAMID = 8,
    VT_ROOMMEMBERBINATTRINTERNAL = 10
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint16_t memberId() const {
    return GetField<uint16_t>(VT_MEMBERID, 0);
  }
  uint8_t teamId() const {
    return GetField<uint8_t>(VT_TEAMID, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
           VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
           VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
           verifier.VerifyVector(roomMemberBinAttrInternal()) &&
           verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
           verifier.EndTable();
  }
};

struct SetRoomMemberDataInternalRequestBuilder {
  typedef SetRoomMemberDataInternalRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(SetRoomMemberDataInternalRequest::VT_ROOMID, roomId, 0);
  }
  void add_memberId(uint16_t memberId) {
    fbb_.AddElement<uint16_t>(SetRoomMemberDataInternalRequest::VT_MEMBERID, memberId, 0);
  }
  void add_teamId(uint8_t teamId) {
    fbb_.AddElement<uint8_t>(SetRoomMemberDataInternalRequest::VT_TEAMID, teamId, 0);
  }
  void add_roomMemberBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
    fbb_.AddOffset(SetRoomMemberDataInternalRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
  }
  explicit SetRoomMemberDataInternalRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SetRoomMemberDataInternalRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SetRoomMemberDataInternalRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint16_t memberId = 0,
    uint8_t teamId = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0) {
  SetRoomMemberDataInternalRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
  builder_.add_memberId(memberId);
  builder_.add_teamId(teamId);
  return builder_.Finish();
}

inline flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint16_t memberId = 0,
    uint8_t teamId = 0,
    const std::vector<flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr) {
  auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
  return CreateSetRoomMemberDataInternalRequest(
      _fbb,
      roomId,
      memberId,
      teamId,
      roomMemberBinAttrInternal__);
}

struct GetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetRoomDataInternalRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_ATTRID = 6
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  const flatbuffers::Vector<uint16_t> *attrId() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyOffset(verifier, VT_ATTRID) &&
           verifier.VerifyVector(attrId()) &&
           verifier.EndTable();
  }
};

struct GetRoomDataInternalRequestBuilder {
  typedef GetRoomDataInternalRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(GetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
  }
  void add_attrId(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrId) {
    fbb_.AddOffset(GetRoomDataInternalRequest::VT_ATTRID, attrId);
  }
  explicit GetRoomDataInternalRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetRoomDataInternalRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetRoomDataInternalRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> attrId = 0) {
  GetRoomDataInternalRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_attrId(attrId);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    const std::vector<uint16_t> *attrId = nullptr) {
  auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
  return CreateGetRoomDataInternalRequest(
      _fbb,
      roomId,
      attrId__);
}

struct RoomMemberUpdateInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomMemberUpdateInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMMEMBERDATAINTERNAL = 4,
    VT_EVENTCAUSE = 6,
    VT_OPTDATA = 8
  };
  const RoomMemberDataInternal *roomMemberDataInternal() const {
    return GetPointer<const RoomMemberDataInternal *>(VT_ROOMMEMBERDATAINTERNAL);
  }
  uint8_t eventCause() const {
    return GetField<uint8_t>(VT_EVENTCAUSE, 0);
  }
  const PresenceOptionData *optData() const {
    return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_ROOMMEMBERDATAINTERNAL) &&
           verifier.VerifyTable(roomMemberDataInternal()) &&
           VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
           VerifyOffset(verifier, VT_OPTDATA) &&
           verifier.VerifyTable(optData()) &&
           verifier.EndTable();
  }
};

struct RoomMemberUpdateInfoBuilder {
  typedef RoomMemberUpdateInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomMemberDataInternal(flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal) {
    fbb_.AddOffset(RoomMemberUpdateInfo::VT_ROOMMEMBERDATAINTERNAL, roomMemberDataInternal);
  }
  void add_eventCause(uint8_t eventCause) {
    fbb_.AddElement<uint8_t>(RoomMemberUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
  }
  void add_optData(flatbuffers::Offset<PresenceOptionData> optData) {
    fbb_.AddOffset(RoomMemberUpdateInfo::VT_OPTDATA, optData);
  }
  explicit RoomMemberUpdateInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomMemberUpdateInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomMemberUpdateInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomMemberUpdateInfo> CreateRoomMemberUpdateInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal = 0,
    uint8_t eventCause = 0,
    flatbuffers::Offset<PresenceOptionData> optData = 0) {
  RoomMemberUpdateInfoBuilder builder_(_fbb);
  builder_.add_optData(optData);
  builder_.add_roomMemberDataInternal(roomMemberDataInternal);
  builder_.add_eventCause(eventCause);
  return builder_.Finish();
}

struct RoomUpdateInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomUpdateInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_EVENTCAUSE = 4,
    VT_ERRORCODE = 6,
    VT_OPTDATA = 8
  };
  uint8_t eventCause() const {
    return GetField<uint8_t>(VT_EVENTCAUSE, 0);
  }
  int32_t errorCode() const {
    return GetField<int32_t>(VT_ERRORCODE, 0);
  }
  const PresenceOptionData *optData() const {
    return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
           VerifyField<int32_t>(verifier, VT_ERRORCODE, 4) &&
           VerifyOffset(verifier, VT_OPTDATA) &&
           verifier.VerifyTable(optData()) &&
           verifier.EndTable();
  }
};

struct RoomUpdateInfoBuilder {
  typedef RoomUpdateInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_eventCause(uint8_t eventCause) {
    fbb_.AddElement<uint8_t>(RoomUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
  }
  void add_errorCode(int32_t errorCode) {
    fbb_.AddElement<int32_t>(RoomUpdateInfo::VT_ERRORCODE, errorCode, 0);
  }
  void add_optData(flatbuffers::Offset<PresenceOptionData> optData) {
    fbb_.AddOffset(RoomUpdateInfo::VT_OPTDATA, optData);
  }
  explicit RoomUpdateInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomUpdateInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomUpdateInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomUpdateInfo> CreateRoomUpdateInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t eventCause = 0,
    int32_t errorCode = 0,
    flatbuffers::Offset<PresenceOptionData> optData = 0) {
  RoomUpdateInfoBuilder builder_(_fbb);
  builder_.add_optData(optData);
  builder_.add_errorCode(errorCode);
  builder_.add_eventCause(eventCause);
  return builder_.Finish();
}

struct RoomDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomDataInternalUpdateInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NEWROOMDATAINTERNAL = 4,
    VT_PREVFLAGATTR = 6,
    VT_PREVROOMPASSWORDSLOTMASK = 8,
    VT_NEWROOMGROUP = 10,
    VT_NEWROOMBINATTRINTERNAL = 12
  };
  const RoomDataInternal *newRoomDataInternal() const {
    return GetPointer<const RoomDataInternal *>(VT_NEWROOMDATAINTERNAL);
  }
  uint32_t prevFlagAttr() const {
    return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
  }
  uint64_t prevRoomPasswordSlotMask() const {
    return GetField<uint64_t>(VT_PREVROOMPASSWORDSLOTMASK, 0);
  }
  const flatbuffers::Vector<uint8_t> *newRoomGroup() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_NEWROOMGROUP);
  }
  const flatbuffers::Vector<uint16_t> *newRoomBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_NEWROOMBINATTRINTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NEWROOMDATAINTERNAL) &&
           verifier.VerifyTable(newRoomDataInternal()) &&
           VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
           VerifyField<uint64_t>(verifier, VT_PREVROOMPASSWORDSLOTMASK, 8) &&
           VerifyOffset(verifier, VT_NEWROOMGROUP) &&
           verifier.VerifyVector(newRoomGroup()) &&
           VerifyOffset(verifier, VT_NEWROOMBINATTRINTERNAL) &&
           verifier.VerifyVector(newRoomBinAttrInternal()) &&
           verifier.EndTable();
  }
};

struct RoomDataInternalUpdateInfoBuilder {
  typedef RoomDataInternalUpdateInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_newRoomDataInternal(flatbuffers::Offset<RoomDataInternal> newRoomDataInternal) {
    fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMDATAINTERNAL, newRoomDataInternal);
  }
  void add_prevFlagAttr(uint32_t prevFlagAttr) {
    fbb_.AddElement<uint32_t>(RoomDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
  }
  void add_prevRoomPasswordSlotMask(uint64_t prevRoomPasswordSlotMask) {
    fbb_.AddElement<uint64_t>(RoomDataInternalUpdateInfo::VT_PREVROOMPASSWORDSLOTMASK, prevRoomPasswordSlotMask, 0);
  }
  void add_newRoomGroup(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> newRoomGroup) {
    fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMGROUP, newRoomGroup);
  }
  void add_newRoomBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal) {
    fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMBINATTRINTERNAL, newRoomBinAttrInternal);
  }
  explicit RoomDataInternalUpdateInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomDataInternalUpdateInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomDataInternalUpdateInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
    uint32_t prevFlagAttr = 0,
    uint64_t prevRoomPasswordSlotMask = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> newRoomGroup = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal = 0) {
  RoomDataInternalUpdateInfoBuilder builder_(_fbb);
  builder_.add_prevRoomPasswordSlotMask(prevRoomPasswordSlotMask);
  builder_.add_newRoomBinAttrInternal(newRoomBinAttrInternal);
  builder_.add_newRoomGroup(newRoomGroup);
  builder_.add_prevFlagAttr(prevFlagAttr);
  builder_.add_newRoomDataInternal(newRoomDataInternal);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
    uint32_t prevFlagAttr = 0,
    uint64_t prevRoomPasswordSlotMask = 0,
    const std::vector<uint8_t> *newRoomGroup = nullptr,
    const std::vector<uint16_t> *newRoomBinAttrInternal = nullptr) {
  auto newRoomGroup__ = newRoomGroup ? _fbb.CreateVector<uint8_t>(*newRoomGroup) : 0;
  auto newRoomBinAttrInternal__ = newRoomBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomBinAttrInternal) : 0;
  return CreateRoomDataInternalUpdateInfo(
      _fbb,
      newRoomDataInternal,
      prevFlagAttr,
      prevRoomPasswordSlotMask,
      newRoomGroup__,
      newRoomBinAttrInternal__);
}

struct RoomMemberDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomMemberDataInternalUpdateInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NEWROOMMEMBERDATAINTERNAL = 4,
    VT_PREVFLAGATTR = 6,
    VT_PREVTEAMID = 8,
    VT_NEWROOMMEMBERBINATTRINTERNAL = 10
  };
  const RoomMemberDataInternal *newRoomMemberDataInternal() const {
    return GetPointer<const RoomMemberDataInternal *>(VT_NEWROOMMEMBERDATAINTERNAL);
  }
  uint32_t prevFlagAttr() const {
    return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
  }
  uint8_t prevTeamId() const {
    return GetField<uint8_t>(VT_PREVTEAMID, 0);
  }
  const flatbuffers::Vector<uint16_t> *newRoomMemberBinAttrInternal() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_NEWROOMMEMBERBINATTRINTERNAL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NEWROOMMEMBERDATAINTERNAL) &&
           verifier.VerifyTable(newRoomMemberDataInternal()) &&
           VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
           VerifyField<uint8_t>(verifier, VT_PREVTEAMID, 1) &&
           VerifyOffset(verifier, VT_NEWROOMMEMBERBINATTRINTERNAL) &&
           verifier.VerifyVector(newRoomMemberBinAttrInternal()) &&
           verifier.EndTable();
  }
};

struct RoomMemberDataInternalUpdateInfoBuilder {
  typedef RoomMemberDataInternalUpdateInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_newRoomMemberDataInternal(flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal) {
    fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERDATAINTERNAL, newRoomMemberDataInternal);
  }
  void add_prevFlagAttr(uint32_t prevFlagAttr) {
    fbb_.AddElement<uint32_t>(RoomMemberDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
  }
  void add_prevTeamId(uint8_t prevTeamId) {
    fbb_.AddElement<uint8_t>(RoomMemberDataInternalUpdateInfo::VT_PREVTEAMID, prevTeamId, 0);
  }
  void add_newRoomMemberBinAttrInternal(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal) {
    fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERBINATTRINTERNAL, newRoomMemberBinAttrInternal);
  }
  explicit RoomMemberDataInternalUpdateInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomMemberDataInternalUpdateInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
    uint32_t prevFlagAttr = 0,
    uint8_t prevTeamId = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal = 0) {
  RoomMemberDataInternalUpdateInfoBuilder builder_(_fbb);
  builder_.add_newRoomMemberBinAttrInternal(newRoomMemberBinAttrInternal);
  builder_.add_prevFlagAttr(prevFlagAttr);
  builder_.add_newRoomMemberDataInternal(newRoomMemberDataInternal);
  builder_.add_prevTeamId(prevTeamId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
    uint32_t prevFlagAttr = 0,
    uint8_t prevTeamId = 0,
    const std::vector<uint16_t> *newRoomMemberBinAttrInternal = nullptr) {
  auto newRoomMemberBinAttrInternal__ = newRoomMemberBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomMemberBinAttrInternal) : 0;
  return CreateRoomMemberDataInternalUpdateInfo(
      _fbb,
      newRoomMemberDataInternal,
      prevFlagAttr,
      prevTeamId,
      newRoomMemberBinAttrInternal__);
}

struct GetPingInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetPingInfoResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SERVERID = 4,
    VT_WORLDID = 6,
    VT_ROOMID = 8,
    VT_RTT = 10
  };
  uint16_t serverId() const {
    return GetField<uint16_t>(VT_SERVERID, 0);
  }
  uint32_t worldId() const {
    return GetField<uint32_t>(VT_WORLDID, 0);
  }
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint32_t rtt() const {
    return GetField<uint32_t>(VT_RTT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
           VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint32_t>(verifier, VT_RTT, 4) &&
           verifier.EndTable();
  }
};

struct GetPingInfoResponseBuilder {
  typedef GetPingInfoResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_serverId(uint16_t serverId) {
    fbb_.AddElement<uint16_t>(GetPingInfoResponse::VT_SERVERID, serverId, 0);
  }
  void add_worldId(uint32_t worldId) {
    fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_WORLDID, worldId, 0);
  }
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(GetPingInfoResponse::VT_ROOMID, roomId, 0);
  }
  void add_rtt(uint32_t rtt) {
    fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_RTT, rtt, 0);
  }
  explicit GetPingInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetPingInfoResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetPingInfoResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetPingInfoResponse> CreateGetPingInfoResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint16_t serverId = 0,
    uint32_t worldId = 0,
    uint64_t roomId = 0,
    uint32_t rtt = 0) {
  GetPingInfoResponseBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_rtt(rtt);
  builder_.add_worldId(worldId);
  builder_.add_serverId(serverId);
  return builder_.Finish();
}

struct SendRoomMessageRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SendRoomMessageRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROOMID = 4,
    VT_CASTTYPE = 6,
    VT_DST = 8,
    VT_MSG = 10,
    VT_OPTION = 12
  };
  uint64_t roomId() const {
    return GetField<uint64_t>(VT_ROOMID, 0);
  }
  uint8_t castType() const {
    return GetField<uint8_t>(VT_CASTTYPE, 0);
  }
  const flatbuffers::Vector<uint16_t> *dst() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_DST);
  }
  const flatbuffers::Vector<uint8_t> *msg() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MSG);
  }
  uint8_t option() const {
    return GetField<uint8_t>(VT_OPTION, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
           VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyVector(dst()) &&
           VerifyOffset(verifier, VT_MSG) &&
           verifier.VerifyVector(msg()) &&
           VerifyField<uint8_t>(verifier, VT_OPTION, 1) &&
           verifier.EndTable();
  }
};

struct SendRoomMessageRequestBuilder {
  typedef SendRoomMessageRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_roomId(uint64_t roomId) {
    fbb_.AddElement<uint64_t>(SendRoomMessageRequest::VT_ROOMID, roomId, 0);
  }
  void add_castType(uint8_t castType) {
    fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_CASTTYPE, castType, 0);
  }
  void add_dst(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> dst) {
    fbb_.AddOffset(SendRoomMessageRequest::VT_DST, dst);
  }
  void add_msg(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> msg) {
    fbb_.AddOffset(SendRoomMessageRequest::VT_MSG, msg);
  }
  void add_option(uint8_t option) {
    fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_OPTION, option, 0);
  }
  explicit SendRoomMessageRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SendRoomMessageRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SendRoomMessageRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint8_t castType = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> dst = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> msg = 0,
    uint8_t option = 0) {
  SendRoomMessageRequestBuilder builder_(_fbb);
  builder_.add_roomId(roomId);
  builder_.add_msg(msg);
  builder_.add_dst(dst);
  builder_.add_option(option);
  builder_.add_castType(castType);
  return builder_.Finish();
}

inline flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t roomId = 0,
    uint8_t castType = 0,
    const std::vector<uint16_t> *dst = nullptr,
    const std::vector<uint8_t> *msg = nullptr,
    uint8_t option = 0) {
  auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
  auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
  return CreateSendRoomMessageRequest(
      _fbb,
      roomId,
      castType,
      dst__,
      msg__,
      option);
}

struct RoomMessageInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RoomMessageInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FILTERED = 4,
    VT_CASTTYPE = 6,
    VT_DST = 8,
    VT_SRCMEMBER = 10,
    VT_MSG = 12
  };
  bool filtered() const {
    return GetField<uint8_t>(VT_FILTERED, 0) != 0;
  }
  uint8_t castType() const {
    return GetField<uint8_t>(VT_CASTTYPE, 0);
  }
  const flatbuffers::Vector<uint16_t> *dst() const {
    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_DST);
  }
  const UserInfo2 *srcMember() const {
    return GetPointer<const UserInfo2 *>(VT_SRCMEMBER);
  }
  const flatbuffers::Vector<uint8_t> *msg() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MSG);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_FILTERED, 1) &&
           VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
           VerifyOffset(verifier, VT_DST) &&
           verifier.VerifyVector(dst()) &&
           VerifyOffset(verifier, VT_SRCMEMBER) &&
           verifier.VerifyTable(srcMember()) &&
           VerifyOffset(verifier, VT_MSG) &&
           verifier.VerifyVector(msg()) &&
           verifier.EndTable();
  }
};

struct RoomMessageInfoBuilder {
  typedef RoomMessageInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_filtered(bool filtered) {
    fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_FILTERED, static_cast<uint8_t>(filtered), 0);
  }
  void add_castType(uint8_t castType) {
    fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_CASTTYPE, castType, 0);
  }
  void add_dst(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> dst) {
    fbb_.AddOffset(RoomMessageInfo::VT_DST, dst);
  }
  void add_srcMember(flatbuffers::Offset<UserInfo2> srcMember) {
    fbb_.AddOffset(RoomMessageInfo::VT_SRCMEMBER, srcMember);
  }
  void add_msg(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> msg) {
    fbb_.AddOffset(RoomMessageInfo::VT_MSG, msg);
  }
  explicit RoomMessageInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RoomMessageInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RoomMessageInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool filtered = false,
    uint8_t castType = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> dst = 0,
    flatbuffers::Offset<UserInfo2> srcMember = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> msg = 0) {
  RoomMessageInfoBuilder builder_(_fbb);
  builder_.add_msg(msg);
  builder_.add_srcMember(srcMember);
  builder_.add_dst(dst);
  builder_.add_castType(castType);
  builder_.add_filtered(filtered);
  return builder_.Finish();
}

inline flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    bool filtered = false,
    uint8_t castType = 0,
    const std::vector<uint16_t> *dst = nullptr,
    flatbuffers::Offset<UserInfo2> srcMember = 0,
    const std::vector<uint8_t> *msg = nullptr) {
  auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
  auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
  return CreateRoomMessageInfo(
      _fbb,
      filtered,
      castType,
      dst__,
      srcMember,
      msg__);
}

struct MessageDetails FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MessageDetailsBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COMMUNICATIONID = 4,
    VT_MSGID = 6,
    VT_MAINTYPE = 8,
    VT_SUBTYPE = 10,
    VT_MSGFEATURES = 12,
    VT_SUBJECT = 14,
    VT_BODY = 16,
    VT_DATA = 18
  };
  const flatbuffers::String *communicationId() const {
    return GetPointer<const flatbuffers::String *>(VT_COMMUNICATIONID);
  }
  uint64_t msgId() const {
    return GetField<uint64_t>(VT_MSGID, 0);
  }
  uint16_t mainType() const {
    return GetField<uint16_t>(VT_MAINTYPE, 0);
  }
  uint16_t subType() const {
    return GetField<uint16_t>(VT_SUBTYPE, 0);
  }
  uint32_t msgFeatures() const {
    return GetField<uint32_t>(VT_MSGFEATURES, 0);
  }
  const flatbuffers::String *subject() const {
    return GetPointer<const flatbuffers::String *>(VT_SUBJECT);
  }
  const flatbuffers::String *body() const {
    return GetPointer<const flatbuffers::String *>(VT_BODY);
  }
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_COMMUNICATIONID) &&
           verifier.VerifyString(communicationId()) &&
           VerifyField<uint64_t>(verifier, VT_MSGID, 8) &&
           VerifyField<uint16_t>(verifier, VT_MAINTYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_SUBTYPE, 2) &&
           VerifyField<uint32_t>(verifier, VT_MSGFEATURES, 4) &&
           VerifyOffset(verifier, VT_SUBJECT) &&
           verifier.VerifyString(subject()) &&
           VerifyOffset(verifier, VT_BODY) &&
           verifier.VerifyString(body()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct MessageDetailsBuilder {
  typedef MessageDetails Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_communicationId(flatbuffers::Offset<flatbuffers::String> communicationId) {
    fbb_.AddOffset(MessageDetails::VT_COMMUNICATIONID, communicationId);
  }
  void add_msgId(uint64_t msgId) {
    fbb_.AddElement<uint64_t>(MessageDetails::VT_MSGID, msgId, 0);
  }
  void add_mainType(uint16_t mainType) {
    fbb_.AddElement<uint16_t>(MessageDetails::VT_MAINTYPE, mainType, 0);
  }
  void add_subType(uint16_t subType) {
    fbb_.AddElement<uint16_t>(MessageDetails::VT_SUBTYPE, subType, 0);
  }
  void add_msgFeatures(uint32_t msgFeatures) {
    fbb_.AddElement<uint32_t>(MessageDetails::VT_MSGFEATURES, msgFeatures, 0);
  }
  void add_subject(flatbuffers::Offset<flatbuffers::String> subject) {
    fbb_.AddOffset(MessageDetails::VT_SUBJECT, subject);
  }
  void add_body(flatbuffers::Offset<flatbuffers::String> body) {
    fbb_.AddOffset(MessageDetails::VT_BODY, body);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(MessageDetails::VT_DATA, data);
  }
  explicit MessageDetailsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<MessageDetails> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<MessageDetails>(end);
    return o;
  }
};

inline flatbuffers::Offset<MessageDetails> CreateMessageDetails(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> communicationId = 0,
    uint64_t msgId = 0,
    uint16_t mainType = 0,
    uint16_t subType = 0,
    uint32_t msgFeatures = 0,
    flatbuffers::Offset<flatbuffers::String> subject = 0,
    flatbuffers::Offset<flatbuffers::String> body = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
  MessageDetailsBuilder builder_(_fbb);
  builder_.add_msgId(msgId);
  builder_.add_data(data);
  builder_.add_body(body);
  builder_.add_subject(subject);
  builder_.add_msgFeatures(msgFeatures);
  builder_.add_communicationId(communicationId);
  builder_.add_subType(subType);
  builder_.add_mainType(mainType);
  return builder_.Finish();
}

inline flatbuffers::Offset<MessageDetails> CreateMessageDetailsDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *communicationId = nullptr,
    uint64_t msgId = 0,
    uint16_t mainType = 0,
    uint16_t subType = 0,
    uint32_t msgFeatures = 0,
    const char *subject = nullptr,
    const char *body = nullptr,
    const std::vector<uint8_t> *data = nullptr) {
  auto communicationId__ = communicationId ? _fbb.CreateString(communicationId) : 0;
  auto subject__ = subject ? _fbb.CreateString(subject) : 0;
  auto body__ = body ? _fbb.CreateString(body) : 0;
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return CreateMessageDetails(
      _fbb,
      communicationId__,
      msgId,
      mainType,
      subType,
      msgFeatures,
      subject__,
      body__,
      data__);
}

struct SendMessageRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef SendMessageRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MESSAGE = 4,
    VT_NPIDS = 6
  };
  const flatbuffers::Vector<uint8_t> *message() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
  }
  const MessageDetails *message_nested_root() const {
    return flatbuffers::GetRoot<MessageDetails>(message()->Data());
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *npids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_NPIDS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           verifier.VerifyVector(message()) &&
           verifier.VerifyNestedFlatBuffer<MessageDetails>(message(), nullptr) &&
           VerifyOffset(verifier, VT_NPIDS) &&
           verifier.VerifyVector(npids()) &&
           verifier.VerifyVectorOfStrings(npids()) &&
           verifier.EndTable();
  }
};

struct SendMessageRequestBuilder {
  typedef SendMessageRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
    fbb_.AddOffset(SendMessageRequest::VT_MESSAGE, message);
  }
  void add_npids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> npids) {
    fbb_.AddOffset(SendMessageRequest::VT_NPIDS, npids);
  }
  explicit SendMessageRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<SendMessageRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<SendMessageRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> npids = 0) {
  SendMessageRequestBuilder builder_(_fbb);
  builder_.add_npids(npids);
  builder_.add_message(message);
  return builder_.Finish();
}

inline flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *message = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *npids = nullptr) {
  auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
  auto npids__ = npids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*npids) : 0;
  return CreateSendMessageRequest(
      _fbb,
      message__,
      npids__);
}

struct BoardInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef BoardInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RANKLIMIT = 4,
    VT_UPDATEMODE = 6,
    VT_SORTMODE = 8,
    VT_UPLOADNUMLIMIT = 10,
    VT_UPLOADSIZELIMIT = 12
  };
  uint32_t rankLimit() const {
    return GetField<uint32_t>(VT_RANKLIMIT, 0);
  }
  uint32_t updateMode() const {
    return GetField<uint32_t>(VT_UPDATEMODE, 0);
  }
  uint32_t sortMode() const {
    return GetField<uint32_t>(VT_SORTMODE, 0);
  }
  uint32_t uploadNumLimit() const {
    return GetField<uint32_t>(VT_UPLOADNUMLIMIT, 0);
  }
  uint32_t uploadSizeLimit() const {
    return GetField<uint32_t>(VT_UPLOADSIZELIMIT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_RANKLIMIT, 4) &&
           VerifyField<uint32_t>(verifier, VT_UPDATEMODE, 4) &&
           VerifyField<uint32_t>(verifier, VT_SORTMODE, 4) &&
           VerifyField<uint32_t>(verifier, VT_UPLOADNUMLIMIT, 4) &&
           VerifyField<uint32_t>(verifier, VT_UPLOADSIZELIMIT, 4) &&
           verifier.EndTable();
  }
};

struct BoardInfoBuilder {
  typedef BoardInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_rankLimit(uint32_t rankLimit) {
    fbb_.AddElement<uint32_t>(BoardInfo::VT_RANKLIMIT, rankLimit, 0);
  }
  void add_updateMode(uint32_t updateMode) {
    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPDATEMODE, updateMode, 0);
  }
  void add_sortMode(uint32_t sortMode) {
    fbb_.AddElement<uint32_t>(BoardInfo::VT_SORTMODE, sortMode, 0);
  }
  void add_uploadNumLimit(uint32_t uploadNumLimit) {
    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADNUMLIMIT, uploadNumLimit, 0);
  }
  void add_uploadSizeLimit(uint32_t uploadSizeLimit) {
    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADSIZELIMIT, uploadSizeLimit, 0);
  }
  explicit BoardInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<BoardInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<BoardInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<BoardInfo> CreateBoardInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t rankLimit = 0,
    uint32_t updateMode = 0,
    uint32_t sortMode = 0,
    uint32_t uploadNumLimit = 0,
    uint32_t uploadSizeLimit = 0) {
  BoardInfoBuilder builder_(_fbb);
  builder_.add_uploadSizeLimit(uploadSizeLimit);
  builder_.add_uploadNumLimit(uploadNumLimit);
  builder_.add_sortMode(sortMode);
  builder_.add_updateMode(updateMode);
  builder_.add_rankLimit(rankLimit);
  return builder_.Finish();
}

struct RecordScoreRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RecordScoreRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_PCID = 6,
    VT_SCORE = 8,
    VT_COMMENT = 10,
    VT_DATA = 12
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  int32_t pcId() const {
    return GetField<int32_t>(VT_PCID, 0);
  }
  int64_t score() const {
    return GetField<int64_t>(VT_SCORE, 0);
  }
  const flatbuffers::String *comment() const {
    return GetPointer<const flatbuffers::String *>(VT_COMMENT);
  }
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyField<int32_t>(verifier, VT_PCID, 4) &&
           VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
           VerifyOffset(verifier, VT_COMMENT) &&
           verifier.VerifyString(comment()) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct RecordScoreRequestBuilder {
  typedef RecordScoreRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(RecordScoreRequest::VT_BOARDID, boardId, 0);
  }
  void add_pcId(int32_t pcId) {
    fbb_.AddElement<int32_t>(RecordScoreRequest::VT_PCID, pcId, 0);
  }
  void add_score(int64_t score) {
    fbb_.AddElement<int64_t>(RecordScoreRequest::VT_SCORE, score, 0);
  }
  void add_comment(flatbuffers::Offset<flatbuffers::String> comment) {
    fbb_.AddOffset(RecordScoreRequest::VT_COMMENT, comment);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(RecordScoreRequest::VT_DATA, data);
  }
  explicit RecordScoreRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RecordScoreRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RecordScoreRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    int32_t pcId = 0,
    int64_t score = 0,
    flatbuffers::Offset<flatbuffers::String> comment = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
  RecordScoreRequestBuilder builder_(_fbb);
  builder_.add_score(score);
  builder_.add_data(data);
  builder_.add_comment(comment);
  builder_.add_pcId(pcId);
  builder_.add_boardId(boardId);
  return builder_.Finish();
}

inline flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    int32_t pcId = 0,
    int64_t score = 0,
    const char *comment = nullptr,
    const std::vector<uint8_t> *data = nullptr) {
  auto comment__ = comment ? _fbb.CreateString(comment) : 0;
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return CreateRecordScoreRequest(
      _fbb,
      boardId,
      pcId,
      score,
      comment__,
      data__);
}

struct GetScoreRangeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetScoreRangeRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_STARTRANK = 6,
    VT_NUMRANKS = 8,
    VT_WITHCOMMENT = 10,
    VT_WITHGAMEINFO = 12
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  uint32_t startRank() const {
    return GetField<uint32_t>(VT_STARTRANK, 0);
  }
  uint32_t numRanks() const {
    return GetField<uint32_t>(VT_NUMRANKS, 0);
  }
  bool withComment() const {
    return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
  }
  bool withGameInfo() const {
    return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyField<uint32_t>(verifier, VT_STARTRANK, 4) &&
           VerifyField<uint32_t>(verifier, VT_NUMRANKS, 4) &&
           VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
           VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
           verifier.EndTable();
  }
};

struct GetScoreRangeRequestBuilder {
  typedef GetScoreRangeRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_BOARDID, boardId, 0);
  }
  void add_startRank(uint32_t startRank) {
    fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_STARTRANK, startRank, 0);
  }
  void add_numRanks(uint32_t numRanks) {
    fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_NUMRANKS, numRanks, 0);
  }
  void add_withComment(bool withComment) {
    fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
  }
  void add_withGameInfo(bool withGameInfo) {
    fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
  }
  explicit GetScoreRangeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetScoreRangeRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetScoreRangeRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetScoreRangeRequest> CreateGetScoreRangeRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    uint32_t startRank = 0,
    uint32_t numRanks = 0,
    bool withComment = false,
    bool withGameInfo = false) {
  GetScoreRangeRequestBuilder builder_(_fbb);
  builder_.add_numRanks(numRanks);
  builder_.add_startRank(startRank);
  builder_.add_boardId(boardId);
  builder_.add_withGameInfo(withGameInfo);
  builder_.add_withComment(withComment);
  return builder_.Finish();
}

struct ScoreNpIdPcId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ScoreNpIdPcIdBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NPID = 4,
    VT_PCID = 6
  };
  const flatbuffers::String *npid() const {
    return GetPointer<const flatbuffers::String *>(VT_NPID);
  }
  int32_t pcId() const {
    return GetField<int32_t>(VT_PCID, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NPID) &&
           verifier.VerifyString(npid()) &&
           VerifyField<int32_t>(verifier, VT_PCID, 4) &&
           verifier.EndTable();
  }
};

struct ScoreNpIdPcIdBuilder {
  typedef ScoreNpIdPcId Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_npid(flatbuffers::Offset<flatbuffers::String> npid) {
    fbb_.AddOffset(ScoreNpIdPcId::VT_NPID, npid);
  }
  void add_pcId(int32_t pcId) {
    fbb_.AddElement<int32_t>(ScoreNpIdPcId::VT_PCID, pcId, 0);
  }
  explicit ScoreNpIdPcIdBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ScoreNpIdPcId> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ScoreNpIdPcId>(end);
    return o;
  }
};

inline flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcId(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> npid = 0,
    int32_t pcId = 0) {
  ScoreNpIdPcIdBuilder builder_(_fbb);
  builder_.add_pcId(pcId);
  builder_.add_npid(npid);
  return builder_.Finish();
}

inline flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcIdDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *npid = nullptr,
    int32_t pcId = 0) {
  auto npid__ = npid ? _fbb.CreateString(npid) : 0;
  return CreateScoreNpIdPcId(
      _fbb,
      npid__,
      pcId);
}

struct GetScoreNpIdRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetScoreNpIdRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_NPIDS = 6,
    VT_WITHCOMMENT = 8,
    VT_WITHGAMEINFO = 10
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<ScoreNpIdPcId>> *npids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ScoreNpIdPcId>> *>(VT_NPIDS);
  }
  bool withComment() const {
    return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
  }
  bool withGameInfo() const {
    return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyOffset(verifier, VT_NPIDS) &&
           verifier.VerifyVector(npids()) &&
           verifier.VerifyVectorOfTables(npids()) &&
           VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
           VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
           verifier.EndTable();
  }
};

struct GetScoreNpIdRequestBuilder {
  typedef GetScoreNpIdRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(GetScoreNpIdRequest::VT_BOARDID, boardId, 0);
  }
  void add_npids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreNpIdPcId>>> npids) {
    fbb_.AddOffset(GetScoreNpIdRequest::VT_NPIDS, npids);
  }
  void add_withComment(bool withComment) {
    fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
  }
  void add_withGameInfo(bool withGameInfo) {
    fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
  }
  explicit GetScoreNpIdRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetScoreNpIdRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetScoreNpIdRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreNpIdPcId>>> npids = 0,
    bool withComment = false,
    bool withGameInfo = false) {
  GetScoreNpIdRequestBuilder builder_(_fbb);
  builder_.add_npids(npids);
  builder_.add_boardId(boardId);
  builder_.add_withGameInfo(withGameInfo);
  builder_.add_withComment(withComment);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    const std::vector<flatbuffers::Offset<ScoreNpIdPcId>> *npids = nullptr,
    bool withComment = false,
    bool withGameInfo = false) {
  auto npids__ = npids ? _fbb.CreateVector<flatbuffers::Offset<ScoreNpIdPcId>>(*npids) : 0;
  return CreateGetScoreNpIdRequest(
      _fbb,
      boardId,
      npids__,
      withComment,
      withGameInfo);
}

struct GetScoreFriendsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetScoreFriendsRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_INCLUDE_SELF = 6,
    VT_MAX = 8,
    VT_WITHCOMMENT = 10,
    VT_WITHGAMEINFO = 12
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  bool include_self() const {
    return GetField<uint8_t>(VT_INCLUDE_SELF, 0) != 0;
  }
  uint32_t max() const {
    return GetField<uint32_t>(VT_MAX, 0);
  }
  bool withComment() const {
    return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
  }
  bool withGameInfo() const {
    return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyField<uint8_t>(verifier, VT_INCLUDE_SELF, 1) &&
           VerifyField<uint32_t>(verifier, VT_MAX, 4) &&
           VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
           VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
           verifier.EndTable();
  }
};

struct GetScoreFriendsRequestBuilder {
  typedef GetScoreFriendsRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_BOARDID, boardId, 0);
  }
  void add_include_self(bool include_self) {
    fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_INCLUDE_SELF, static_cast<uint8_t>(include_self), 0);
  }
  void add_max(uint32_t max) {
    fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_MAX, max, 0);
  }
  void add_withComment(bool withComment) {
    fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
  }
  void add_withGameInfo(bool withGameInfo) {
    fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
  }
  explicit GetScoreFriendsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetScoreFriendsRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetScoreFriendsRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetScoreFriendsRequest> CreateGetScoreFriendsRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    bool include_self = false,
    uint32_t max = 0,
    bool withComment = false,
    bool withGameInfo = false) {
  GetScoreFriendsRequestBuilder builder_(_fbb);
  builder_.add_max(max);
  builder_.add_boardId(boardId);
  builder_.add_withGameInfo(withGameInfo);
  builder_.add_withComment(withComment);
  builder_.add_include_self(include_self);
  return builder_.Finish();
}

struct ScoreRankData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ScoreRankDataBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NPID = 4,
    VT_ONLINENAME = 6,
    VT_PCID = 8,
    VT_RANK = 10,
    VT_SCORE = 12,
    VT_HASGAMEDATA = 14,
    VT_RECORDDATE = 16
  };
  const flatbuffers::String *npId() const {
    return GetPointer<const flatbuffers::String *>(VT_NPID);
  }
  const flatbuffers::String *onlineName() const {
    return GetPointer<const flatbuffers::String *>(VT_ONLINENAME);
  }
  int32_t pcId() const {
    return GetField<int32_t>(VT_PCID, 0);
  }
  uint32_t rank() const {
    return GetField<uint32_t>(VT_RANK, 0);
  }
  int64_t score() const {
    return GetField<int64_t>(VT_SCORE, 0);
  }
  bool hasGameData() const {
    return GetField<uint8_t>(VT_HASGAMEDATA, 0) != 0;
  }
  uint64_t recordDate() const {
    return GetField<uint64_t>(VT_RECORDDATE, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NPID) &&
           verifier.VerifyString(npId()) &&
           VerifyOffset(verifier, VT_ONLINENAME) &&
           verifier.VerifyString(onlineName()) &&
           VerifyField<int32_t>(verifier, VT_PCID, 4) &&
           VerifyField<uint32_t>(verifier, VT_RANK, 4) &&
           VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
           VerifyField<uint8_t>(verifier, VT_HASGAMEDATA, 1) &&
           VerifyField<uint64_t>(verifier, VT_RECORDDATE, 8) &&
           verifier.EndTable();
  }
};

struct ScoreRankDataBuilder {
  typedef ScoreRankData Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_npId(flatbuffers::Offset<flatbuffers::String> npId) {
    fbb_.AddOffset(ScoreRankData::VT_NPID, npId);
  }
  void add_onlineName(flatbuffers::Offset<flatbuffers::String> onlineName) {
    fbb_.AddOffset(ScoreRankData::VT_ONLINENAME, onlineName);
  }
  void add_pcId(int32_t pcId) {
    fbb_.AddElement<int32_t>(ScoreRankData::VT_PCID, pcId, 0);
  }
  void add_rank(uint32_t rank) {
    fbb_.AddElement<uint32_t>(ScoreRankData::VT_RANK, rank, 0);
  }
  void add_score(int64_t score) {
    fbb_.AddElement<int64_t>(ScoreRankData::VT_SCORE, score, 0);
  }
  void add_hasGameData(bool hasGameData) {
    fbb_.AddElement<uint8_t>(ScoreRankData::VT_HASGAMEDATA, static_cast<uint8_t>(hasGameData), 0);
  }
  void add_recordDate(uint64_t recordDate) {
    fbb_.AddElement<uint64_t>(ScoreRankData::VT_RECORDDATE, recordDate, 0);
  }
  explicit ScoreRankDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ScoreRankData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ScoreRankData>(end);
    return o;
  }
};

inline flatbuffers::Offset<ScoreRankData> CreateScoreRankData(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> npId = 0,
    flatbuffers::Offset<flatbuffers::String> onlineName = 0,
    int32_t pcId = 0,
    uint32_t rank = 0,
    int64_t score = 0,
    bool hasGameData = false,
    uint64_t recordDate = 0) {
  ScoreRankDataBuilder builder_(_fbb);
  builder_.add_recordDate(recordDate);
  builder_.add_score(score);
  builder_.add_rank(rank);
  builder_.add_pcId(pcId);
  builder_.add_onlineName(onlineName);
  builder_.add_npId(npId);
  builder_.add_hasGameData(hasGameData);
  return builder_.Finish();
}

inline flatbuffers::Offset<ScoreRankData> CreateScoreRankDataDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *npId = nullptr,
    const char *onlineName = nullptr,
    int32_t pcId = 0,
    uint32_t rank = 0,
    int64_t score = 0,
    bool hasGameData = false,
    uint64_t recordDate = 0) {
  auto npId__ = npId ? _fbb.CreateString(npId) : 0;
  auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
  return CreateScoreRankData(
      _fbb,
      npId__,
      onlineName__,
      pcId,
      rank,
      score,
      hasGameData,
      recordDate);
}

struct ScoreInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ScoreInfoBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DATA = 4
  };
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.EndTable();
  }
};

struct ScoreInfoBuilder {
  typedef ScoreInfo Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(ScoreInfo::VT_DATA, data);
  }
  explicit ScoreInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<ScoreInfo> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<ScoreInfo>(end);
    return o;
  }
};

inline flatbuffers::Offset<ScoreInfo> CreateScoreInfo(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
  ScoreInfoBuilder builder_(_fbb);
  builder_.add_data(data);
  return builder_.Finish();
}

inline flatbuffers::Offset<ScoreInfo> CreateScoreInfoDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *data = nullptr) {
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  return CreateScoreInfo(
      _fbb,
      data__);
}

struct GetScoreResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetScoreResponseBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_RANKARRAY = 4,
    VT_COMMENTARRAY = 6,
    VT_INFOARRAY = 8,
    VT_LASTSORTDATE = 10,
    VT_TOTALRECORD = 12
  };
  const flatbuffers::Vector<flatbuffers::Offset<ScoreRankData>> *rankArray() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ScoreRankData>> *>(VT_RANKARRAY);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *commentArray() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_COMMENTARRAY);
  }
  const flatbuffers::Vector<flatbuffers::Offset<ScoreInfo>> *infoArray() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ScoreInfo>> *>(VT_INFOARRAY);
  }
  uint64_t lastSortDate() const {
    return GetField<uint64_t>(VT_LASTSORTDATE, 0);
  }
  uint32_t totalRecord() const {
    return GetField<uint32_t>(VT_TOTALRECORD, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_RANKARRAY) &&
           verifier.VerifyVector(rankArray()) &&
           verifier.VerifyVectorOfTables(rankArray()) &&
           VerifyOffset(verifier, VT_COMMENTARRAY) &&
           verifier.VerifyVector(commentArray()) &&
           verifier.VerifyVectorOfStrings(commentArray()) &&
           VerifyOffset(verifier, VT_INFOARRAY) &&
           verifier.VerifyVector(infoArray()) &&
           verifier.VerifyVectorOfTables(infoArray()) &&
           VerifyField<uint64_t>(verifier, VT_LASTSORTDATE, 8) &&
           VerifyField<uint32_t>(verifier, VT_TOTALRECORD, 4) &&
           verifier.EndTable();
  }
};

struct GetScoreResponseBuilder {
  typedef GetScoreResponse Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_rankArray(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreRankData>>> rankArray) {
    fbb_.AddOffset(GetScoreResponse::VT_RANKARRAY, rankArray);
  }
  void add_commentArray(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> commentArray) {
    fbb_.AddOffset(GetScoreResponse::VT_COMMENTARRAY, commentArray);
  }
  void add_infoArray(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreInfo>>> infoArray) {
    fbb_.AddOffset(GetScoreResponse::VT_INFOARRAY, infoArray);
  }
  void add_lastSortDate(uint64_t lastSortDate) {
    fbb_.AddElement<uint64_t>(GetScoreResponse::VT_LASTSORTDATE, lastSortDate, 0);
  }
  void add_totalRecord(uint32_t totalRecord) {
    fbb_.AddElement<uint32_t>(GetScoreResponse::VT_TOTALRECORD, totalRecord, 0);
  }
  explicit GetScoreResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetScoreResponse> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetScoreResponse>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponse(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreRankData>>> rankArray = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> commentArray = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ScoreInfo>>> infoArray = 0,
    uint64_t lastSortDate = 0,
    uint32_t totalRecord = 0) {
  GetScoreResponseBuilder builder_(_fbb);
  builder_.add_lastSortDate(lastSortDate);
  builder_.add_totalRecord(totalRecord);
  builder_.add_infoArray(infoArray);
  builder_.add_commentArray(commentArray);
  builder_.add_rankArray(rankArray);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponseDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<ScoreRankData>> *rankArray = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *commentArray = nullptr,
    const std::vector<flatbuffers::Offset<ScoreInfo>> *infoArray = nullptr,
    uint64_t lastSortDate = 0,
    uint32_t totalRecord = 0) {
  auto rankArray__ = rankArray ? _fbb.CreateVector<flatbuffers::Offset<ScoreRankData>>(*rankArray) : 0;
  auto commentArray__ = commentArray ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*commentArray) : 0;
  auto infoArray__ = infoArray ? _fbb.CreateVector<flatbuffers::Offset<ScoreInfo>>(*infoArray) : 0;
  return CreateGetScoreResponse(
      _fbb,
      rankArray__,
      commentArray__,
      infoArray__,
      lastSortDate,
      totalRecord);
}

struct RecordScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef RecordScoreGameDataRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_PCID = 6,
    VT_SCORE = 8
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  int32_t pcId() const {
    return GetField<int32_t>(VT_PCID, 0);
  }
  int64_t score() const {
    return GetField<int64_t>(VT_SCORE, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyField<int32_t>(verifier, VT_PCID, 4) &&
           VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
           verifier.EndTable();
  }
};

struct RecordScoreGameDataRequestBuilder {
  typedef RecordScoreGameDataRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(RecordScoreGameDataRequest::VT_BOARDID, boardId, 0);
  }
  void add_pcId(int32_t pcId) {
    fbb_.AddElement<int32_t>(RecordScoreGameDataRequest::VT_PCID, pcId, 0);
  }
  void add_score(int64_t score) {
    fbb_.AddElement<int64_t>(RecordScoreGameDataRequest::VT_SCORE, score, 0);
  }
  explicit RecordScoreGameDataRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<RecordScoreGameDataRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RecordScoreGameDataRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<RecordScoreGameDataRequest> CreateRecordScoreGameDataRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    int32_t pcId = 0,
    int64_t score = 0) {
  RecordScoreGameDataRequestBuilder builder_(_fbb);
  builder_.add_score(score);
  builder_.add_pcId(pcId);
  builder_.add_boardId(boardId);
  return builder_.Finish();
}

struct GetScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef GetScoreGameDataRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BOARDID = 4,
    VT_NPID = 6,
    VT_PCID = 8
  };
  uint32_t boardId() const {
    return GetField<uint32_t>(VT_BOARDID, 0);
  }
  const flatbuffers::String *npId() const {
    return GetPointer<const flatbuffers::String *>(VT_NPID);
  }
  int32_t pcId() const {
    return GetField<int32_t>(VT_PCID, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
           VerifyOffset(verifier, VT_NPID) &&
           verifier.VerifyString(npId()) &&
           VerifyField<int32_t>(verifier, VT_PCID, 4) &&
           verifier.EndTable();
  }
};

struct GetScoreGameDataRequestBuilder {
  typedef GetScoreGameDataRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_boardId(uint32_t boardId) {
    fbb_.AddElement<uint32_t>(GetScoreGameDataRequest::VT_BOARDID, boardId, 0);
  }
  void add_npId(flatbuffers::Offset<flatbuffers::String> npId) {
    fbb_.AddOffset(GetScoreGameDataRequest::VT_NPID, npId);
  }
  void add_pcId(int32_t pcId) {
    fbb_.AddElement<int32_t>(GetScoreGameDataRequest::VT_PCID, pcId, 0);
  }
  explicit GetScoreGameDataRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<GetScoreGameDataRequest> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<GetScoreGameDataRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    flatbuffers::Offset<flatbuffers::String> npId = 0,
    int32_t pcId = 0) {
  GetScoreGameDataRequestBuilder builder_(_fbb);
  builder_.add_pcId(pcId);
  builder_.add_npId(npId);
  builder_.add_boardId(boardId);
  return builder_.Finish();
}

inline flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t boardId = 0,
    const char *npId = nullptr,
    int32_t pcId = 0) {
  auto npId__ = npId ? _fbb.CreateString(npId) : 0;
  return CreateGetScoreGameDataRequest(
      _fbb,
      boardId,
      npId__,
      pcId);
}

#endif  // FLATBUFFERS_GENERATED_NP2STRUCTS_H_
