rpcsx/rpcs3/Emu/NP/generated/np2_structs_generated.h

// 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 == 24 &&
				  FLATBUFFERS_VERSION_MINOR == 3 &&
				  FLATBUFFERS_VERSION_REVISION == 25,
	"Non-compatible flatbuffers version included");

struct SignalingAddr;
struct SignalingAddrBuilder;

struct MatchingSignalingInfo;
struct MatchingSignalingInfoBuilder;

struct Matching2SignalingInfo;
struct Matching2SignalingInfoBuilder;

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 UserInfo;
struct UserInfoBuilder;

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 JoinRoomResponse;
struct JoinRoomResponseBuilder;

struct LeaveRoomRequest;
struct LeaveRoomRequestBuilder;

struct GetRoomDataExternalListRequest;
struct GetRoomDataExternalListRequestBuilder;

struct GetRoomDataExternalListResponse;
struct GetRoomDataExternalListResponseBuilder;

struct SetRoomDataExternalRequest;
struct SetRoomDataExternalRequestBuilder;

struct SetRoomDataInternalRequest;
struct SetRoomDataInternalRequestBuilder;

struct GetRoomMemberDataInternalRequest;
struct GetRoomMemberDataInternalRequestBuilder;

struct SetRoomMemberDataInternalRequest;
struct SetRoomMemberDataInternalRequestBuilder;

struct SetUserInfo;
struct SetUserInfoBuilder;

struct GetRoomDataInternalRequest;
struct GetRoomDataInternalRequestBuilder;

struct RoomMemberUpdateInfo;
struct RoomMemberUpdateInfoBuilder;

struct NotificationUserJoinedRoom;
struct NotificationUserJoinedRoomBuilder;

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 TusUser;
struct TusUserBuilder;

struct TusVariable;
struct TusVariableBuilder;

struct TusVarResponse;
struct TusVarResponseBuilder;

struct TusSetMultiSlotVariableRequest;
struct TusSetMultiSlotVariableRequestBuilder;

struct TusGetMultiSlotVariableRequest;
struct TusGetMultiSlotVariableRequestBuilder;

struct TusGetMultiUserVariableRequest;
struct TusGetMultiUserVariableRequestBuilder;

struct TusGetFriendsVariableRequest;
struct TusGetFriendsVariableRequestBuilder;

struct TusAddAndGetVariableRequest;
struct TusAddAndGetVariableRequestBuilder;

struct TusTryAndSetVariableRequest;
struct TusTryAndSetVariableRequestBuilder;

struct TusDeleteMultiSlotVariableRequest;
struct TusDeleteMultiSlotVariableRequestBuilder;

struct TusSetDataRequest;
struct TusSetDataRequestBuilder;

struct TusDataStatus;
struct TusDataStatusBuilder;

struct TusData;
struct TusDataBuilder;

struct TusDataStatusResponse;
struct TusDataStatusResponseBuilder;

struct TusGetDataRequest;
struct TusGetDataRequestBuilder;

struct TusGetMultiSlotDataStatusRequest;
struct TusGetMultiSlotDataStatusRequestBuilder;

struct TusGetMultiUserDataStatusRequest;
struct TusGetMultiUserDataStatusRequestBuilder;

struct TusGetFriendsDataStatusRequest;
struct TusGetFriendsDataStatusRequestBuilder;

struct TusDeleteMultiSlotDataRequest;
struct TusDeleteMultiSlotDataRequestBuilder;

struct SetPresenceRequest;
struct SetPresenceRequestBuilder;

struct MatchingSearchCondition;
struct MatchingSearchConditionBuilder;

struct MatchingAttr;
struct MatchingAttrBuilder;

struct CreateRoomGUIRequest;
struct CreateRoomGUIRequestBuilder;

struct GUIUserInfo;
struct GUIUserInfoBuilder;

struct MatchingRoomStatus;
struct MatchingRoomStatusBuilder;

struct GetRoomListGUIRequest;
struct GetRoomListGUIRequestBuilder;

struct MatchingRoom;
struct MatchingRoomBuilder;

struct MatchingRoomList;
struct MatchingRoomListBuilder;

struct MatchingGuiRoomId;
struct MatchingGuiRoomIdBuilder;

struct SetRoomSearchFlagGUI;
struct SetRoomSearchFlagGUIBuilder;

struct QuickMatchGUIRequest;
struct QuickMatchGUIRequestBuilder;

struct SearchJoinRoomGUIRequest;
struct SearchJoinRoomGUIRequestBuilder;

struct MatchingSearchJoinRoomInfo;
struct MatchingSearchJoinRoomInfoBuilder;

struct SignalingAddr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef SignalingAddrBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_IP = 4,
		VT_PORT = 6
	};
	const ::flatbuffers::Vector<uint8_t>* ip() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_IP);
	}
	uint16_t port() const
	{
		return GetField<uint16_t>(VT_PORT, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_IP) &&
		       verifier.VerifyVector(ip()) &&
		       VerifyField<uint16_t>(verifier, VT_PORT, 2) &&
		       verifier.EndTable();
	}
};

struct SignalingAddrBuilder
{
	typedef SignalingAddr Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_ip(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ip)
	{
		fbb_.AddOffset(SignalingAddr::VT_IP, ip);
	}
	void add_port(uint16_t port)
	{
		fbb_.AddElement<uint16_t>(SignalingAddr::VT_PORT, port, 0);
	}
	explicit SignalingAddrBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<SignalingAddr> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<SignalingAddr>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<SignalingAddr> CreateSignalingAddr(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ip = 0,
	uint16_t port = 0)
{
	SignalingAddrBuilder builder_(_fbb);
	builder_.add_ip(ip);
	builder_.add_port(port);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<SignalingAddr> CreateSignalingAddrDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<uint8_t>* ip = nullptr,
	uint16_t port = 0)
{
	auto ip__ = ip ? _fbb.CreateVector<uint8_t>(*ip) : 0;
	return CreateSignalingAddr(
		_fbb,
		ip__,
		port);
}

struct MatchingSignalingInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingSignalingInfoBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_NPID = 4,
		VT_ADDR = 6
	};
	const ::flatbuffers::String* npid() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_NPID);
	}
	const SignalingAddr* addr() const
	{
		return GetPointer<const SignalingAddr*>(VT_ADDR);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_NPID) &&
		       verifier.VerifyString(npid()) &&
		       VerifyOffset(verifier, VT_ADDR) &&
		       verifier.VerifyTable(addr()) &&
		       verifier.EndTable();
	}
};

struct MatchingSignalingInfoBuilder
{
	typedef MatchingSignalingInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid)
	{
		fbb_.AddOffset(MatchingSignalingInfo::VT_NPID, npid);
	}
	void add_addr(::flatbuffers::Offset<SignalingAddr> addr)
	{
		fbb_.AddOffset(MatchingSignalingInfo::VT_ADDR, addr);
	}
	explicit MatchingSignalingInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingSignalingInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingSignalingInfo>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingSignalingInfo> CreateMatchingSignalingInfo(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::String> npid = 0,
	::flatbuffers::Offset<SignalingAddr> addr = 0)
{
	MatchingSignalingInfoBuilder builder_(_fbb);
	builder_.add_addr(addr);
	builder_.add_npid(npid);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingSignalingInfo> CreateMatchingSignalingInfoDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const char* npid = nullptr,
	::flatbuffers::Offset<SignalingAddr> addr = 0)
{
	auto npid__ = npid ? _fbb.CreateString(npid) : 0;
	return CreateMatchingSignalingInfo(
		_fbb,
		npid__,
		addr);
}

struct Matching2SignalingInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef Matching2SignalingInfoBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_MEMBER_ID = 4,
		VT_ADDR = 6
	};
	uint16_t member_id() const
	{
		return GetField<uint16_t>(VT_MEMBER_ID, 0);
	}
	const SignalingAddr* addr() const
	{
		return GetPointer<const SignalingAddr*>(VT_ADDR);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint16_t>(verifier, VT_MEMBER_ID, 2) &&
		       VerifyOffset(verifier, VT_ADDR) &&
		       verifier.VerifyTable(addr()) &&
		       verifier.EndTable();
	}
};

struct Matching2SignalingInfoBuilder
{
	typedef Matching2SignalingInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_member_id(uint16_t member_id)
	{
		fbb_.AddElement<uint16_t>(Matching2SignalingInfo::VT_MEMBER_ID, member_id, 0);
	}
	void add_addr(::flatbuffers::Offset<SignalingAddr> addr)
	{
		fbb_.AddOffset(Matching2SignalingInfo::VT_ADDR, addr);
	}
	explicit Matching2SignalingInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<Matching2SignalingInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<Matching2SignalingInfo>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<Matching2SignalingInfo> CreateMatching2SignalingInfo(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint16_t member_id = 0,
	::flatbuffers::Offset<SignalingAddr> addr = 0)
{
	Matching2SignalingInfoBuilder builder_(_fbb);
	builder_.add_addr(addr);
	builder_.add_member_id(member_id);
	return builder_.Finish();
}

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_LABEL = 6,
		VT_WITHPASSWORD = 8
	};
	uint32_t slotNum() const
	{
		return GetField<uint32_t>(VT_SLOTNUM, 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) &&
		       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_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,
	::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);
	return builder_.Finish();
}

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

struct UserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef UserInfoBuilder 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 UserInfoBuilder
{
	typedef UserInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId)
	{
		fbb_.AddOffset(UserInfo::VT_NPID, npId);
	}
	void add_onlineName(::flatbuffers::Offset<::flatbuffers::String> onlineName)
	{
		fbb_.AddOffset(UserInfo::VT_ONLINENAME, onlineName);
	}
	void add_avatarUrl(::flatbuffers::Offset<::flatbuffers::String> avatarUrl)
	{
		fbb_.AddOffset(UserInfo::VT_AVATARURL, avatarUrl);
	}
	explicit UserInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<UserInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<UserInfo>(end);
		return o;
	}
};

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

inline ::flatbuffers::Offset<UserInfo> CreateUserInfoDirect(
	::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 CreateUserInfo(
		_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 UserInfo* userInfo() const
	{
		return GetPointer<const UserInfo*>(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<UserInfo> 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<UserInfo> 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<UserInfo> 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_LABEL = 8,
		VT_SLOTNUM = 10,
		VT_CURGROUPMEMBERNUM = 12
	};
	uint8_t groupId() const
	{
		return GetField<uint8_t>(VT_GROUPID, 0);
	}
	bool withPassword() const
	{
		return GetField<uint8_t>(VT_WITHPASSWORD, 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) &&
		       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_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,
	::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_withPassword(withPassword);
	builder_.add_groupId(groupId);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<RoomGroup> CreateRoomGroupDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint8_t groupId = 0,
	bool withPassword = 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,
		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 UserInfo* owner() const
	{
		return GetPointer<const UserInfo*>(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<UserInfo> 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<UserInfo> 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<UserInfo> 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
	};
	uint8_t groupId() const
	{
		return GetField<uint8_t>(VT_GROUPID, 0);
	}
	bool withPassword() const
	{
		return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint8_t>(verifier, VT_GROUPID, 1) &&
		       VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
		       verifier.EndTable();
	}
};

struct RoomGroupPasswordConfigBuilder
{
	typedef RoomGroupPasswordConfig Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_groupId(uint8_t groupId)
	{
		fbb_.AddElement<uint8_t>(RoomGroupPasswordConfig::VT_GROUPID, groupId, 0);
	}
	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,
	uint8_t groupId = 0,
	bool withPassword = false)
{
	RoomGroupPasswordConfigBuilder builder_(_fbb);
	builder_.add_withPassword(withPassword);
	builder_.add_groupId(groupId);
	return builder_.Finish();
}

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_ROOMS = 8
	};
	uint32_t startIndex() const
	{
		return GetField<uint32_t>(VT_STARTINDEX, 0);
	}
	uint32_t total() const
	{
		return GetField<uint32_t>(VT_TOTAL, 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) &&
		       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_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,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms = 0)
{
	SearchRoomResponseBuilder builder_(_fbb);
	builder_.add_rooms(rooms);
	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,
	const std::vector<::flatbuffers::Offset<RoomDataExternal>>* rooms = nullptr)
{
	auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
	return CreateSearchRoomResponse(
		_fbb,
		startIndex,
		total,
		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 JoinRoomResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef JoinRoomResponseBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ROOM_DATA = 4,
		VT_SIGNALING_DATA = 6
	};
	const RoomDataInternal* room_data() const
	{
		return GetPointer<const RoomDataInternal*>(VT_ROOM_DATA);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>* signaling_data() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>*>(VT_SIGNALING_DATA);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_ROOM_DATA) &&
		       verifier.VerifyTable(room_data()) &&
		       VerifyOffset(verifier, VT_SIGNALING_DATA) &&
		       verifier.VerifyVector(signaling_data()) &&
		       verifier.VerifyVectorOfTables(signaling_data()) &&
		       verifier.EndTable();
	}
};

struct JoinRoomResponseBuilder
{
	typedef JoinRoomResponse Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_room_data(::flatbuffers::Offset<RoomDataInternal> room_data)
	{
		fbb_.AddOffset(JoinRoomResponse::VT_ROOM_DATA, room_data);
	}
	void add_signaling_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>> signaling_data)
	{
		fbb_.AddOffset(JoinRoomResponse::VT_SIGNALING_DATA, signaling_data);
	}
	explicit JoinRoomResponseBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<JoinRoomResponse> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<JoinRoomResponse>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<JoinRoomResponse> CreateJoinRoomResponse(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<RoomDataInternal> room_data = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>> signaling_data = 0)
{
	JoinRoomResponseBuilder builder_(_fbb);
	builder_.add_signaling_data(signaling_data);
	builder_.add_room_data(room_data);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<JoinRoomResponse> CreateJoinRoomResponseDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<RoomDataInternal> room_data = 0,
	const std::vector<::flatbuffers::Offset<Matching2SignalingInfo>>* signaling_data = nullptr)
{
	auto signaling_data__ = signaling_data ? _fbb.CreateVector<::flatbuffers::Offset<Matching2SignalingInfo>>(*signaling_data) : 0;
	return CreateJoinRoomResponse(
		_fbb,
		room_data,
		signaling_data__);
}

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 GetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef GetRoomMemberDataInternalRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ROOMID = 4,
		VT_MEMBERID = 6,
		VT_ATTRID = 8
	};
	uint64_t roomId() const
	{
		return GetField<uint64_t>(VT_ROOMID, 0);
	}
	uint16_t memberId() const
	{
		return GetField<uint16_t>(VT_MEMBERID, 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) &&
		       VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
		       VerifyOffset(verifier, VT_ATTRID) &&
		       verifier.VerifyVector(attrId()) &&
		       verifier.EndTable();
	}
};

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

inline ::flatbuffers::Offset<GetRoomMemberDataInternalRequest> CreateGetRoomMemberDataInternalRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint64_t roomId = 0,
	uint16_t memberId = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0)
{
	GetRoomMemberDataInternalRequestBuilder builder_(_fbb);
	builder_.add_roomId(roomId);
	builder_.add_attrId(attrId);
	builder_.add_memberId(memberId);
	return builder_.Finish();
}

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

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 SetUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef SetUserInfoBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_SERVERID = 4,
		VT_USERBINATTR = 6
	};
	uint16_t serverId() const
	{
		return GetField<uint16_t>(VT_SERVERID, 0);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>* userBinAttr() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>*>(VT_USERBINATTR);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
		       VerifyOffset(verifier, VT_USERBINATTR) &&
		       verifier.VerifyVector(userBinAttr()) &&
		       verifier.VerifyVectorOfTables(userBinAttr()) &&
		       verifier.EndTable();
	}
};

struct SetUserInfoBuilder
{
	typedef SetUserInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_serverId(uint16_t serverId)
	{
		fbb_.AddElement<uint16_t>(SetUserInfo::VT_SERVERID, serverId, 0);
	}
	void add_userBinAttr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr)
	{
		fbb_.AddOffset(SetUserInfo::VT_USERBINATTR, userBinAttr);
	}
	explicit SetUserInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<SetUserInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<SetUserInfo>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfo(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint16_t serverId = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr = 0)
{
	SetUserInfoBuilder builder_(_fbb);
	builder_.add_userBinAttr(userBinAttr);
	builder_.add_serverId(serverId);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfoDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint16_t serverId = 0,
	const std::vector<::flatbuffers::Offset<BinAttr>>* userBinAttr = nullptr)
{
	auto userBinAttr__ = userBinAttr ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*userBinAttr) : 0;
	return CreateSetUserInfo(
		_fbb,
		serverId,
		userBinAttr__);
}

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 NotificationUserJoinedRoom FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef NotificationUserJoinedRoomBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ROOM_ID = 4,
		VT_UPDATE_INFO = 6,
		VT_SIGNALING = 8
	};
	uint64_t room_id() const
	{
		return GetField<uint64_t>(VT_ROOM_ID, 0);
	}
	const RoomMemberUpdateInfo* update_info() const
	{
		return GetPointer<const RoomMemberUpdateInfo*>(VT_UPDATE_INFO);
	}
	const SignalingAddr* signaling() const
	{
		return GetPointer<const SignalingAddr*>(VT_SIGNALING);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint64_t>(verifier, VT_ROOM_ID, 8) &&
		       VerifyOffset(verifier, VT_UPDATE_INFO) &&
		       verifier.VerifyTable(update_info()) &&
		       VerifyOffset(verifier, VT_SIGNALING) &&
		       verifier.VerifyTable(signaling()) &&
		       verifier.EndTable();
	}
};

struct NotificationUserJoinedRoomBuilder
{
	typedef NotificationUserJoinedRoom Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_room_id(uint64_t room_id)
	{
		fbb_.AddElement<uint64_t>(NotificationUserJoinedRoom::VT_ROOM_ID, room_id, 0);
	}
	void add_update_info(::flatbuffers::Offset<RoomMemberUpdateInfo> update_info)
	{
		fbb_.AddOffset(NotificationUserJoinedRoom::VT_UPDATE_INFO, update_info);
	}
	void add_signaling(::flatbuffers::Offset<SignalingAddr> signaling)
	{
		fbb_.AddOffset(NotificationUserJoinedRoom::VT_SIGNALING, signaling);
	}
	explicit NotificationUserJoinedRoomBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<NotificationUserJoinedRoom> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<NotificationUserJoinedRoom>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<NotificationUserJoinedRoom> CreateNotificationUserJoinedRoom(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint64_t room_id = 0,
	::flatbuffers::Offset<RoomMemberUpdateInfo> update_info = 0,
	::flatbuffers::Offset<SignalingAddr> signaling = 0)
{
	NotificationUserJoinedRoomBuilder builder_(_fbb);
	builder_.add_room_id(room_id);
	builder_.add_signaling(signaling);
	builder_.add_update_info(update_info);
	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 UserInfo* srcMember() const
	{
		return GetPointer<const UserInfo*>(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<UserInfo> 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<UserInfo> 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<UserInfo> 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
	{
		const auto _f = message();
		return _f ? ::flatbuffers::GetRoot<MessageDetails>(_f->Data()) : nullptr;
	}
	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);
}

struct TusUser FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusUserBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_VUSER = 4,
		VT_NPID = 6
	};
	bool vuser() const
	{
		return GetField<uint8_t>(VT_VUSER, 0) != 0;
	}
	const ::flatbuffers::String* npid() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_NPID);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint8_t>(verifier, VT_VUSER, 1) &&
		       VerifyOffset(verifier, VT_NPID) &&
		       verifier.VerifyString(npid()) &&
		       verifier.EndTable();
	}
};

struct TusUserBuilder
{
	typedef TusUser Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_vuser(bool vuser)
	{
		fbb_.AddElement<uint8_t>(TusUser::VT_VUSER, static_cast<uint8_t>(vuser), 0);
	}
	void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid)
	{
		fbb_.AddOffset(TusUser::VT_NPID, npid);
	}
	explicit TusUserBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusUser> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusUser>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusUser> CreateTusUser(
	::flatbuffers::FlatBufferBuilder& _fbb,
	bool vuser = false,
	::flatbuffers::Offset<::flatbuffers::String> npid = 0)
{
	TusUserBuilder builder_(_fbb);
	builder_.add_npid(npid);
	builder_.add_vuser(vuser);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusUser> CreateTusUserDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	bool vuser = false,
	const char* npid = nullptr)
{
	auto npid__ = npid ? _fbb.CreateString(npid) : 0;
	return CreateTusUser(
		_fbb,
		vuser,
		npid__);
}

struct TusVariable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusVariableBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_OWNERID = 4,
		VT_HASDATA = 6,
		VT_LASTCHANGEDDATE = 8,
		VT_LASTCHANGEDAUTHORID = 10,
		VT_VARIABLE = 12,
		VT_OLDVARIABLE = 14
	};
	const ::flatbuffers::String* ownerId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_OWNERID);
	}
	bool hasData() const
	{
		return GetField<uint8_t>(VT_HASDATA, 0) != 0;
	}
	uint64_t lastChangedDate() const
	{
		return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
	}
	const ::flatbuffers::String* lastChangedAuthorId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_LASTCHANGEDAUTHORID);
	}
	int64_t variable() const
	{
		return GetField<int64_t>(VT_VARIABLE, 0);
	}
	int64_t oldVariable() const
	{
		return GetField<int64_t>(VT_OLDVARIABLE, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_OWNERID) &&
		       verifier.VerifyString(ownerId()) &&
		       VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
		       VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
		       VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
		       verifier.VerifyString(lastChangedAuthorId()) &&
		       VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
		       VerifyField<int64_t>(verifier, VT_OLDVARIABLE, 8) &&
		       verifier.EndTable();
	}
};

struct TusVariableBuilder
{
	typedef TusVariable Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId)
	{
		fbb_.AddOffset(TusVariable::VT_OWNERID, ownerId);
	}
	void add_hasData(bool hasData)
	{
		fbb_.AddElement<uint8_t>(TusVariable::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
	}
	void add_lastChangedDate(uint64_t lastChangedDate)
	{
		fbb_.AddElement<uint64_t>(TusVariable::VT_LASTCHANGEDDATE, lastChangedDate, 0);
	}
	void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId)
	{
		fbb_.AddOffset(TusVariable::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
	}
	void add_variable(int64_t variable)
	{
		fbb_.AddElement<int64_t>(TusVariable::VT_VARIABLE, variable, 0);
	}
	void add_oldVariable(int64_t oldVariable)
	{
		fbb_.AddElement<int64_t>(TusVariable::VT_OLDVARIABLE, oldVariable, 0);
	}
	explicit TusVariableBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusVariable> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusVariable>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusVariable> CreateTusVariable(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
	bool hasData = false,
	uint64_t lastChangedDate = 0,
	::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
	int64_t variable = 0,
	int64_t oldVariable = 0)
{
	TusVariableBuilder builder_(_fbb);
	builder_.add_oldVariable(oldVariable);
	builder_.add_variable(variable);
	builder_.add_lastChangedDate(lastChangedDate);
	builder_.add_lastChangedAuthorId(lastChangedAuthorId);
	builder_.add_ownerId(ownerId);
	builder_.add_hasData(hasData);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusVariable> CreateTusVariableDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const char* ownerId = nullptr,
	bool hasData = false,
	uint64_t lastChangedDate = 0,
	const char* lastChangedAuthorId = nullptr,
	int64_t variable = 0,
	int64_t oldVariable = 0)
{
	auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
	auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
	return CreateTusVariable(
		_fbb,
		ownerId__,
		hasData,
		lastChangedDate,
		lastChangedAuthorId__,
		variable,
		oldVariable);
}

struct TusVarResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusVarResponseBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_VARS = 4
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>* vars() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>*>(VT_VARS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_VARS) &&
		       verifier.VerifyVector(vars()) &&
		       verifier.VerifyVectorOfTables(vars()) &&
		       verifier.EndTable();
	}
};

struct TusVarResponseBuilder
{
	typedef TusVarResponse Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_vars(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars)
	{
		fbb_.AddOffset(TusVarResponse::VT_VARS, vars);
	}
	explicit TusVarResponseBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusVarResponse> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusVarResponse>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponse(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars = 0)
{
	TusVarResponseBuilder builder_(_fbb);
	builder_.add_vars(vars);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponseDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<TusVariable>>* vars = nullptr)
{
	auto vars__ = vars ? _fbb.CreateVector<::flatbuffers::Offset<TusVariable>>(*vars) : 0;
	return CreateTusVarResponse(
		_fbb,
		vars__);
}

struct TusSetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusSetMultiSlotVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTIDARRAY = 6,
		VT_VARIABLEARRAY = 8
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	const ::flatbuffers::Vector<int32_t>* slotIdArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int32_t>*>(VT_SLOTIDARRAY);
	}
	const ::flatbuffers::Vector<int64_t>* variableArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int64_t>*>(VT_VARIABLEARRAY);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyOffset(verifier, VT_SLOTIDARRAY) &&
		       verifier.VerifyVector(slotIdArray()) &&
		       VerifyOffset(verifier, VT_VARIABLEARRAY) &&
		       verifier.VerifyVector(variableArray()) &&
		       verifier.EndTable();
	}
};

struct TusSetMultiSlotVariableRequestBuilder
{
	typedef TusSetMultiSlotVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_USER, user);
	}
	void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray)
	{
		fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
	}
	void add_variableArray(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray)
	{
		fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_VARIABLEARRAY, variableArray);
	}
	explicit TusSetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusSetMultiSlotVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusSetMultiSlotVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray = 0)
{
	TusSetMultiSlotVariableRequestBuilder builder_(_fbb);
	builder_.add_variableArray(variableArray);
	builder_.add_slotIdArray(slotIdArray);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	const std::vector<int32_t>* slotIdArray = nullptr,
	const std::vector<int64_t>* variableArray = nullptr)
{
	auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
	auto variableArray__ = variableArray ? _fbb.CreateVector<int64_t>(*variableArray) : 0;
	return CreateTusSetMultiSlotVariableRequest(
		_fbb,
		user,
		slotIdArray__,
		variableArray__);
}

struct TusGetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetMultiSlotVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTIDARRAY = 6
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	const ::flatbuffers::Vector<int32_t>* slotIdArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int32_t>*>(VT_SLOTIDARRAY);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyOffset(verifier, VT_SLOTIDARRAY) &&
		       verifier.VerifyVector(slotIdArray()) &&
		       verifier.EndTable();
	}
};

struct TusGetMultiSlotVariableRequestBuilder
{
	typedef TusGetMultiSlotVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_USER, user);
	}
	void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray)
	{
		fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
	}
	explicit TusGetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetMultiSlotVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetMultiSlotVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0)
{
	TusGetMultiSlotVariableRequestBuilder builder_(_fbb);
	builder_.add_slotIdArray(slotIdArray);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	const std::vector<int32_t>* slotIdArray = nullptr)
{
	auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
	return CreateTusGetMultiSlotVariableRequest(
		_fbb,
		user,
		slotIdArray__);
}

struct TusGetMultiUserVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetMultiUserVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USERS = 4,
		VT_SLOTID = 6
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>* users() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>*>(VT_USERS);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USERS) &&
		       verifier.VerifyVector(users()) &&
		       verifier.VerifyVectorOfTables(users()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       verifier.EndTable();
	}
};

struct TusGetMultiUserVariableRequestBuilder
{
	typedef TusGetMultiUserVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users)
	{
		fbb_.AddOffset(TusGetMultiUserVariableRequest::VT_USERS, users);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusGetMultiUserVariableRequest::VT_SLOTID, slotId, 0);
	}
	explicit TusGetMultiUserVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetMultiUserVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetMultiUserVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
	int32_t slotId = 0)
{
	TusGetMultiUserVariableRequestBuilder builder_(_fbb);
	builder_.add_slotId(slotId);
	builder_.add_users(users);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<TusUser>>* users = nullptr,
	int32_t slotId = 0)
{
	auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
	return CreateTusGetMultiUserVariableRequest(
		_fbb,
		users__,
		slotId);
}

struct TusGetFriendsVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetFriendsVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_SLOTID = 4,
		VT_INCLUDESELF = 6,
		VT_SORTTYPE = 8,
		VT_ARRAYNUM = 10
	};
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	bool includeSelf() const
	{
		return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
	}
	int32_t sortType() const
	{
		return GetField<int32_t>(VT_SORTTYPE, 0);
	}
	uint32_t arrayNum() const
	{
		return GetField<uint32_t>(VT_ARRAYNUM, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
		       VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
		       VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
		       verifier.EndTable();
	}
};

struct TusGetFriendsVariableRequestBuilder
{
	typedef TusGetFriendsVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SLOTID, slotId, 0);
	}
	void add_includeSelf(bool includeSelf)
	{
		fbb_.AddElement<uint8_t>(TusGetFriendsVariableRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
	}
	void add_sortType(int32_t sortType)
	{
		fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SORTTYPE, sortType, 0);
	}
	void add_arrayNum(uint32_t arrayNum)
	{
		fbb_.AddElement<uint32_t>(TusGetFriendsVariableRequest::VT_ARRAYNUM, arrayNum, 0);
	}
	explicit TusGetFriendsVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetFriendsVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetFriendsVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetFriendsVariableRequest> CreateTusGetFriendsVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	int32_t slotId = 0,
	bool includeSelf = false,
	int32_t sortType = 0,
	uint32_t arrayNum = 0)
{
	TusGetFriendsVariableRequestBuilder builder_(_fbb);
	builder_.add_arrayNum(arrayNum);
	builder_.add_sortType(sortType);
	builder_.add_slotId(slotId);
	builder_.add_includeSelf(includeSelf);
	return builder_.Finish();
}

struct TusAddAndGetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusAddAndGetVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTID = 6,
		VT_INVARIABLE = 8,
		VT_ISLASTCHANGEDDATE = 10,
		VT_ISLASTCHANGEDAUTHORID = 12
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	int64_t inVariable() const
	{
		return GetField<int64_t>(VT_INVARIABLE, 0);
	}
	const ::flatbuffers::Vector<uint64_t>* isLastChangedDate() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint64_t>*>(VT_ISLASTCHANGEDDATE);
	}
	const ::flatbuffers::String* isLastChangedAuthorId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_ISLASTCHANGEDAUTHORID);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       VerifyField<int64_t>(verifier, VT_INVARIABLE, 8) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
		       verifier.VerifyVector(isLastChangedDate()) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
		       verifier.VerifyString(isLastChangedAuthorId()) &&
		       verifier.EndTable();
	}
};

struct TusAddAndGetVariableRequestBuilder
{
	typedef TusAddAndGetVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusAddAndGetVariableRequest::VT_USER, user);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusAddAndGetVariableRequest::VT_SLOTID, slotId, 0);
	}
	void add_inVariable(int64_t inVariable)
	{
		fbb_.AddElement<int64_t>(TusAddAndGetVariableRequest::VT_INVARIABLE, inVariable, 0);
	}
	void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate)
	{
		fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
	}
	void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId)
	{
		fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
	}
	explicit TusAddAndGetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusAddAndGetVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusAddAndGetVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	int64_t inVariable = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
	::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0)
{
	TusAddAndGetVariableRequestBuilder builder_(_fbb);
	builder_.add_inVariable(inVariable);
	builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
	builder_.add_isLastChangedDate(isLastChangedDate);
	builder_.add_slotId(slotId);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	int64_t inVariable = 0,
	const std::vector<uint64_t>* isLastChangedDate = nullptr,
	const char* isLastChangedAuthorId = nullptr)
{
	auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
	auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
	return CreateTusAddAndGetVariableRequest(
		_fbb,
		user,
		slotId,
		inVariable,
		isLastChangedDate__,
		isLastChangedAuthorId__);
}

struct TusTryAndSetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusTryAndSetVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTID = 6,
		VT_OPETYPE = 8,
		VT_VARIABLE = 10,
		VT_ISLASTCHANGEDDATE = 12,
		VT_ISLASTCHANGEDAUTHORID = 14,
		VT_COMPAREVALUE = 16
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	int32_t opeType() const
	{
		return GetField<int32_t>(VT_OPETYPE, 0);
	}
	int64_t variable() const
	{
		return GetField<int64_t>(VT_VARIABLE, 0);
	}
	const ::flatbuffers::Vector<uint64_t>* isLastChangedDate() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint64_t>*>(VT_ISLASTCHANGEDDATE);
	}
	const ::flatbuffers::String* isLastChangedAuthorId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_ISLASTCHANGEDAUTHORID);
	}
	const ::flatbuffers::Vector<int64_t>* compareValue() const
	{
		return GetPointer<const ::flatbuffers::Vector<int64_t>*>(VT_COMPAREVALUE);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       VerifyField<int32_t>(verifier, VT_OPETYPE, 4) &&
		       VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
		       verifier.VerifyVector(isLastChangedDate()) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
		       verifier.VerifyString(isLastChangedAuthorId()) &&
		       VerifyOffset(verifier, VT_COMPAREVALUE) &&
		       verifier.VerifyVector(compareValue()) &&
		       verifier.EndTable();
	}
};

struct TusTryAndSetVariableRequestBuilder
{
	typedef TusTryAndSetVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusTryAndSetVariableRequest::VT_USER, user);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_SLOTID, slotId, 0);
	}
	void add_opeType(int32_t opeType)
	{
		fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_OPETYPE, opeType, 0);
	}
	void add_variable(int64_t variable)
	{
		fbb_.AddElement<int64_t>(TusTryAndSetVariableRequest::VT_VARIABLE, variable, 0);
	}
	void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate)
	{
		fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
	}
	void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId)
	{
		fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
	}
	void add_compareValue(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue)
	{
		fbb_.AddOffset(TusTryAndSetVariableRequest::VT_COMPAREVALUE, compareValue);
	}
	explicit TusTryAndSetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusTryAndSetVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusTryAndSetVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	int32_t opeType = 0,
	int64_t variable = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
	::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue = 0)
{
	TusTryAndSetVariableRequestBuilder builder_(_fbb);
	builder_.add_variable(variable);
	builder_.add_compareValue(compareValue);
	builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
	builder_.add_isLastChangedDate(isLastChangedDate);
	builder_.add_opeType(opeType);
	builder_.add_slotId(slotId);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	int32_t opeType = 0,
	int64_t variable = 0,
	const std::vector<uint64_t>* isLastChangedDate = nullptr,
	const char* isLastChangedAuthorId = nullptr,
	const std::vector<int64_t>* compareValue = nullptr)
{
	auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
	auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
	auto compareValue__ = compareValue ? _fbb.CreateVector<int64_t>(*compareValue) : 0;
	return CreateTusTryAndSetVariableRequest(
		_fbb,
		user,
		slotId,
		opeType,
		variable,
		isLastChangedDate__,
		isLastChangedAuthorId__,
		compareValue__);
}

struct TusDeleteMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusDeleteMultiSlotVariableRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTIDARRAY = 6
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	const ::flatbuffers::Vector<int32_t>* slotIdArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int32_t>*>(VT_SLOTIDARRAY);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyOffset(verifier, VT_SLOTIDARRAY) &&
		       verifier.VerifyVector(slotIdArray()) &&
		       verifier.EndTable();
	}
};

struct TusDeleteMultiSlotVariableRequestBuilder
{
	typedef TusDeleteMultiSlotVariableRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_USER, user);
	}
	void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray)
	{
		fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
	}
	explicit TusDeleteMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0)
{
	TusDeleteMultiSlotVariableRequestBuilder builder_(_fbb);
	builder_.add_slotIdArray(slotIdArray);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	const std::vector<int32_t>* slotIdArray = nullptr)
{
	auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
	return CreateTusDeleteMultiSlotVariableRequest(
		_fbb,
		user,
		slotIdArray__);
}

struct TusSetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusSetDataRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTID = 6,
		VT_DATA = 8,
		VT_INFO = 10,
		VT_ISLASTCHANGEDDATE = 12,
		VT_ISLASTCHANGEDAUTHORID = 14
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	const ::flatbuffers::Vector<uint8_t>* data() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_DATA);
	}
	const ::flatbuffers::Vector<uint8_t>* info() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_INFO);
	}
	const ::flatbuffers::Vector<uint64_t>* isLastChangedDate() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint64_t>*>(VT_ISLASTCHANGEDDATE);
	}
	const ::flatbuffers::String* isLastChangedAuthorId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_ISLASTCHANGEDAUTHORID);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       VerifyOffset(verifier, VT_DATA) &&
		       verifier.VerifyVector(data()) &&
		       VerifyOffset(verifier, VT_INFO) &&
		       verifier.VerifyVector(info()) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
		       verifier.VerifyVector(isLastChangedDate()) &&
		       VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
		       verifier.VerifyString(isLastChangedAuthorId()) &&
		       verifier.EndTable();
	}
};

struct TusSetDataRequestBuilder
{
	typedef TusSetDataRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusSetDataRequest::VT_USER, user);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusSetDataRequest::VT_SLOTID, slotId, 0);
	}
	void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data)
	{
		fbb_.AddOffset(TusSetDataRequest::VT_DATA, data);
	}
	void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info)
	{
		fbb_.AddOffset(TusSetDataRequest::VT_INFO, info);
	}
	void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate)
	{
		fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
	}
	void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId)
	{
		fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
	}
	explicit TusSetDataRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusSetDataRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusSetDataRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
	::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0)
{
	TusSetDataRequestBuilder builder_(_fbb);
	builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
	builder_.add_isLastChangedDate(isLastChangedDate);
	builder_.add_info(info);
	builder_.add_data(data);
	builder_.add_slotId(slotId);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0,
	const std::vector<uint8_t>* data = nullptr,
	const std::vector<uint8_t>* info = nullptr,
	const std::vector<uint64_t>* isLastChangedDate = nullptr,
	const char* isLastChangedAuthorId = nullptr)
{
	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
	auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
	auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
	auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
	return CreateTusSetDataRequest(
		_fbb,
		user,
		slotId,
		data__,
		info__,
		isLastChangedDate__,
		isLastChangedAuthorId__);
}

struct TusDataStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusDataStatusBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_OWNERID = 4,
		VT_HASDATA = 6,
		VT_LASTCHANGEDDATE = 8,
		VT_LASTCHANGEDAUTHORID = 10,
		VT_INFO = 12
	};
	const ::flatbuffers::String* ownerId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_OWNERID);
	}
	bool hasData() const
	{
		return GetField<uint8_t>(VT_HASDATA, 0) != 0;
	}
	uint64_t lastChangedDate() const
	{
		return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
	}
	const ::flatbuffers::String* lastChangedAuthorId() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_LASTCHANGEDAUTHORID);
	}
	const ::flatbuffers::Vector<uint8_t>* info() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_INFO);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_OWNERID) &&
		       verifier.VerifyString(ownerId()) &&
		       VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
		       VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
		       VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
		       verifier.VerifyString(lastChangedAuthorId()) &&
		       VerifyOffset(verifier, VT_INFO) &&
		       verifier.VerifyVector(info()) &&
		       verifier.EndTable();
	}
};

struct TusDataStatusBuilder
{
	typedef TusDataStatus Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId)
	{
		fbb_.AddOffset(TusDataStatus::VT_OWNERID, ownerId);
	}
	void add_hasData(bool hasData)
	{
		fbb_.AddElement<uint8_t>(TusDataStatus::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
	}
	void add_lastChangedDate(uint64_t lastChangedDate)
	{
		fbb_.AddElement<uint64_t>(TusDataStatus::VT_LASTCHANGEDDATE, lastChangedDate, 0);
	}
	void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId)
	{
		fbb_.AddOffset(TusDataStatus::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
	}
	void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info)
	{
		fbb_.AddOffset(TusDataStatus::VT_INFO, info);
	}
	explicit TusDataStatusBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusDataStatus> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusDataStatus>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatus(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
	bool hasData = false,
	uint64_t lastChangedDate = 0,
	::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0)
{
	TusDataStatusBuilder builder_(_fbb);
	builder_.add_lastChangedDate(lastChangedDate);
	builder_.add_info(info);
	builder_.add_lastChangedAuthorId(lastChangedAuthorId);
	builder_.add_ownerId(ownerId);
	builder_.add_hasData(hasData);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatusDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const char* ownerId = nullptr,
	bool hasData = false,
	uint64_t lastChangedDate = 0,
	const char* lastChangedAuthorId = nullptr,
	const std::vector<uint8_t>* info = nullptr)
{
	auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
	auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
	auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
	return CreateTusDataStatus(
		_fbb,
		ownerId__,
		hasData,
		lastChangedDate,
		lastChangedAuthorId__,
		info__);
}

struct TusData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusDataBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_STATUS = 4,
		VT_DATA = 6
	};
	const TusDataStatus* status() const
	{
		return GetPointer<const TusDataStatus*>(VT_STATUS);
	}
	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_STATUS) &&
		       verifier.VerifyTable(status()) &&
		       VerifyOffset(verifier, VT_DATA) &&
		       verifier.VerifyVector(data()) &&
		       verifier.EndTable();
	}
};

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

inline ::flatbuffers::Offset<TusData> CreateTusData(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusDataStatus> status = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0)
{
	TusDataBuilder builder_(_fbb);
	builder_.add_data(data);
	builder_.add_status(status);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusData> CreateTusDataDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusDataStatus> status = 0,
	const std::vector<uint8_t>* data = nullptr)
{
	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
	return CreateTusData(
		_fbb,
		status,
		data__);
}

struct TusDataStatusResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusDataStatusResponseBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_STATUS = 4
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>* status() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>*>(VT_STATUS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_STATUS) &&
		       verifier.VerifyVector(status()) &&
		       verifier.VerifyVectorOfTables(status()) &&
		       verifier.EndTable();
	}
};

struct TusDataStatusResponseBuilder
{
	typedef TusDataStatusResponse Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_status(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status)
	{
		fbb_.AddOffset(TusDataStatusResponse::VT_STATUS, status);
	}
	explicit TusDataStatusResponseBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusDataStatusResponse> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusDataStatusResponse>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponse(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status = 0)
{
	TusDataStatusResponseBuilder builder_(_fbb);
	builder_.add_status(status);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponseDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<TusDataStatus>>* status = nullptr)
{
	auto status__ = status ? _fbb.CreateVector<::flatbuffers::Offset<TusDataStatus>>(*status) : 0;
	return CreateTusDataStatusResponse(
		_fbb,
		status__);
}

struct TusGetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetDataRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTID = 6
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       verifier.EndTable();
	}
};

struct TusGetDataRequestBuilder
{
	typedef TusGetDataRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusGetDataRequest::VT_USER, user);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusGetDataRequest::VT_SLOTID, slotId, 0);
	}
	explicit TusGetDataRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetDataRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetDataRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetDataRequest> CreateTusGetDataRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	int32_t slotId = 0)
{
	TusGetDataRequestBuilder builder_(_fbb);
	builder_.add_slotId(slotId);
	builder_.add_user(user);
	return builder_.Finish();
}

struct TusGetMultiSlotDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetMultiSlotDataStatusRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTIDARRAY = 6
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	const ::flatbuffers::Vector<int32_t>* slotIdArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int32_t>*>(VT_SLOTIDARRAY);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyOffset(verifier, VT_SLOTIDARRAY) &&
		       verifier.VerifyVector(slotIdArray()) &&
		       verifier.EndTable();
	}
};

struct TusGetMultiSlotDataStatusRequestBuilder
{
	typedef TusGetMultiSlotDataStatusRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_USER, user);
	}
	void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray)
	{
		fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_SLOTIDARRAY, slotIdArray);
	}
	explicit TusGetMultiSlotDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0)
{
	TusGetMultiSlotDataStatusRequestBuilder builder_(_fbb);
	builder_.add_slotIdArray(slotIdArray);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	const std::vector<int32_t>* slotIdArray = nullptr)
{
	auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
	return CreateTusGetMultiSlotDataStatusRequest(
		_fbb,
		user,
		slotIdArray__);
}

struct TusGetMultiUserDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetMultiUserDataStatusRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USERS = 4,
		VT_SLOTID = 6
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>* users() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>*>(VT_USERS);
	}
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USERS) &&
		       verifier.VerifyVector(users()) &&
		       verifier.VerifyVectorOfTables(users()) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       verifier.EndTable();
	}
};

struct TusGetMultiUserDataStatusRequestBuilder
{
	typedef TusGetMultiUserDataStatusRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users)
	{
		fbb_.AddOffset(TusGetMultiUserDataStatusRequest::VT_USERS, users);
	}
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusGetMultiUserDataStatusRequest::VT_SLOTID, slotId, 0);
	}
	explicit TusGetMultiUserDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
	int32_t slotId = 0)
{
	TusGetMultiUserDataStatusRequestBuilder builder_(_fbb);
	builder_.add_slotId(slotId);
	builder_.add_users(users);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<TusUser>>* users = nullptr,
	int32_t slotId = 0)
{
	auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
	return CreateTusGetMultiUserDataStatusRequest(
		_fbb,
		users__,
		slotId);
}

struct TusGetFriendsDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusGetFriendsDataStatusRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_SLOTID = 4,
		VT_INCLUDESELF = 6,
		VT_SORTTYPE = 8,
		VT_ARRAYNUM = 10
	};
	int32_t slotId() const
	{
		return GetField<int32_t>(VT_SLOTID, 0);
	}
	bool includeSelf() const
	{
		return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
	}
	int32_t sortType() const
	{
		return GetField<int32_t>(VT_SORTTYPE, 0);
	}
	uint32_t arrayNum() const
	{
		return GetField<uint32_t>(VT_ARRAYNUM, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
		       VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
		       VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
		       VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
		       verifier.EndTable();
	}
};

struct TusGetFriendsDataStatusRequestBuilder
{
	typedef TusGetFriendsDataStatusRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_slotId(int32_t slotId)
	{
		fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SLOTID, slotId, 0);
	}
	void add_includeSelf(bool includeSelf)
	{
		fbb_.AddElement<uint8_t>(TusGetFriendsDataStatusRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
	}
	void add_sortType(int32_t sortType)
	{
		fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SORTTYPE, sortType, 0);
	}
	void add_arrayNum(uint32_t arrayNum)
	{
		fbb_.AddElement<uint32_t>(TusGetFriendsDataStatusRequest::VT_ARRAYNUM, arrayNum, 0);
	}
	explicit TusGetFriendsDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusGetFriendsDataStatusRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusGetFriendsDataStatusRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusGetFriendsDataStatusRequest> CreateTusGetFriendsDataStatusRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	int32_t slotId = 0,
	bool includeSelf = false,
	int32_t sortType = 0,
	uint32_t arrayNum = 0)
{
	TusGetFriendsDataStatusRequestBuilder builder_(_fbb);
	builder_.add_arrayNum(arrayNum);
	builder_.add_sortType(sortType);
	builder_.add_slotId(slotId);
	builder_.add_includeSelf(includeSelf);
	return builder_.Finish();
}

struct TusDeleteMultiSlotDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef TusDeleteMultiSlotDataRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_USER = 4,
		VT_SLOTIDARRAY = 6
	};
	const TusUser* user() const
	{
		return GetPointer<const TusUser*>(VT_USER);
	}
	const ::flatbuffers::Vector<int32_t>* slotIdArray() const
	{
		return GetPointer<const ::flatbuffers::Vector<int32_t>*>(VT_SLOTIDARRAY);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_USER) &&
		       verifier.VerifyTable(user()) &&
		       VerifyOffset(verifier, VT_SLOTIDARRAY) &&
		       verifier.VerifyVector(slotIdArray()) &&
		       verifier.EndTable();
	}
};

struct TusDeleteMultiSlotDataRequestBuilder
{
	typedef TusDeleteMultiSlotDataRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_user(::flatbuffers::Offset<TusUser> user)
	{
		fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_USER, user);
	}
	void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray)
	{
		fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_SLOTIDARRAY, slotIdArray);
	}
	explicit TusDeleteMultiSlotDataRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0)
{
	TusDeleteMultiSlotDataRequestBuilder builder_(_fbb);
	builder_.add_slotIdArray(slotIdArray);
	builder_.add_user(user);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<TusUser> user = 0,
	const std::vector<int32_t>* slotIdArray = nullptr)
{
	auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
	return CreateTusDeleteMultiSlotDataRequest(
		_fbb,
		user,
		slotIdArray__);
}

struct SetPresenceRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef SetPresenceRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_TITLE = 4,
		VT_STATUS = 6,
		VT_COMMENT = 8,
		VT_DATA = 10
	};
	const ::flatbuffers::String* title() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_TITLE);
	}
	const ::flatbuffers::String* status() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_STATUS);
	}
	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) &&
		       VerifyOffset(verifier, VT_TITLE) &&
		       verifier.VerifyString(title()) &&
		       VerifyOffset(verifier, VT_STATUS) &&
		       verifier.VerifyString(status()) &&
		       VerifyOffset(verifier, VT_COMMENT) &&
		       verifier.VerifyString(comment()) &&
		       VerifyOffset(verifier, VT_DATA) &&
		       verifier.VerifyVector(data()) &&
		       verifier.EndTable();
	}
};

struct SetPresenceRequestBuilder
{
	typedef SetPresenceRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_title(::flatbuffers::Offset<::flatbuffers::String> title)
	{
		fbb_.AddOffset(SetPresenceRequest::VT_TITLE, title);
	}
	void add_status(::flatbuffers::Offset<::flatbuffers::String> status)
	{
		fbb_.AddOffset(SetPresenceRequest::VT_STATUS, status);
	}
	void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment)
	{
		fbb_.AddOffset(SetPresenceRequest::VT_COMMENT, comment);
	}
	void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data)
	{
		fbb_.AddOffset(SetPresenceRequest::VT_DATA, data);
	}
	explicit SetPresenceRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<SetPresenceRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<SetPresenceRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::String> title = 0,
	::flatbuffers::Offset<::flatbuffers::String> status = 0,
	::flatbuffers::Offset<::flatbuffers::String> comment = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0)
{
	SetPresenceRequestBuilder builder_(_fbb);
	builder_.add_data(data);
	builder_.add_comment(comment);
	builder_.add_status(status);
	builder_.add_title(title);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const char* title = nullptr,
	const char* status = nullptr,
	const char* comment = nullptr,
	const std::vector<uint8_t>* data = nullptr)
{
	auto title__ = title ? _fbb.CreateString(title) : 0;
	auto status__ = status ? _fbb.CreateString(status) : 0;
	auto comment__ = comment ? _fbb.CreateString(comment) : 0;
	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
	return CreateSetPresenceRequest(
		_fbb,
		title__,
		status__,
		comment__,
		data__);
}

struct MatchingSearchCondition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingSearchConditionBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ATTR_TYPE = 4,
		VT_ATTR_ID = 6,
		VT_COMP_OP = 8,
		VT_COMP_VALUE = 10
	};
	uint32_t attr_type() const
	{
		return GetField<uint32_t>(VT_ATTR_TYPE, 0);
	}
	uint32_t attr_id() const
	{
		return GetField<uint32_t>(VT_ATTR_ID, 0);
	}
	uint32_t comp_op() const
	{
		return GetField<uint32_t>(VT_COMP_OP, 0);
	}
	uint32_t comp_value() const
	{
		return GetField<uint32_t>(VT_COMP_VALUE, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
		       VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
		       VerifyField<uint32_t>(verifier, VT_COMP_OP, 4) &&
		       VerifyField<uint32_t>(verifier, VT_COMP_VALUE, 4) &&
		       verifier.EndTable();
	}
};

struct MatchingSearchConditionBuilder
{
	typedef MatchingSearchCondition Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_attr_type(uint32_t attr_type)
	{
		fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_TYPE, attr_type, 0);
	}
	void add_attr_id(uint32_t attr_id)
	{
		fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_ID, attr_id, 0);
	}
	void add_comp_op(uint32_t comp_op)
	{
		fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_OP, comp_op, 0);
	}
	void add_comp_value(uint32_t comp_value)
	{
		fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_VALUE, comp_value, 0);
	}
	explicit MatchingSearchConditionBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingSearchCondition> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingSearchCondition>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingSearchCondition> CreateMatchingSearchCondition(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t attr_type = 0,
	uint32_t attr_id = 0,
	uint32_t comp_op = 0,
	uint32_t comp_value = 0)
{
	MatchingSearchConditionBuilder builder_(_fbb);
	builder_.add_comp_value(comp_value);
	builder_.add_comp_op(comp_op);
	builder_.add_attr_id(attr_id);
	builder_.add_attr_type(attr_type);
	return builder_.Finish();
}

struct MatchingAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingAttrBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ATTR_TYPE = 4,
		VT_ATTR_ID = 6,
		VT_NUM = 8,
		VT_DATA = 10
	};
	uint32_t attr_type() const
	{
		return GetField<uint32_t>(VT_ATTR_TYPE, 0);
	}
	uint32_t attr_id() const
	{
		return GetField<uint32_t>(VT_ATTR_ID, 0);
	}
	uint32_t num() const
	{
		return GetField<uint32_t>(VT_NUM, 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<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
		       VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
		       VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
		       VerifyOffset(verifier, VT_DATA) &&
		       verifier.VerifyVector(data()) &&
		       verifier.EndTable();
	}
};

struct MatchingAttrBuilder
{
	typedef MatchingAttr Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_attr_type(uint32_t attr_type)
	{
		fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_TYPE, attr_type, 0);
	}
	void add_attr_id(uint32_t attr_id)
	{
		fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_ID, attr_id, 0);
	}
	void add_num(uint32_t num)
	{
		fbb_.AddElement<uint32_t>(MatchingAttr::VT_NUM, num, 0);
	}
	void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data)
	{
		fbb_.AddOffset(MatchingAttr::VT_DATA, data);
	}
	explicit MatchingAttrBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingAttr> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingAttr>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttr(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t attr_type = 0,
	uint32_t attr_id = 0,
	uint32_t num = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0)
{
	MatchingAttrBuilder builder_(_fbb);
	builder_.add_data(data);
	builder_.add_num(num);
	builder_.add_attr_id(attr_id);
	builder_.add_attr_type(attr_type);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttrDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t attr_type = 0,
	uint32_t attr_id = 0,
	uint32_t num = 0,
	const std::vector<uint8_t>* data = nullptr)
{
	auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
	return CreateMatchingAttr(
		_fbb,
		attr_type,
		attr_id,
		num,
		data__);
}

struct CreateRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef CreateRoomGUIRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_TOTAL_SLOTS = 4,
		VT_PRIVATE_SLOTS = 6,
		VT_PRIVILEGE_GRANT = 8,
		VT_STEALTH = 10,
		VT_GAME_ATTRS = 12
	};
	uint32_t total_slots() const
	{
		return GetField<uint32_t>(VT_TOTAL_SLOTS, 0);
	}
	uint32_t private_slots() const
	{
		return GetField<uint32_t>(VT_PRIVATE_SLOTS, 0);
	}
	bool privilege_grant() const
	{
		return GetField<uint8_t>(VT_PRIVILEGE_GRANT, 0) != 0;
	}
	bool stealth() const
	{
		return GetField<uint8_t>(VT_STEALTH, 0) != 0;
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>* game_attrs() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>*>(VT_GAME_ATTRS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint32_t>(verifier, VT_TOTAL_SLOTS, 4) &&
		       VerifyField<uint32_t>(verifier, VT_PRIVATE_SLOTS, 4) &&
		       VerifyField<uint8_t>(verifier, VT_PRIVILEGE_GRANT, 1) &&
		       VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
		       VerifyOffset(verifier, VT_GAME_ATTRS) &&
		       verifier.VerifyVector(game_attrs()) &&
		       verifier.VerifyVectorOfTables(game_attrs()) &&
		       verifier.EndTable();
	}
};

struct CreateRoomGUIRequestBuilder
{
	typedef CreateRoomGUIRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_total_slots(uint32_t total_slots)
	{
		fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_TOTAL_SLOTS, total_slots, 0);
	}
	void add_private_slots(uint32_t private_slots)
	{
		fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_PRIVATE_SLOTS, private_slots, 0);
	}
	void add_privilege_grant(bool privilege_grant)
	{
		fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_PRIVILEGE_GRANT, static_cast<uint8_t>(privilege_grant), 0);
	}
	void add_stealth(bool stealth)
	{
		fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
	}
	void add_game_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs)
	{
		fbb_.AddOffset(CreateRoomGUIRequest::VT_GAME_ATTRS, game_attrs);
	}
	explicit CreateRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<CreateRoomGUIRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<CreateRoomGUIRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t total_slots = 0,
	uint32_t private_slots = 0,
	bool privilege_grant = false,
	bool stealth = false,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs = 0)
{
	CreateRoomGUIRequestBuilder builder_(_fbb);
	builder_.add_game_attrs(game_attrs);
	builder_.add_private_slots(private_slots);
	builder_.add_total_slots(total_slots);
	builder_.add_stealth(stealth);
	builder_.add_privilege_grant(privilege_grant);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t total_slots = 0,
	uint32_t private_slots = 0,
	bool privilege_grant = false,
	bool stealth = false,
	const std::vector<::flatbuffers::Offset<MatchingAttr>>* game_attrs = nullptr)
{
	auto game_attrs__ = game_attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*game_attrs) : 0;
	return CreateCreateRoomGUIRequest(
		_fbb,
		total_slots,
		private_slots,
		privilege_grant,
		stealth,
		game_attrs__);
}

struct GUIUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef GUIUserInfoBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_INFO = 4,
		VT_OWNER = 6
	};
	const UserInfo* info() const
	{
		return GetPointer<const UserInfo*>(VT_INFO);
	}
	bool owner() const
	{
		return GetField<uint8_t>(VT_OWNER, 0) != 0;
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_INFO) &&
		       verifier.VerifyTable(info()) &&
		       VerifyField<uint8_t>(verifier, VT_OWNER, 1) &&
		       verifier.EndTable();
	}
};

struct GUIUserInfoBuilder
{
	typedef GUIUserInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_info(::flatbuffers::Offset<UserInfo> info)
	{
		fbb_.AddOffset(GUIUserInfo::VT_INFO, info);
	}
	void add_owner(bool owner)
	{
		fbb_.AddElement<uint8_t>(GUIUserInfo::VT_OWNER, static_cast<uint8_t>(owner), 0);
	}
	explicit GUIUserInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<GUIUserInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<GUIUserInfo>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<GUIUserInfo> CreateGUIUserInfo(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<UserInfo> info = 0,
	bool owner = false)
{
	GUIUserInfoBuilder builder_(_fbb);
	builder_.add_info(info);
	builder_.add_owner(owner);
	return builder_.Finish();
}

struct MatchingRoomStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingRoomStatusBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ID = 4,
		VT_MEMBERS = 6,
		VT_KICK_ACTOR = 8,
		VT_OPT = 10
	};
	const ::flatbuffers::Vector<uint8_t>* id() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_ID);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>* members() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>*>(VT_MEMBERS);
	}
	const ::flatbuffers::String* kick_actor() const
	{
		return GetPointer<const ::flatbuffers::String*>(VT_KICK_ACTOR);
	}
	const ::flatbuffers::Vector<uint8_t>* opt() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_OPT);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_ID) &&
		       verifier.VerifyVector(id()) &&
		       VerifyOffset(verifier, VT_MEMBERS) &&
		       verifier.VerifyVector(members()) &&
		       verifier.VerifyVectorOfTables(members()) &&
		       VerifyOffset(verifier, VT_KICK_ACTOR) &&
		       verifier.VerifyString(kick_actor()) &&
		       VerifyOffset(verifier, VT_OPT) &&
		       verifier.VerifyVector(opt()) &&
		       verifier.EndTable();
	}
};

struct MatchingRoomStatusBuilder
{
	typedef MatchingRoomStatus Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id)
	{
		fbb_.AddOffset(MatchingRoomStatus::VT_ID, id);
	}
	void add_members(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members)
	{
		fbb_.AddOffset(MatchingRoomStatus::VT_MEMBERS, members);
	}
	void add_kick_actor(::flatbuffers::Offset<::flatbuffers::String> kick_actor)
	{
		fbb_.AddOffset(MatchingRoomStatus::VT_KICK_ACTOR, kick_actor);
	}
	void add_opt(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt)
	{
		fbb_.AddOffset(MatchingRoomStatus::VT_OPT, opt);
	}
	explicit MatchingRoomStatusBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingRoomStatus> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingRoomStatus>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatus(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members = 0,
	::flatbuffers::Offset<::flatbuffers::String> kick_actor = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt = 0)
{
	MatchingRoomStatusBuilder builder_(_fbb);
	builder_.add_opt(opt);
	builder_.add_kick_actor(kick_actor);
	builder_.add_members(members);
	builder_.add_id(id);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatusDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<uint8_t>* id = nullptr,
	const std::vector<::flatbuffers::Offset<GUIUserInfo>>* members = nullptr,
	const char* kick_actor = nullptr,
	const std::vector<uint8_t>* opt = nullptr)
{
	auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
	auto members__ = members ? _fbb.CreateVector<::flatbuffers::Offset<GUIUserInfo>>(*members) : 0;
	auto kick_actor__ = kick_actor ? _fbb.CreateString(kick_actor) : 0;
	auto opt__ = opt ? _fbb.CreateVector<uint8_t>(*opt) : 0;
	return CreateMatchingRoomStatus(
		_fbb,
		id__,
		members__,
		kick_actor__,
		opt__);
}

struct GetRoomListGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef GetRoomListGUIRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_RANGE_START = 4,
		VT_RANGE_MAX = 6,
		VT_CONDS = 8,
		VT_ATTRS = 10
	};
	uint32_t range_start() const
	{
		return GetField<uint32_t>(VT_RANGE_START, 0);
	}
	uint32_t range_max() const
	{
		return GetField<uint32_t>(VT_RANGE_MAX, 0);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>*>(VT_CONDS);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>* attrs() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>*>(VT_ATTRS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint32_t>(verifier, VT_RANGE_START, 4) &&
		       VerifyField<uint32_t>(verifier, VT_RANGE_MAX, 4) &&
		       VerifyOffset(verifier, VT_CONDS) &&
		       verifier.VerifyVector(conds()) &&
		       verifier.VerifyVectorOfTables(conds()) &&
		       VerifyOffset(verifier, VT_ATTRS) &&
		       verifier.VerifyVector(attrs()) &&
		       verifier.VerifyVectorOfTables(attrs()) &&
		       verifier.EndTable();
	}
};

struct GetRoomListGUIRequestBuilder
{
	typedef GetRoomListGUIRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_range_start(uint32_t range_start)
	{
		fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_START, range_start, 0);
	}
	void add_range_max(uint32_t range_max)
	{
		fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_MAX, range_max, 0);
	}
	void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds)
	{
		fbb_.AddOffset(GetRoomListGUIRequest::VT_CONDS, conds);
	}
	void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs)
	{
		fbb_.AddOffset(GetRoomListGUIRequest::VT_ATTRS, attrs);
	}
	explicit GetRoomListGUIRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<GetRoomListGUIRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<GetRoomListGUIRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t range_start = 0,
	uint32_t range_max = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0)
{
	GetRoomListGUIRequestBuilder builder_(_fbb);
	builder_.add_attrs(attrs);
	builder_.add_conds(conds);
	builder_.add_range_max(range_max);
	builder_.add_range_start(range_start);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t range_start = 0,
	uint32_t range_max = 0,
	const std::vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds = nullptr,
	const std::vector<::flatbuffers::Offset<MatchingAttr>>* attrs = nullptr)
{
	auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
	auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
	return CreateGetRoomListGUIRequest(
		_fbb,
		range_start,
		range_max,
		conds__,
		attrs__);
}

struct MatchingRoom FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingRoomBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ID = 4,
		VT_ATTR = 6
	};
	const ::flatbuffers::Vector<uint8_t>* id() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_ID);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>* attr() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>*>(VT_ATTR);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_ID) &&
		       verifier.VerifyVector(id()) &&
		       VerifyOffset(verifier, VT_ATTR) &&
		       verifier.VerifyVector(attr()) &&
		       verifier.VerifyVectorOfTables(attr()) &&
		       verifier.EndTable();
	}
};

struct MatchingRoomBuilder
{
	typedef MatchingRoom Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id)
	{
		fbb_.AddOffset(MatchingRoom::VT_ID, id);
	}
	void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr)
	{
		fbb_.AddOffset(MatchingRoom::VT_ATTR, attr);
	}
	explicit MatchingRoomBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingRoom> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingRoom>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoom(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0)
{
	MatchingRoomBuilder builder_(_fbb);
	builder_.add_attr(attr);
	builder_.add_id(id);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoomDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<uint8_t>* id = nullptr,
	const std::vector<::flatbuffers::Offset<MatchingAttr>>* attr = nullptr)
{
	auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
	auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
	return CreateMatchingRoom(
		_fbb,
		id__,
		attr__);
}

struct MatchingRoomList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingRoomListBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_START = 4,
		VT_TOTAL = 6,
		VT_ROOMS = 8
	};
	uint32_t start() const
	{
		return GetField<uint32_t>(VT_START, 0);
	}
	uint32_t total() const
	{
		return GetField<uint32_t>(VT_TOTAL, 0);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>* rooms() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>*>(VT_ROOMS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyField<uint32_t>(verifier, VT_START, 4) &&
		       VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
		       VerifyOffset(verifier, VT_ROOMS) &&
		       verifier.VerifyVector(rooms()) &&
		       verifier.VerifyVectorOfTables(rooms()) &&
		       verifier.EndTable();
	}
};

struct MatchingRoomListBuilder
{
	typedef MatchingRoomList Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_start(uint32_t start)
	{
		fbb_.AddElement<uint32_t>(MatchingRoomList::VT_START, start, 0);
	}
	void add_total(uint32_t total)
	{
		fbb_.AddElement<uint32_t>(MatchingRoomList::VT_TOTAL, total, 0);
	}
	void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms)
	{
		fbb_.AddOffset(MatchingRoomList::VT_ROOMS, rooms);
	}
	explicit MatchingRoomListBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingRoomList> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingRoomList>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomList(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t start = 0,
	uint32_t total = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms = 0)
{
	MatchingRoomListBuilder builder_(_fbb);
	builder_.add_rooms(rooms);
	builder_.add_total(total);
	builder_.add_start(start);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomListDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	uint32_t start = 0,
	uint32_t total = 0,
	const std::vector<::flatbuffers::Offset<MatchingRoom>>* rooms = nullptr)
{
	auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<MatchingRoom>>(*rooms) : 0;
	return CreateMatchingRoomList(
		_fbb,
		start,
		total,
		rooms__);
}

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

struct MatchingGuiRoomIdBuilder
{
	typedef MatchingGuiRoomId Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id)
	{
		fbb_.AddOffset(MatchingGuiRoomId::VT_ID, id);
	}
	explicit MatchingGuiRoomIdBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingGuiRoomId> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingGuiRoomId>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomId(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0)
{
	MatchingGuiRoomIdBuilder builder_(_fbb);
	builder_.add_id(id);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomIdDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<uint8_t>* id = nullptr)
{
	auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
	return CreateMatchingGuiRoomId(
		_fbb,
		id__);
}

struct SetRoomSearchFlagGUI FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef SetRoomSearchFlagGUIBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ROOMID = 4,
		VT_STEALTH = 6
	};
	const ::flatbuffers::Vector<uint8_t>* roomid() const
	{
		return GetPointer<const ::flatbuffers::Vector<uint8_t>*>(VT_ROOMID);
	}
	bool stealth() const
	{
		return GetField<uint8_t>(VT_STEALTH, 0) != 0;
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_ROOMID) &&
		       verifier.VerifyVector(roomid()) &&
		       VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
		       verifier.EndTable();
	}
};

struct SetRoomSearchFlagGUIBuilder
{
	typedef SetRoomSearchFlagGUI Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_roomid(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid)
	{
		fbb_.AddOffset(SetRoomSearchFlagGUI::VT_ROOMID, roomid);
	}
	void add_stealth(bool stealth)
	{
		fbb_.AddElement<uint8_t>(SetRoomSearchFlagGUI::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
	}
	explicit SetRoomSearchFlagGUIBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<SetRoomSearchFlagGUI> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<SetRoomSearchFlagGUI>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUI(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid = 0,
	bool stealth = false)
{
	SetRoomSearchFlagGUIBuilder builder_(_fbb);
	builder_.add_roomid(roomid);
	builder_.add_stealth(stealth);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUIDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<uint8_t>* roomid = nullptr,
	bool stealth = false)
{
	auto roomid__ = roomid ? _fbb.CreateVector<uint8_t>(*roomid) : 0;
	return CreateSetRoomSearchFlagGUI(
		_fbb,
		roomid__,
		stealth);
}

struct QuickMatchGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef QuickMatchGUIRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_CONDS = 4,
		VT_AVAILABLE_NUM = 6
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>*>(VT_CONDS);
	}
	uint32_t available_num() const
	{
		return GetField<uint32_t>(VT_AVAILABLE_NUM, 0);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_CONDS) &&
		       verifier.VerifyVector(conds()) &&
		       verifier.VerifyVectorOfTables(conds()) &&
		       VerifyField<uint32_t>(verifier, VT_AVAILABLE_NUM, 4) &&
		       verifier.EndTable();
	}
};

struct QuickMatchGUIRequestBuilder
{
	typedef QuickMatchGUIRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds)
	{
		fbb_.AddOffset(QuickMatchGUIRequest::VT_CONDS, conds);
	}
	void add_available_num(uint32_t available_num)
	{
		fbb_.AddElement<uint32_t>(QuickMatchGUIRequest::VT_AVAILABLE_NUM, available_num, 0);
	}
	explicit QuickMatchGUIRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<QuickMatchGUIRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<QuickMatchGUIRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
	uint32_t available_num = 0)
{
	QuickMatchGUIRequestBuilder builder_(_fbb);
	builder_.add_available_num(available_num);
	builder_.add_conds(conds);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds = nullptr,
	uint32_t available_num = 0)
{
	auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
	return CreateQuickMatchGUIRequest(
		_fbb,
		conds__,
		available_num);
}

struct SearchJoinRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef SearchJoinRoomGUIRequestBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_CONDS = 4,
		VT_ATTRS = 6
	};
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>*>(VT_CONDS);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>* attrs() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>*>(VT_ATTRS);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_CONDS) &&
		       verifier.VerifyVector(conds()) &&
		       verifier.VerifyVectorOfTables(conds()) &&
		       VerifyOffset(verifier, VT_ATTRS) &&
		       verifier.VerifyVector(attrs()) &&
		       verifier.VerifyVectorOfTables(attrs()) &&
		       verifier.EndTable();
	}
};

struct SearchJoinRoomGUIRequestBuilder
{
	typedef SearchJoinRoomGUIRequest Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds)
	{
		fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_CONDS, conds);
	}
	void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs)
	{
		fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_ATTRS, attrs);
	}
	explicit SearchJoinRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<SearchJoinRoomGUIRequest> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<SearchJoinRoomGUIRequest>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequest(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0)
{
	SearchJoinRoomGUIRequestBuilder builder_(_fbb);
	builder_.add_attrs(attrs);
	builder_.add_conds(conds);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequestDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	const std::vector<::flatbuffers::Offset<MatchingSearchCondition>>* conds = nullptr,
	const std::vector<::flatbuffers::Offset<MatchingAttr>>* attrs = nullptr)
{
	auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
	auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
	return CreateSearchJoinRoomGUIRequest(
		_fbb,
		conds__,
		attrs__);
}

struct MatchingSearchJoinRoomInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
{
	typedef MatchingSearchJoinRoomInfoBuilder Builder;
	enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE
	{
		VT_ROOM = 4,
		VT_ATTR = 6
	};
	const MatchingRoomStatus* room() const
	{
		return GetPointer<const MatchingRoomStatus*>(VT_ROOM);
	}
	const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>* attr() const
	{
		return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>*>(VT_ATTR);
	}
	bool Verify(::flatbuffers::Verifier& verifier) const
	{
		return VerifyTableStart(verifier) &&
		       VerifyOffset(verifier, VT_ROOM) &&
		       verifier.VerifyTable(room()) &&
		       VerifyOffset(verifier, VT_ATTR) &&
		       verifier.VerifyVector(attr()) &&
		       verifier.VerifyVectorOfTables(attr()) &&
		       verifier.EndTable();
	}
};

struct MatchingSearchJoinRoomInfoBuilder
{
	typedef MatchingSearchJoinRoomInfo Table;
	::flatbuffers::FlatBufferBuilder& fbb_;
	::flatbuffers::uoffset_t start_;
	void add_room(::flatbuffers::Offset<MatchingRoomStatus> room)
	{
		fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ROOM, room);
	}
	void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr)
	{
		fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ATTR, attr);
	}
	explicit MatchingSearchJoinRoomInfoBuilder(::flatbuffers::FlatBufferBuilder& _fbb)
		: fbb_(_fbb)
	{
		start_ = fbb_.StartTable();
	}
	::flatbuffers::Offset<MatchingSearchJoinRoomInfo> Finish()
	{
		const auto end = fbb_.EndTable(start_);
		auto o = ::flatbuffers::Offset<MatchingSearchJoinRoomInfo>(end);
		return o;
	}
};

inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfo(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<MatchingRoomStatus> room = 0,
	::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0)
{
	MatchingSearchJoinRoomInfoBuilder builder_(_fbb);
	builder_.add_attr(attr);
	builder_.add_room(room);
	return builder_.Finish();
}

inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfoDirect(
	::flatbuffers::FlatBufferBuilder& _fbb,
	::flatbuffers::Offset<MatchingRoomStatus> room = 0,
	const std::vector<::flatbuffers::Offset<MatchingAttr>>* attr = nullptr)
{
	auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
	return CreateMatchingSearchJoinRoomInfo(
		_fbb,
		room,
		attr__);
}

#endif // FLATBUFFERS_GENERATED_NP2STRUCTS_H_