Add vendor (steam)

1 files changed, 2543 insertions, 0 deletions

diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go
new file mode 100644
index 00000000..fa5028d8
--- /dev/null
+++ b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go
@@ -0,0 +1,2543 @@
+// Generated code
+// DO NOT EDIT
+
+package steamlang
+
+import (
+	"encoding/binary"
+	. "github.com/Philipp15b/go-steam/protocol/protobuf"
+	"github.com/Philipp15b/go-steam/rwu"
+	"github.com/Philipp15b/go-steam/steamid"
+	"github.com/golang/protobuf/proto"
+	"io"
+)
+
+const UdpHeader_MAGIC uint32 = 0x31305356
+
+type UdpHeader struct {
+	Magic        uint32
+	PayloadSize  uint16
+	PacketType   EUdpPacketType
+	Flags        uint8
+	SourceConnID uint32
+	DestConnID   uint32
+	SeqThis      uint32
+	SeqAck       uint32
+	PacketsInMsg uint32
+	MsgStartSeq  uint32
+	MsgSize      uint32
+}
+
+func NewUdpHeader() *UdpHeader {
+	return &UdpHeader{
+		Magic:        UdpHeader_MAGIC,
+		PacketType:   EUdpPacketType_Invalid,
+		SourceConnID: 512,
+	}
+}
+
+func (d *UdpHeader) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Magic)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PayloadSize)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PacketType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Flags)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SourceConnID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.DestConnID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SeqThis)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SeqAck)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PacketsInMsg)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.MsgStartSeq)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.MsgSize)
+	return err
+}
+
+func (d *UdpHeader) Deserialize(r io.Reader) error {
+	var err error
+	d.Magic, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.PayloadSize, err = rwu.ReadUint16(r)
+	if err != nil {
+		return err
+	}
+	t0, err := rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	d.PacketType = EUdpPacketType(t0)
+	d.Flags, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	d.SourceConnID, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.DestConnID, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.SeqThis, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.SeqAck, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.PacketsInMsg, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.MsgStartSeq, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.MsgSize, err = rwu.ReadUint32(r)
+	return err
+}
+
+const ChallengeData_CHALLENGE_MASK uint32 = 0xA426DF2B
+
+type ChallengeData struct {
+	ChallengeValue uint32
+	ServerLoad     uint32
+}
+
+func NewChallengeData() *ChallengeData {
+	return &ChallengeData{}
+}
+
+func (d *ChallengeData) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.ChallengeValue)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ServerLoad)
+	return err
+}
+
+func (d *ChallengeData) Deserialize(r io.Reader) error {
+	var err error
+	d.ChallengeValue, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.ServerLoad, err = rwu.ReadUint32(r)
+	return err
+}
+
+const ConnectData_CHALLENGE_MASK uint32 = ChallengeData_CHALLENGE_MASK
+
+type ConnectData struct {
+	ChallengeValue uint32
+}
+
+func NewConnectData() *ConnectData {
+	return &ConnectData{}
+}
+
+func (d *ConnectData) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.ChallengeValue)
+	return err
+}
+
+func (d *ConnectData) Deserialize(r io.Reader) error {
+	var err error
+	d.ChallengeValue, err = rwu.ReadUint32(r)
+	return err
+}
+
+type Accept struct {
+}
+
+func NewAccept() *Accept {
+	return &Accept{}
+}
+
+func (d *Accept) Serialize(w io.Writer) error {
+	var err error
+	return err
+}
+
+func (d *Accept) Deserialize(r io.Reader) error {
+	var err error
+	return err
+}
+
+type Datagram struct {
+}
+
+func NewDatagram() *Datagram {
+	return &Datagram{}
+}
+
+func (d *Datagram) Serialize(w io.Writer) error {
+	var err error
+	return err
+}
+
+func (d *Datagram) Deserialize(r io.Reader) error {
+	var err error
+	return err
+}
+
+type Disconnect struct {
+}
+
+func NewDisconnect() *Disconnect {
+	return &Disconnect{}
+}
+
+func (d *Disconnect) Serialize(w io.Writer) error {
+	var err error
+	return err
+}
+
+func (d *Disconnect) Deserialize(r io.Reader) error {
+	var err error
+	return err
+}
+
+type MsgHdr struct {
+	Msg         EMsg
+	TargetJobID uint64
+	SourceJobID uint64
+}
+
+func NewMsgHdr() *MsgHdr {
+	return &MsgHdr{
+		Msg:         EMsg_Invalid,
+		TargetJobID: ^uint64(0),
+		SourceJobID: ^uint64(0),
+	}
+}
+
+func (d *MsgHdr) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Msg)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+	return err
+}
+
+func (d *MsgHdr) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Msg = EMsg(t0)
+	d.TargetJobID, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SourceJobID, err = rwu.ReadUint64(r)
+	return err
+}
+
+type ExtendedClientMsgHdr struct {
+	Msg           EMsg
+	HeaderSize    uint8
+	HeaderVersion uint16
+	TargetJobID   uint64
+	SourceJobID   uint64
+	HeaderCanary  uint8
+	SteamID       steamid.SteamId
+	SessionID     int32
+}
+
+func NewExtendedClientMsgHdr() *ExtendedClientMsgHdr {
+	return &ExtendedClientMsgHdr{
+		Msg:           EMsg_Invalid,
+		HeaderSize:    36,
+		HeaderVersion: 2,
+		TargetJobID:   ^uint64(0),
+		SourceJobID:   ^uint64(0),
+		HeaderCanary:  239,
+	}
+}
+
+func (d *ExtendedClientMsgHdr) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Msg)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.HeaderSize)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.HeaderVersion)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.HeaderCanary)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SessionID)
+	return err
+}
+
+func (d *ExtendedClientMsgHdr) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Msg = EMsg(t0)
+	d.HeaderSize, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	d.HeaderVersion, err = rwu.ReadUint16(r)
+	if err != nil {
+		return err
+	}
+	d.TargetJobID, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SourceJobID, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.HeaderCanary, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamID = steamid.SteamId(t1)
+	d.SessionID, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgHdrProtoBuf struct {
+	Msg          EMsg
+	HeaderLength int32
+	Proto        *CMsgProtoBufHeader
+}
+
+func NewMsgHdrProtoBuf() *MsgHdrProtoBuf {
+	return &MsgHdrProtoBuf{
+		Msg:   EMsg_Invalid,
+		Proto: new(CMsgProtoBufHeader),
+	}
+}
+
+func (d *MsgHdrProtoBuf) Serialize(w io.Writer) error {
+	var err error
+	buf0, err := proto.Marshal(d.Proto)
+	if err != nil {
+		return err
+	}
+	d.HeaderLength = int32(len(buf0))
+	err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask))
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.HeaderLength)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(buf0)
+	return err
+}
+
+func (d *MsgHdrProtoBuf) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Msg = EMsg(uint32(t0) & EMsgMask)
+	d.HeaderLength, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	buf1 := make([]byte, d.HeaderLength, d.HeaderLength)
+	_, err = io.ReadFull(r, buf1)
+	if err != nil {
+		return err
+	}
+	err = proto.Unmarshal(buf1, d.Proto)
+	return err
+}
+
+type MsgGCHdrProtoBuf struct {
+	Msg          uint32
+	HeaderLength int32
+	Proto        *CMsgProtoBufHeader
+}
+
+func NewMsgGCHdrProtoBuf() *MsgGCHdrProtoBuf {
+	return &MsgGCHdrProtoBuf{
+		Msg:   0,
+		Proto: new(CMsgProtoBufHeader),
+	}
+}
+
+func (d *MsgGCHdrProtoBuf) Serialize(w io.Writer) error {
+	var err error
+	buf0, err := proto.Marshal(d.Proto)
+	if err != nil {
+		return err
+	}
+	d.HeaderLength = int32(len(buf0))
+	err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask))
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.HeaderLength)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(buf0)
+	return err
+}
+
+func (d *MsgGCHdrProtoBuf) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.Msg = uint32(t0) & EMsgMask
+	d.HeaderLength, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	buf1 := make([]byte, d.HeaderLength, d.HeaderLength)
+	_, err = io.ReadFull(r, buf1)
+	if err != nil {
+		return err
+	}
+	err = proto.Unmarshal(buf1, d.Proto)
+	return err
+}
+
+type MsgGCHdr struct {
+	HeaderVersion uint16
+	TargetJobID   uint64
+	SourceJobID   uint64
+}
+
+func NewMsgGCHdr() *MsgGCHdr {
+	return &MsgGCHdr{
+		HeaderVersion: 1,
+		TargetJobID:   ^uint64(0),
+		SourceJobID:   ^uint64(0),
+	}
+}
+
+func (d *MsgGCHdr) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.HeaderVersion)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TargetJobID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SourceJobID)
+	return err
+}
+
+func (d *MsgGCHdr) Deserialize(r io.Reader) error {
+	var err error
+	d.HeaderVersion, err = rwu.ReadUint16(r)
+	if err != nil {
+		return err
+	}
+	d.TargetJobID, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SourceJobID, err = rwu.ReadUint64(r)
+	return err
+}
+
+type MsgClientJustStrings struct {
+}
+
+func NewMsgClientJustStrings() *MsgClientJustStrings {
+	return &MsgClientJustStrings{}
+}
+
+func (d *MsgClientJustStrings) GetEMsg() EMsg {
+	return EMsg_Invalid
+}
+
+func (d *MsgClientJustStrings) Serialize(w io.Writer) error {
+	var err error
+	return err
+}
+
+func (d *MsgClientJustStrings) Deserialize(r io.Reader) error {
+	var err error
+	return err
+}
+
+type MsgClientGenericResponse struct {
+	Result EResult
+}
+
+func NewMsgClientGenericResponse() *MsgClientGenericResponse {
+	return &MsgClientGenericResponse{}
+}
+
+func (d *MsgClientGenericResponse) GetEMsg() EMsg {
+	return EMsg_Invalid
+}
+
+func (d *MsgClientGenericResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	return err
+}
+
+func (d *MsgClientGenericResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	d.Result = EResult(t0)
+	return err
+}
+
+const MsgChannelEncryptRequest_PROTOCOL_VERSION uint32 = 1
+
+type MsgChannelEncryptRequest struct {
+	ProtocolVersion uint32
+	Universe        EUniverse
+}
+
+func NewMsgChannelEncryptRequest() *MsgChannelEncryptRequest {
+	return &MsgChannelEncryptRequest{
+		ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION,
+		Universe:        EUniverse_Invalid,
+	}
+}
+
+func (d *MsgChannelEncryptRequest) GetEMsg() EMsg {
+	return EMsg_ChannelEncryptRequest
+}
+
+func (d *MsgChannelEncryptRequest) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Universe)
+	return err
+}
+
+func (d *MsgChannelEncryptRequest) Deserialize(r io.Reader) error {
+	var err error
+	d.ProtocolVersion, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	t0, err := rwu.ReadInt32(r)
+	d.Universe = EUniverse(t0)
+	return err
+}
+
+type MsgChannelEncryptResponse struct {
+	ProtocolVersion uint32
+	KeySize         uint32
+}
+
+func NewMsgChannelEncryptResponse() *MsgChannelEncryptResponse {
+	return &MsgChannelEncryptResponse{
+		ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION,
+		KeySize:         128,
+	}
+}
+
+func (d *MsgChannelEncryptResponse) GetEMsg() EMsg {
+	return EMsg_ChannelEncryptResponse
+}
+
+func (d *MsgChannelEncryptResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.KeySize)
+	return err
+}
+
+func (d *MsgChannelEncryptResponse) Deserialize(r io.Reader) error {
+	var err error
+	d.ProtocolVersion, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.KeySize, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgChannelEncryptResult struct {
+	Result EResult
+}
+
+func NewMsgChannelEncryptResult() *MsgChannelEncryptResult {
+	return &MsgChannelEncryptResult{
+		Result: EResult_Invalid,
+	}
+}
+
+func (d *MsgChannelEncryptResult) GetEMsg() EMsg {
+	return EMsg_ChannelEncryptResult
+}
+
+func (d *MsgChannelEncryptResult) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	return err
+}
+
+func (d *MsgChannelEncryptResult) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	d.Result = EResult(t0)
+	return err
+}
+
+type MsgClientNewLoginKey struct {
+	UniqueID uint32
+	LoginKey []uint8
+}
+
+func NewMsgClientNewLoginKey() *MsgClientNewLoginKey {
+	return &MsgClientNewLoginKey{
+		LoginKey: make([]uint8, 20, 20),
+	}
+}
+
+func (d *MsgClientNewLoginKey) GetEMsg() EMsg {
+	return EMsg_ClientNewLoginKey
+}
+
+func (d *MsgClientNewLoginKey) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.UniqueID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.LoginKey)
+	return err
+}
+
+func (d *MsgClientNewLoginKey) Deserialize(r io.Reader) error {
+	var err error
+	d.UniqueID, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	err = binary.Read(r, binary.LittleEndian, d.LoginKey)
+	return err
+}
+
+type MsgClientNewLoginKeyAccepted struct {
+	UniqueID uint32
+}
+
+func NewMsgClientNewLoginKeyAccepted() *MsgClientNewLoginKeyAccepted {
+	return &MsgClientNewLoginKeyAccepted{}
+}
+
+func (d *MsgClientNewLoginKeyAccepted) GetEMsg() EMsg {
+	return EMsg_ClientNewLoginKeyAccepted
+}
+
+func (d *MsgClientNewLoginKeyAccepted) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.UniqueID)
+	return err
+}
+
+func (d *MsgClientNewLoginKeyAccepted) Deserialize(r io.Reader) error {
+	var err error
+	d.UniqueID, err = rwu.ReadUint32(r)
+	return err
+}
+
+const (
+	MsgClientLogon_ObfuscationMask                                      uint32 = 0xBAADF00D
+	MsgClientLogon_CurrentProtocol                                      uint32 = 65579
+	MsgClientLogon_ProtocolVerMajorMask                                 uint32 = 0xFFFF0000
+	MsgClientLogon_ProtocolVerMinorMask                                 uint32 = 0xFFFF
+	MsgClientLogon_ProtocolVerMinorMinGameServers                       uint16 = 4
+	MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgMulti            uint16 = 12
+	MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgClientEncryptPct uint16 = 14
+	MsgClientLogon_ProtocolVerMinorMinForExtendedMsgHdr                 uint16 = 17
+	MsgClientLogon_ProtocolVerMinorMinForCellId                         uint16 = 18
+	MsgClientLogon_ProtocolVerMinorMinForSessionIDLast                  uint16 = 19
+	MsgClientLogon_ProtocolVerMinorMinForServerAvailablityMsgs          uint16 = 24
+	MsgClientLogon_ProtocolVerMinorMinClients                           uint16 = 25
+	MsgClientLogon_ProtocolVerMinorMinForOSType                         uint16 = 26
+	MsgClientLogon_ProtocolVerMinorMinForCegApplyPESig                  uint16 = 27
+	MsgClientLogon_ProtocolVerMinorMinForMarketingMessages2             uint16 = 27
+	MsgClientLogon_ProtocolVerMinorMinForAnyProtoBufMessages            uint16 = 28
+	MsgClientLogon_ProtocolVerMinorMinForProtoBufLoggedOffMessage       uint16 = 28
+	MsgClientLogon_ProtocolVerMinorMinForProtoBufMultiMessages          uint16 = 28
+	MsgClientLogon_ProtocolVerMinorMinForSendingProtocolToUFS           uint16 = 30
+	MsgClientLogon_ProtocolVerMinorMinForMachineAuth                    uint16 = 33
+	MsgClientLogon_ProtocolVerMinorMinForSessionIDLastAnon              uint16 = 36
+	MsgClientLogon_ProtocolVerMinorMinForEnhancedAppList                uint16 = 40
+	MsgClientLogon_ProtocolVerMinorMinForGzipMultiMessages              uint16 = 43
+)
+
+type MsgClientLogon struct {
+}
+
+func NewMsgClientLogon() *MsgClientLogon {
+	return &MsgClientLogon{}
+}
+
+func (d *MsgClientLogon) GetEMsg() EMsg {
+	return EMsg_ClientLogon
+}
+
+func (d *MsgClientLogon) Serialize(w io.Writer) error {
+	var err error
+	return err
+}
+
+func (d *MsgClientLogon) Deserialize(r io.Reader) error {
+	var err error
+	return err
+}
+
+type MsgClientVACBanStatus struct {
+	NumBans uint32
+}
+
+func NewMsgClientVACBanStatus() *MsgClientVACBanStatus {
+	return &MsgClientVACBanStatus{}
+}
+
+func (d *MsgClientVACBanStatus) GetEMsg() EMsg {
+	return EMsg_ClientVACBanStatus
+}
+
+func (d *MsgClientVACBanStatus) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.NumBans)
+	return err
+}
+
+func (d *MsgClientVACBanStatus) Deserialize(r io.Reader) error {
+	var err error
+	d.NumBans, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientAppUsageEvent struct {
+	AppUsageEvent EAppUsageEvent
+	GameID        uint64
+	Offline       uint16
+}
+
+func NewMsgClientAppUsageEvent() *MsgClientAppUsageEvent {
+	return &MsgClientAppUsageEvent{}
+}
+
+func (d *MsgClientAppUsageEvent) GetEMsg() EMsg {
+	return EMsg_ClientAppUsageEvent
+}
+
+func (d *MsgClientAppUsageEvent) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.AppUsageEvent)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.GameID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Offline)
+	return err
+}
+
+func (d *MsgClientAppUsageEvent) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.AppUsageEvent = EAppUsageEvent(t0)
+	d.GameID, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.Offline, err = rwu.ReadUint16(r)
+	return err
+}
+
+type MsgClientEmailAddrInfo struct {
+	PasswordStrength           uint32
+	FlagsAccountSecurityPolicy uint32
+	Validated                  bool
+}
+
+func NewMsgClientEmailAddrInfo() *MsgClientEmailAddrInfo {
+	return &MsgClientEmailAddrInfo{}
+}
+
+func (d *MsgClientEmailAddrInfo) GetEMsg() EMsg {
+	return EMsg_ClientEmailAddrInfo
+}
+
+func (d *MsgClientEmailAddrInfo) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.PasswordStrength)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.FlagsAccountSecurityPolicy)
+	if err != nil {
+		return err
+	}
+	err = rwu.WriteBool(w, d.Validated)
+	return err
+}
+
+func (d *MsgClientEmailAddrInfo) Deserialize(r io.Reader) error {
+	var err error
+	d.PasswordStrength, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.FlagsAccountSecurityPolicy, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.Validated, err = rwu.ReadBool(r)
+	return err
+}
+
+type MsgClientUpdateGuestPassesList struct {
+	Result                   EResult
+	CountGuestPassesToGive   int32
+	CountGuestPassesToRedeem int32
+}
+
+func NewMsgClientUpdateGuestPassesList() *MsgClientUpdateGuestPassesList {
+	return &MsgClientUpdateGuestPassesList{}
+}
+
+func (d *MsgClientUpdateGuestPassesList) GetEMsg() EMsg {
+	return EMsg_ClientUpdateGuestPassesList
+}
+
+func (d *MsgClientUpdateGuestPassesList) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToGive)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToRedeem)
+	return err
+}
+
+func (d *MsgClientUpdateGuestPassesList) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.CountGuestPassesToGive, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.CountGuestPassesToRedeem, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientRequestedClientStats struct {
+	CountStats int32
+}
+
+func NewMsgClientRequestedClientStats() *MsgClientRequestedClientStats {
+	return &MsgClientRequestedClientStats{}
+}
+
+func (d *MsgClientRequestedClientStats) GetEMsg() EMsg {
+	return EMsg_ClientRequestedClientStats
+}
+
+func (d *MsgClientRequestedClientStats) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.CountStats)
+	return err
+}
+
+func (d *MsgClientRequestedClientStats) Deserialize(r io.Reader) error {
+	var err error
+	d.CountStats, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientP2PIntroducerMessage struct {
+	SteamID     steamid.SteamId
+	RoutingType EIntroducerRouting
+	Data        []uint8
+	DataLen     uint32
+}
+
+func NewMsgClientP2PIntroducerMessage() *MsgClientP2PIntroducerMessage {
+	return &MsgClientP2PIntroducerMessage{
+		Data: make([]uint8, 1450, 1450),
+	}
+}
+
+func (d *MsgClientP2PIntroducerMessage) GetEMsg() EMsg {
+	return EMsg_ClientP2PIntroducerMessage
+}
+
+func (d *MsgClientP2PIntroducerMessage) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamID)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.RoutingType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Data)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.DataLen)
+	return err
+}
+
+func (d *MsgClientP2PIntroducerMessage) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamID = steamid.SteamId(t0)
+	t1, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.RoutingType = EIntroducerRouting(t1)
+	err = binary.Read(r, binary.LittleEndian, d.Data)
+	if err != nil {
+		return err
+	}
+	d.DataLen, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientOGSBeginSession struct {
+	AccountType uint8
+	AccountId   steamid.SteamId
+	AppId       uint32
+	TimeStarted uint32
+}
+
+func NewMsgClientOGSBeginSession() *MsgClientOGSBeginSession {
+	return &MsgClientOGSBeginSession{}
+}
+
+func (d *MsgClientOGSBeginSession) GetEMsg() EMsg {
+	return EMsg_ClientOGSBeginSession
+}
+
+func (d *MsgClientOGSBeginSession) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.AccountType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.AccountId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.AppId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TimeStarted)
+	return err
+}
+
+func (d *MsgClientOGSBeginSession) Deserialize(r io.Reader) error {
+	var err error
+	d.AccountType, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.AccountId = steamid.SteamId(t0)
+	d.AppId, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.TimeStarted, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientOGSBeginSessionResponse struct {
+	Result            EResult
+	CollectingAny     bool
+	CollectingDetails bool
+	SessionId         uint64
+}
+
+func NewMsgClientOGSBeginSessionResponse() *MsgClientOGSBeginSessionResponse {
+	return &MsgClientOGSBeginSessionResponse{}
+}
+
+func (d *MsgClientOGSBeginSessionResponse) GetEMsg() EMsg {
+	return EMsg_ClientOGSBeginSessionResponse
+}
+
+func (d *MsgClientOGSBeginSessionResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = rwu.WriteBool(w, d.CollectingAny)
+	if err != nil {
+		return err
+	}
+	err = rwu.WriteBool(w, d.CollectingDetails)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SessionId)
+	return err
+}
+
+func (d *MsgClientOGSBeginSessionResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.CollectingAny, err = rwu.ReadBool(r)
+	if err != nil {
+		return err
+	}
+	d.CollectingDetails, err = rwu.ReadBool(r)
+	if err != nil {
+		return err
+	}
+	d.SessionId, err = rwu.ReadUint64(r)
+	return err
+}
+
+type MsgClientOGSEndSession struct {
+	SessionId       uint64
+	TimeEnded       uint32
+	ReasonCode      int32
+	CountAttributes int32
+}
+
+func NewMsgClientOGSEndSession() *MsgClientOGSEndSession {
+	return &MsgClientOGSEndSession{}
+}
+
+func (d *MsgClientOGSEndSession) GetEMsg() EMsg {
+	return EMsg_ClientOGSEndSession
+}
+
+func (d *MsgClientOGSEndSession) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SessionId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TimeEnded)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ReasonCode)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.CountAttributes)
+	return err
+}
+
+func (d *MsgClientOGSEndSession) Deserialize(r io.Reader) error {
+	var err error
+	d.SessionId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.TimeEnded, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.ReasonCode, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.CountAttributes, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientOGSEndSessionResponse struct {
+	Result EResult
+}
+
+func NewMsgClientOGSEndSessionResponse() *MsgClientOGSEndSessionResponse {
+	return &MsgClientOGSEndSessionResponse{}
+}
+
+func (d *MsgClientOGSEndSessionResponse) GetEMsg() EMsg {
+	return EMsg_ClientOGSEndSessionResponse
+}
+
+func (d *MsgClientOGSEndSessionResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	return err
+}
+
+func (d *MsgClientOGSEndSessionResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	d.Result = EResult(t0)
+	return err
+}
+
+type MsgClientOGSWriteRow struct {
+	SessionId       uint64
+	CountAttributes int32
+}
+
+func NewMsgClientOGSWriteRow() *MsgClientOGSWriteRow {
+	return &MsgClientOGSWriteRow{}
+}
+
+func (d *MsgClientOGSWriteRow) GetEMsg() EMsg {
+	return EMsg_ClientOGSWriteRow
+}
+
+func (d *MsgClientOGSWriteRow) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SessionId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.CountAttributes)
+	return err
+}
+
+func (d *MsgClientOGSWriteRow) Deserialize(r io.Reader) error {
+	var err error
+	d.SessionId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.CountAttributes, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientGetFriendsWhoPlayGame struct {
+	GameId uint64
+}
+
+func NewMsgClientGetFriendsWhoPlayGame() *MsgClientGetFriendsWhoPlayGame {
+	return &MsgClientGetFriendsWhoPlayGame{}
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) GetEMsg() EMsg {
+	return EMsg_ClientGetFriendsWhoPlayGame
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.GameId)
+	return err
+}
+
+func (d *MsgClientGetFriendsWhoPlayGame) Deserialize(r io.Reader) error {
+	var err error
+	d.GameId, err = rwu.ReadUint64(r)
+	return err
+}
+
+type MsgClientGetFriendsWhoPlayGameResponse struct {
+	Result       EResult
+	GameId       uint64
+	CountFriends uint32
+}
+
+func NewMsgClientGetFriendsWhoPlayGameResponse() *MsgClientGetFriendsWhoPlayGameResponse {
+	return &MsgClientGetFriendsWhoPlayGameResponse{}
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) GetEMsg() EMsg {
+	return EMsg_ClientGetFriendsWhoPlayGameResponse
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.GameId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.CountFriends)
+	return err
+}
+
+func (d *MsgClientGetFriendsWhoPlayGameResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.GameId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.CountFriends, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgGSPerformHardwareSurvey struct {
+	Flags uint32
+}
+
+func NewMsgGSPerformHardwareSurvey() *MsgGSPerformHardwareSurvey {
+	return &MsgGSPerformHardwareSurvey{}
+}
+
+func (d *MsgGSPerformHardwareSurvey) GetEMsg() EMsg {
+	return EMsg_GSPerformHardwareSurvey
+}
+
+func (d *MsgGSPerformHardwareSurvey) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Flags)
+	return err
+}
+
+func (d *MsgGSPerformHardwareSurvey) Deserialize(r io.Reader) error {
+	var err error
+	d.Flags, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgGSGetPlayStatsResponse struct {
+	Result                EResult
+	Rank                  int32
+	LifetimeConnects      uint32
+	LifetimeMinutesPlayed uint32
+}
+
+func NewMsgGSGetPlayStatsResponse() *MsgGSGetPlayStatsResponse {
+	return &MsgGSGetPlayStatsResponse{}
+}
+
+func (d *MsgGSGetPlayStatsResponse) GetEMsg() EMsg {
+	return EMsg_GSGetPlayStatsResponse
+}
+
+func (d *MsgGSGetPlayStatsResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Rank)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.LifetimeConnects)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.LifetimeMinutesPlayed)
+	return err
+}
+
+func (d *MsgGSGetPlayStatsResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.Rank, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.LifetimeConnects, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.LifetimeMinutesPlayed, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgGSGetReputationResponse struct {
+	Result          EResult
+	ReputationScore uint32
+	Banned          bool
+	BannedIp        uint32
+	BannedPort      uint16
+	BannedGameId    uint64
+	TimeBanExpires  uint32
+}
+
+func NewMsgGSGetReputationResponse() *MsgGSGetReputationResponse {
+	return &MsgGSGetReputationResponse{}
+}
+
+func (d *MsgGSGetReputationResponse) GetEMsg() EMsg {
+	return EMsg_GSGetReputationResponse
+}
+
+func (d *MsgGSGetReputationResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ReputationScore)
+	if err != nil {
+		return err
+	}
+	err = rwu.WriteBool(w, d.Banned)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.BannedIp)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.BannedPort)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.BannedGameId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.TimeBanExpires)
+	return err
+}
+
+func (d *MsgGSGetReputationResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.ReputationScore, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.Banned, err = rwu.ReadBool(r)
+	if err != nil {
+		return err
+	}
+	d.BannedIp, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.BannedPort, err = rwu.ReadUint16(r)
+	if err != nil {
+		return err
+	}
+	d.BannedGameId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.TimeBanExpires, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgGSDeny struct {
+	SteamId    steamid.SteamId
+	DenyReason EDenyReason
+}
+
+func NewMsgGSDeny() *MsgGSDeny {
+	return &MsgGSDeny{}
+}
+
+func (d *MsgGSDeny) GetEMsg() EMsg {
+	return EMsg_GSDeny
+}
+
+func (d *MsgGSDeny) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.DenyReason)
+	return err
+}
+
+func (d *MsgGSDeny) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamId = steamid.SteamId(t0)
+	t1, err := rwu.ReadInt32(r)
+	d.DenyReason = EDenyReason(t1)
+	return err
+}
+
+type MsgGSApprove struct {
+	SteamId steamid.SteamId
+}
+
+func NewMsgGSApprove() *MsgGSApprove {
+	return &MsgGSApprove{}
+}
+
+func (d *MsgGSApprove) GetEMsg() EMsg {
+	return EMsg_GSApprove
+}
+
+func (d *MsgGSApprove) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamId)
+	return err
+}
+
+func (d *MsgGSApprove) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamId = steamid.SteamId(t0)
+	return err
+}
+
+type MsgGSKick struct {
+	SteamId          steamid.SteamId
+	DenyReason       EDenyReason
+	WaitTilMapChange int32
+}
+
+func NewMsgGSKick() *MsgGSKick {
+	return &MsgGSKick{}
+}
+
+func (d *MsgGSKick) GetEMsg() EMsg {
+	return EMsg_GSKick
+}
+
+func (d *MsgGSKick) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.DenyReason)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.WaitTilMapChange)
+	return err
+}
+
+func (d *MsgGSKick) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamId = steamid.SteamId(t0)
+	t1, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.DenyReason = EDenyReason(t1)
+	d.WaitTilMapChange, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgGSGetUserGroupStatus struct {
+	SteamIdUser  steamid.SteamId
+	SteamIdGroup steamid.SteamId
+}
+
+func NewMsgGSGetUserGroupStatus() *MsgGSGetUserGroupStatus {
+	return &MsgGSGetUserGroupStatus{}
+}
+
+func (d *MsgGSGetUserGroupStatus) GetEMsg() EMsg {
+	return EMsg_GSGetUserGroupStatus
+}
+
+func (d *MsgGSGetUserGroupStatus) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdUser)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup)
+	return err
+}
+
+func (d *MsgGSGetUserGroupStatus) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdUser = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdGroup = steamid.SteamId(t1)
+	return err
+}
+
+type MsgGSGetUserGroupStatusResponse struct {
+	SteamIdUser      steamid.SteamId
+	SteamIdGroup     steamid.SteamId
+	ClanRelationship EClanRelationship
+	ClanRank         EClanRank
+}
+
+func NewMsgGSGetUserGroupStatusResponse() *MsgGSGetUserGroupStatusResponse {
+	return &MsgGSGetUserGroupStatusResponse{}
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) GetEMsg() EMsg {
+	return EMsg_GSGetUserGroupStatusResponse
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdUser)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ClanRelationship)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ClanRank)
+	return err
+}
+
+func (d *MsgGSGetUserGroupStatusResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdUser = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdGroup = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.ClanRelationship = EClanRelationship(t2)
+	t3, err := rwu.ReadInt32(r)
+	d.ClanRank = EClanRank(t3)
+	return err
+}
+
+type MsgClientJoinChat struct {
+	SteamIdChat    steamid.SteamId
+	IsVoiceSpeaker bool
+}
+
+func NewMsgClientJoinChat() *MsgClientJoinChat {
+	return &MsgClientJoinChat{}
+}
+
+func (d *MsgClientJoinChat) GetEMsg() EMsg {
+	return EMsg_ClientJoinChat
+}
+
+func (d *MsgClientJoinChat) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = rwu.WriteBool(w, d.IsVoiceSpeaker)
+	return err
+}
+
+func (d *MsgClientJoinChat) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	d.IsVoiceSpeaker, err = rwu.ReadBool(r)
+	return err
+}
+
+type MsgClientChatEnter struct {
+	SteamIdChat   steamid.SteamId
+	SteamIdFriend steamid.SteamId
+	ChatRoomType  EChatRoomType
+	SteamIdOwner  steamid.SteamId
+	SteamIdClan   steamid.SteamId
+	ChatFlags     uint8
+	EnterResponse EChatRoomEnterResponse
+	NumMembers    int32
+}
+
+func NewMsgClientChatEnter() *MsgClientChatEnter {
+	return &MsgClientChatEnter{}
+}
+
+func (d *MsgClientChatEnter) GetEMsg() EMsg {
+	return EMsg_ClientChatEnter
+}
+
+func (d *MsgClientChatEnter) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdOwner)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdClan)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatFlags)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.EnterResponse)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.NumMembers)
+	return err
+}
+
+func (d *MsgClientChatEnter) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdFriend = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.ChatRoomType = EChatRoomType(t2)
+	t3, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdOwner = steamid.SteamId(t3)
+	t4, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdClan = steamid.SteamId(t4)
+	d.ChatFlags, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	t5, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.EnterResponse = EChatRoomEnterResponse(t5)
+	d.NumMembers, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientChatMsg struct {
+	SteamIdChatter  steamid.SteamId
+	SteamIdChatRoom steamid.SteamId
+	ChatMsgType     EChatEntryType
+}
+
+func NewMsgClientChatMsg() *MsgClientChatMsg {
+	return &MsgClientChatMsg{}
+}
+
+func (d *MsgClientChatMsg) GetEMsg() EMsg {
+	return EMsg_ClientChatMsg
+}
+
+func (d *MsgClientChatMsg) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChatter)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChatRoom)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatMsgType)
+	return err
+}
+
+func (d *MsgClientChatMsg) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChatter = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChatRoom = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	d.ChatMsgType = EChatEntryType(t2)
+	return err
+}
+
+type MsgClientChatMemberInfo struct {
+	SteamIdChat steamid.SteamId
+	Type        EChatInfoType
+}
+
+func NewMsgClientChatMemberInfo() *MsgClientChatMemberInfo {
+	return &MsgClientChatMemberInfo{}
+}
+
+func (d *MsgClientChatMemberInfo) GetEMsg() EMsg {
+	return EMsg_ClientChatMemberInfo
+}
+
+func (d *MsgClientChatMemberInfo) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Type)
+	return err
+}
+
+func (d *MsgClientChatMemberInfo) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	t1, err := rwu.ReadInt32(r)
+	d.Type = EChatInfoType(t1)
+	return err
+}
+
+type MsgClientChatAction struct {
+	SteamIdChat        steamid.SteamId
+	SteamIdUserToActOn steamid.SteamId
+	ChatAction         EChatAction
+}
+
+func NewMsgClientChatAction() *MsgClientChatAction {
+	return &MsgClientChatAction{}
+}
+
+func (d *MsgClientChatAction) GetEMsg() EMsg {
+	return EMsg_ClientChatAction
+}
+
+func (d *MsgClientChatAction) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdUserToActOn)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatAction)
+	return err
+}
+
+func (d *MsgClientChatAction) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdUserToActOn = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	d.ChatAction = EChatAction(t2)
+	return err
+}
+
+type MsgClientChatActionResult struct {
+	SteamIdChat        steamid.SteamId
+	SteamIdUserActedOn steamid.SteamId
+	ChatAction         EChatAction
+	ActionResult       EChatActionResult
+}
+
+func NewMsgClientChatActionResult() *MsgClientChatActionResult {
+	return &MsgClientChatActionResult{}
+}
+
+func (d *MsgClientChatActionResult) GetEMsg() EMsg {
+	return EMsg_ClientChatActionResult
+}
+
+func (d *MsgClientChatActionResult) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdUserActedOn)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatAction)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ActionResult)
+	return err
+}
+
+func (d *MsgClientChatActionResult) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdUserActedOn = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.ChatAction = EChatAction(t2)
+	t3, err := rwu.ReadInt32(r)
+	d.ActionResult = EChatActionResult(t3)
+	return err
+}
+
+type MsgClientChatRoomInfo struct {
+	SteamIdChat steamid.SteamId
+	Type        EChatInfoType
+}
+
+func NewMsgClientChatRoomInfo() *MsgClientChatRoomInfo {
+	return &MsgClientChatRoomInfo{}
+}
+
+func (d *MsgClientChatRoomInfo) GetEMsg() EMsg {
+	return EMsg_ClientChatRoomInfo
+}
+
+func (d *MsgClientChatRoomInfo) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Type)
+	return err
+}
+
+func (d *MsgClientChatRoomInfo) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t0)
+	t1, err := rwu.ReadInt32(r)
+	d.Type = EChatInfoType(t1)
+	return err
+}
+
+type MsgClientGetNumberOfCurrentPlayers struct {
+	GameID uint64
+}
+
+func NewMsgClientGetNumberOfCurrentPlayers() *MsgClientGetNumberOfCurrentPlayers {
+	return &MsgClientGetNumberOfCurrentPlayers{}
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) GetEMsg() EMsg {
+	return EMsg_ClientGetNumberOfCurrentPlayers
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.GameID)
+	return err
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayers) Deserialize(r io.Reader) error {
+	var err error
+	d.GameID, err = rwu.ReadUint64(r)
+	return err
+}
+
+type MsgClientGetNumberOfCurrentPlayersResponse struct {
+	Result     EResult
+	NumPlayers uint32
+}
+
+func NewMsgClientGetNumberOfCurrentPlayersResponse() *MsgClientGetNumberOfCurrentPlayersResponse {
+	return &MsgClientGetNumberOfCurrentPlayersResponse{}
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) GetEMsg() EMsg {
+	return EMsg_ClientGetNumberOfCurrentPlayersResponse
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.NumPlayers)
+	return err
+}
+
+func (d *MsgClientGetNumberOfCurrentPlayersResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.NumPlayers, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientSetIgnoreFriend struct {
+	MySteamId     steamid.SteamId
+	SteamIdFriend steamid.SteamId
+	Ignore        uint8
+}
+
+func NewMsgClientSetIgnoreFriend() *MsgClientSetIgnoreFriend {
+	return &MsgClientSetIgnoreFriend{}
+}
+
+func (d *MsgClientSetIgnoreFriend) GetEMsg() EMsg {
+	return EMsg_ClientSetIgnoreFriend
+}
+
+func (d *MsgClientSetIgnoreFriend) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.MySteamId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Ignore)
+	return err
+}
+
+func (d *MsgClientSetIgnoreFriend) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.MySteamId = steamid.SteamId(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdFriend = steamid.SteamId(t1)
+	d.Ignore, err = rwu.ReadUint8(r)
+	return err
+}
+
+type MsgClientSetIgnoreFriendResponse struct {
+	Unknown uint64
+	Result  EResult
+}
+
+func NewMsgClientSetIgnoreFriendResponse() *MsgClientSetIgnoreFriendResponse {
+	return &MsgClientSetIgnoreFriendResponse{}
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) GetEMsg() EMsg {
+	return EMsg_ClientSetIgnoreFriendResponse
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Unknown)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	return err
+}
+
+func (d *MsgClientSetIgnoreFriendResponse) Deserialize(r io.Reader) error {
+	var err error
+	d.Unknown, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	t0, err := rwu.ReadInt32(r)
+	d.Result = EResult(t0)
+	return err
+}
+
+type MsgClientLoggedOff struct {
+	Result              EResult
+	SecMinReconnectHint int32
+	SecMaxReconnectHint int32
+}
+
+func NewMsgClientLoggedOff() *MsgClientLoggedOff {
+	return &MsgClientLoggedOff{}
+}
+
+func (d *MsgClientLoggedOff) GetEMsg() EMsg {
+	return EMsg_ClientLoggedOff
+}
+
+func (d *MsgClientLoggedOff) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SecMinReconnectHint)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SecMaxReconnectHint)
+	return err
+}
+
+func (d *MsgClientLoggedOff) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.SecMinReconnectHint, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.SecMaxReconnectHint, err = rwu.ReadInt32(r)
+	return err
+}
+
+type MsgClientLogOnResponse struct {
+	Result                    EResult
+	OutOfGameHeartbeatRateSec int32
+	InGameHeartbeatRateSec    int32
+	ClientSuppliedSteamId     steamid.SteamId
+	IpPublic                  uint32
+	ServerRealTime            uint32
+}
+
+func NewMsgClientLogOnResponse() *MsgClientLogOnResponse {
+	return &MsgClientLogOnResponse{}
+}
+
+func (d *MsgClientLogOnResponse) GetEMsg() EMsg {
+	return EMsg_ClientLogOnResponse
+}
+
+func (d *MsgClientLogOnResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.OutOfGameHeartbeatRateSec)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.InGameHeartbeatRateSec)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ClientSuppliedSteamId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.IpPublic)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ServerRealTime)
+	return err
+}
+
+func (d *MsgClientLogOnResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	d.OutOfGameHeartbeatRateSec, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.InGameHeartbeatRateSec, err = rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.ClientSuppliedSteamId = steamid.SteamId(t1)
+	d.IpPublic, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.ServerRealTime, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientSendGuestPass struct {
+	GiftId    uint64
+	GiftType  uint8
+	AccountId uint32
+}
+
+func NewMsgClientSendGuestPass() *MsgClientSendGuestPass {
+	return &MsgClientSendGuestPass{}
+}
+
+func (d *MsgClientSendGuestPass) GetEMsg() EMsg {
+	return EMsg_ClientSendGuestPass
+}
+
+func (d *MsgClientSendGuestPass) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.GiftId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.GiftType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.AccountId)
+	return err
+}
+
+func (d *MsgClientSendGuestPass) Deserialize(r io.Reader) error {
+	var err error
+	d.GiftId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.GiftType, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	d.AccountId, err = rwu.ReadUint32(r)
+	return err
+}
+
+type MsgClientSendGuestPassResponse struct {
+	Result EResult
+}
+
+func NewMsgClientSendGuestPassResponse() *MsgClientSendGuestPassResponse {
+	return &MsgClientSendGuestPassResponse{}
+}
+
+func (d *MsgClientSendGuestPassResponse) GetEMsg() EMsg {
+	return EMsg_ClientSendGuestPassResponse
+}
+
+func (d *MsgClientSendGuestPassResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	return err
+}
+
+func (d *MsgClientSendGuestPassResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	d.Result = EResult(t0)
+	return err
+}
+
+type MsgClientServerUnavailable struct {
+	JobidSent              uint64
+	EMsgSent               uint32
+	EServerTypeUnavailable EServerType
+}
+
+func NewMsgClientServerUnavailable() *MsgClientServerUnavailable {
+	return &MsgClientServerUnavailable{}
+}
+
+func (d *MsgClientServerUnavailable) GetEMsg() EMsg {
+	return EMsg_ClientServerUnavailable
+}
+
+func (d *MsgClientServerUnavailable) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.JobidSent)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.EMsgSent)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.EServerTypeUnavailable)
+	return err
+}
+
+func (d *MsgClientServerUnavailable) Deserialize(r io.Reader) error {
+	var err error
+	d.JobidSent, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.EMsgSent, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	t0, err := rwu.ReadInt32(r)
+	d.EServerTypeUnavailable = EServerType(t0)
+	return err
+}
+
+type MsgClientCreateChat struct {
+	ChatRoomType      EChatRoomType
+	GameId            uint64
+	SteamIdClan       steamid.SteamId
+	PermissionOfficer EChatPermission
+	PermissionMember  EChatPermission
+	PermissionAll     EChatPermission
+	MembersMax        uint32
+	ChatFlags         uint8
+	SteamIdFriendChat steamid.SteamId
+	SteamIdInvited    steamid.SteamId
+}
+
+func NewMsgClientCreateChat() *MsgClientCreateChat {
+	return &MsgClientCreateChat{}
+}
+
+func (d *MsgClientCreateChat) GetEMsg() EMsg {
+	return EMsg_ClientCreateChat
+}
+
+func (d *MsgClientCreateChat) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.GameId)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdClan)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PermissionOfficer)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PermissionMember)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.PermissionAll)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.MembersMax)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatFlags)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdInvited)
+	return err
+}
+
+func (d *MsgClientCreateChat) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.ChatRoomType = EChatRoomType(t0)
+	d.GameId, err = rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdClan = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.PermissionOfficer = EChatPermission(t2)
+	t3, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.PermissionMember = EChatPermission(t3)
+	t4, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.PermissionAll = EChatPermission(t4)
+	d.MembersMax, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.ChatFlags, err = rwu.ReadUint8(r)
+	if err != nil {
+		return err
+	}
+	t5, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdFriendChat = steamid.SteamId(t5)
+	t6, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdInvited = steamid.SteamId(t6)
+	return err
+}
+
+type MsgClientCreateChatResponse struct {
+	Result            EResult
+	SteamIdChat       steamid.SteamId
+	ChatRoomType      EChatRoomType
+	SteamIdFriendChat steamid.SteamId
+}
+
+func NewMsgClientCreateChatResponse() *MsgClientCreateChatResponse {
+	return &MsgClientCreateChatResponse{}
+}
+
+func (d *MsgClientCreateChatResponse) GetEMsg() EMsg {
+	return EMsg_ClientCreateChatResponse
+}
+
+func (d *MsgClientCreateChatResponse) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.Result)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdChat)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.ChatRoomType)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat)
+	return err
+}
+
+func (d *MsgClientCreateChatResponse) Deserialize(r io.Reader) error {
+	var err error
+	t0, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.Result = EResult(t0)
+	t1, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdChat = steamid.SteamId(t1)
+	t2, err := rwu.ReadInt32(r)
+	if err != nil {
+		return err
+	}
+	d.ChatRoomType = EChatRoomType(t2)
+	t3, err := rwu.ReadUint64(r)
+	if err != nil {
+		return err
+	}
+	d.SteamIdFriendChat = steamid.SteamId(t3)
+	return err
+}
+
+type MsgClientMarketingMessageUpdate2 struct {
+	MarketingMessageUpdateTime uint32
+	Count                      uint32
+}
+
+func NewMsgClientMarketingMessageUpdate2() *MsgClientMarketingMessageUpdate2 {
+	return &MsgClientMarketingMessageUpdate2{}
+}
+
+func (d *MsgClientMarketingMessageUpdate2) GetEMsg() EMsg {
+	return EMsg_ClientMarketingMessageUpdate2
+}
+
+func (d *MsgClientMarketingMessageUpdate2) Serialize(w io.Writer) error {
+	var err error
+	err = binary.Write(w, binary.LittleEndian, d.MarketingMessageUpdateTime)
+	if err != nil {
+		return err
+	}
+	err = binary.Write(w, binary.LittleEndian, d.Count)
+	return err
+}
+
+func (d *MsgClientMarketingMessageUpdate2) Deserialize(r io.Reader) error {
+	var err error
+	d.MarketingMessageUpdateTime, err = rwu.ReadUint32(r)
+	if err != nil {
+		return err
+	}
+	d.Count, err = rwu.ReadUint32(r)
+	return err
+}