strom/proto_generated/v1_21_9/proto.go

package v1_21_9

import (
	"encoding/binary"
	"github.com/admin-else/strom/nbt"
	"github.com/admin-else/strom/proto_base"
	"github.com/google/uuid"
	"io"
)

type HandshakingToServerPacket struct {
	Name   string
	Params any
}

var HandshakingToServerPacketNameMap = map[int32]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"}

func (ret *HandshakingToServerPacket) Decode(r io.Reader) (err error) {
	var HandshakingToServerPacketNameKey int32
	HandshakingToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(HandshakingToServerPacketNameMap, HandshakingToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "legacy_server_list_ping":
		var HandshakingToServerPacketParamsLegacyServerListPingTmp HandshakingToServerPacketLegacyServerListPing
		err = HandshakingToServerPacketParamsLegacyServerListPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = HandshakingToServerPacketParamsLegacyServerListPingTmp
	case "set_protocol":
		var HandshakingToServerPacketParamsSetProtocolTmp HandshakingToServerPacketSetProtocol
		err = HandshakingToServerPacketParamsSetProtocolTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = HandshakingToServerPacketParamsSetProtocolTmp
	}
	return
}

var HandshakingToServerPacketNameReverseMap = map[string]int32{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe}

func (ret *HandshakingToServerPacket) Encode(w io.Writer) (err error) {
	var vHandshakingToServerPacketName int32
	vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "legacy_server_list_ping":
		HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = HandshakingToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_protocol":
		HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = HandshakingToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *HandshakingToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent {
		var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *HandshakingToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonClearDialog struct {
}

func (ret *HandshakingToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *HandshakingToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type HandshakingToServerPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *HandshakingToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *HandshakingToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var HandshakingToServerPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if HandshakingToServerPacketCommonCookieResponseValuePresent {
		var HandshakingToServerPacketCommonCookieResponseValuePresentValue ByteArray
		err = HandshakingToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &HandshakingToServerPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *HandshakingToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *HandshakingToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var HandshakingToServerPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if HandshakingToServerPacketCommonCustomClickActionNbtPresent {
		var HandshakingToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = HandshakingToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &HandshakingToServerPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *HandshakingToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *HandshakingToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lHandshakingToServerPacketCommonCustomReportDetailsDetails int32
	lHandshakingToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lHandshakingToServerPacketCommonCustomReportDetailsDetails {
		var HandshakingToServerPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, HandshakingToServerPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *HandshakingToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iHandshakingToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var HandshakingToServerPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if HandshakingToServerPacketCommonRemoveResourcePackUuidPresent {
		var HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lHandshakingToServerPacketCommonSelectKnownPacksPacks int32
	lHandshakingToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lHandshakingToServerPacketCommonSelectKnownPacksPacks {
		var HandshakingToServerPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, HandshakingToServerPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iHandshakingToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *HandshakingToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lHandshakingToServerPacketCommonServerLinksLinks int32
	lHandshakingToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lHandshakingToServerPacketCommonServerLinksLinks {
		var HandshakingToServerPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			HandshakingToServerPacketCommonServerLinksLinksElement.KnownType = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			HandshakingToServerPacketCommonServerLinksLinksElement.UnknownType = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		HandshakingToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, HandshakingToServerPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *HandshakingToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iHandshakingToServerPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType {
		case true:
			HandshakingToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = HandshakingToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType {
		case false:
			HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToServerPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var HandshakingToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *HandshakingToServerPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var HandshakingToServerPacketCommonSettingsParticleStatusKey int32
	HandshakingToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusMap, HandshakingToServerPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var HandshakingToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *HandshakingToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vHandshakingToServerPacketCommonSettingsParticleStatus int32
	vHandshakingToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *HandshakingToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *HandshakingToServerPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketLegacyServerListPing struct {
	Payload uint8
}

func (ret *HandshakingToServerPacketLegacyServerListPing) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Payload)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketLegacyServerListPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Payload)
	if err != nil {
		return
	}
	return
}

type HandshakingToServerPacketSetProtocol struct {
	ProtocolVersion int32
	ServerHost      string
	ServerPort      uint16
	NextState       int32
}

func (ret *HandshakingToServerPacketSetProtocol) Decode(r io.Reader) (err error) {
	ret.ProtocolVersion, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ServerHost, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ServerPort)
	if err != nil {
		return
	}
	ret.NextState, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ProtocolVersion)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.ServerHost)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ServerPort)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.NextState)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacket struct {
	Name   string
	Params any
}

var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"}

func (ret *StatusToServerPacket) Decode(r io.Reader) (err error) {
	var StatusToServerPacketNameKey int32
	StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		var StatusToServerPacketParamsPingTmp StatusToServerPacketPing
		err = StatusToServerPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToServerPacketParamsPingTmp
	case "ping_start":
		var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart
		err = StatusToServerPacketParamsPingStartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToServerPacketParamsPingStartTmp
	}
	return
}

var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01}

func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) {
	var vStatusToServerPacketName int32
	vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = StatusToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "ping_start":
		StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = StatusToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *StatusToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var StatusToServerPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if StatusToServerPacketCommonAddResourcePackPromptMessagePresent {
		var StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *StatusToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonClearDialog struct {
}

func (ret *StatusToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *StatusToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type StatusToServerPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *StatusToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *StatusToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var StatusToServerPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if StatusToServerPacketCommonCookieResponseValuePresent {
		var StatusToServerPacketCommonCookieResponseValuePresentValue ByteArray
		err = StatusToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &StatusToServerPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *StatusToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *StatusToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var StatusToServerPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if StatusToServerPacketCommonCustomClickActionNbtPresent {
		var StatusToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = StatusToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &StatusToServerPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *StatusToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *StatusToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lStatusToServerPacketCommonCustomReportDetailsDetails int32
	lStatusToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lStatusToServerPacketCommonCustomReportDetailsDetails {
		var StatusToServerPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		StatusToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, StatusToServerPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *StatusToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iStatusToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *StatusToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var StatusToServerPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if StatusToServerPacketCommonRemoveResourcePackUuidPresent {
		var StatusToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, StatusToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &StatusToServerPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *StatusToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *StatusToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lStatusToServerPacketCommonSelectKnownPacksPacks int32
	lStatusToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lStatusToServerPacketCommonSelectKnownPacksPacks {
		var StatusToServerPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		StatusToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, StatusToServerPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *StatusToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iStatusToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *StatusToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lStatusToServerPacketCommonServerLinksLinks int32
	lStatusToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lStatusToServerPacketCommonServerLinksLinks {
		var StatusToServerPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			StatusToServerPacketCommonServerLinksLinksElement.KnownType = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			StatusToServerPacketCommonServerLinksLinksElement.UnknownType = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		StatusToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, StatusToServerPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *StatusToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iStatusToServerPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType {
		case true:
			StatusToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = StatusToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType {
		case false:
			StatusToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = StatusToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iStatusToServerPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type StatusToServerPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var StatusToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *StatusToServerPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var StatusToServerPacketCommonSettingsParticleStatusKey int32
	StatusToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusMap, StatusToServerPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var StatusToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *StatusToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vStatusToServerPacketCommonSettingsParticleStatus int32
	vStatusToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToServerPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *StatusToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *StatusToServerPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketPing struct {
	Time int64
}

func (ret *StatusToServerPacketPing) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	return
}

type StatusToServerPacketPingStart struct {
}

func (ret *StatusToServerPacketPingStart) Decode(r io.Reader) (err error) {
	return
}
func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) {
	return
}

type LoginToServerPacket struct {
	Name   string
	Params any
}

var LoginToServerPacketNameMap = map[int32]string{0x00: "login_start", 0x01: "encryption_begin", 0x02: "login_plugin_response", 0x03: "login_acknowledged", 0x04: "cookie_response"}

func (ret *LoginToServerPacket) Decode(r io.Reader) (err error) {
	var LoginToServerPacketNameKey int32
	LoginToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "cookie_response":
		var LoginToServerPacketParamsCookieResponseTmp LoginToServerPacketCommonCookieResponse
		err = LoginToServerPacketParamsCookieResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsCookieResponseTmp
	case "encryption_begin":
		var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin
		err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsEncryptionBeginTmp
	case "login_acknowledged":
		var LoginToServerPacketParamsLoginAcknowledgedTmp LoginToServerPacketLoginAcknowledged
		err = LoginToServerPacketParamsLoginAcknowledgedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsLoginAcknowledgedTmp
	case "login_plugin_response":
		var LoginToServerPacketParamsLoginPluginResponseTmp LoginToServerPacketLoginPluginResponse
		err = LoginToServerPacketParamsLoginPluginResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsLoginPluginResponseTmp
	case "login_start":
		var LoginToServerPacketParamsLoginStartTmp LoginToServerPacketLoginStart
		err = LoginToServerPacketParamsLoginStartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToServerPacketParamsLoginStartTmp
	}
	return
}

var LoginToServerPacketNameReverseMap = map[string]int32{"login_start": 0x00, "encryption_begin": 0x01, "login_plugin_response": 0x02, "login_acknowledged": 0x03, "cookie_response": 0x04}

func (ret *LoginToServerPacket) Encode(w io.Writer) (err error) {
	var vLoginToServerPacketName int32
	vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "cookie_response":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketCommonCookieResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "encryption_begin":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "login_acknowledged":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginAcknowledged)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "login_plugin_response":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginPluginResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "login_start":
		LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *LoginToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var LoginToServerPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if LoginToServerPacketCommonAddResourcePackPromptMessagePresent {
		var LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *LoginToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonClearDialog struct {
}

func (ret *LoginToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *LoginToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type LoginToServerPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *LoginToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *LoginToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var LoginToServerPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if LoginToServerPacketCommonCookieResponseValuePresent {
		var LoginToServerPacketCommonCookieResponseValuePresentValue ByteArray
		err = LoginToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &LoginToServerPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *LoginToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *LoginToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var LoginToServerPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if LoginToServerPacketCommonCustomClickActionNbtPresent {
		var LoginToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = LoginToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &LoginToServerPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *LoginToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *LoginToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lLoginToServerPacketCommonCustomReportDetailsDetails int32
	lLoginToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lLoginToServerPacketCommonCustomReportDetailsDetails {
		var LoginToServerPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		LoginToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, LoginToServerPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *LoginToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iLoginToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *LoginToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var LoginToServerPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if LoginToServerPacketCommonRemoveResourcePackUuidPresent {
		var LoginToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, LoginToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &LoginToServerPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *LoginToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *LoginToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lLoginToServerPacketCommonSelectKnownPacksPacks int32
	lLoginToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lLoginToServerPacketCommonSelectKnownPacksPacks {
		var LoginToServerPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		LoginToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, LoginToServerPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *LoginToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iLoginToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *LoginToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lLoginToServerPacketCommonServerLinksLinks int32
	lLoginToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lLoginToServerPacketCommonServerLinksLinks {
		var LoginToServerPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			LoginToServerPacketCommonServerLinksLinksElement.KnownType = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			LoginToServerPacketCommonServerLinksLinksElement.UnknownType = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		LoginToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, LoginToServerPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *LoginToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iLoginToServerPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType {
		case true:
			LoginToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = LoginToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType {
		case false:
			LoginToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = LoginToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iLoginToServerPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var LoginToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *LoginToServerPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var LoginToServerPacketCommonSettingsParticleStatusKey int32
	LoginToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusMap, LoginToServerPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var LoginToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *LoginToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vLoginToServerPacketCommonSettingsParticleStatus int32
	vLoginToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToServerPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *LoginToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *LoginToServerPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketEncryptionBegin struct {
	SharedSecret []byte
	VerifyToken  []byte
}

func (ret *LoginToServerPacketEncryptionBegin) Decode(r io.Reader) (err error) {
	var lLoginToServerPacketEncryptionBeginSharedSecret int32
	lLoginToServerPacketEncryptionBeginSharedSecret, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret)))
	if err != nil {
		return
	}
	var lLoginToServerPacketEncryptionBeginVerifyToken int32
	lLoginToServerPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginVerifyToken)))
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketEncryptionBegin) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.SharedSecret)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.SharedSecret)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.VerifyToken)
	if err != nil {
		return
	}
	return
}

type LoginToServerPacketLoginAcknowledged struct {
}

func (ret *LoginToServerPacketLoginAcknowledged) Decode(r io.Reader) (err error) {
	return
}
func (ret *LoginToServerPacketLoginAcknowledged) Encode(w io.Writer) (err error) {
	return
}

type LoginToServerPacketLoginPluginResponse struct {
	MessageId int32
	Data      *proto_base.RestBuffer
}

func (ret *LoginToServerPacketLoginPluginResponse) Decode(r io.Reader) (err error) {
	ret.MessageId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var LoginToServerPacketLoginPluginResponseDataPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToServerPacketLoginPluginResponseDataPresent)
	if err != nil {
		return
	}
	if LoginToServerPacketLoginPluginResponseDataPresent {
		var LoginToServerPacketLoginPluginResponseDataPresentValue proto_base.RestBuffer
		err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue
	}
	return
}
func (ret *LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.MessageId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data != nil)
	if err != nil {
		return
	}
	if ret.Data != nil {
		err = (*ret.Data).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToServerPacketLoginStart struct {
	Username   string
	PlayerUUID uuid.UUID
}

func (ret *LoginToServerPacketLoginStart) Decode(r io.Reader) (err error) {
	ret.Username, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	_, err = io.ReadFull(r, ret.PlayerUUID[:])
	if err != nil {
		return
	}
	return
}
func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Username)
	if err != nil {
		return
	}
	_, err = w.Write(ret.PlayerUUID[:])
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacket struct {
	Name   string
	Params any
}

var ConfigurationToServerPacketNameMap = map[int32]string{0x00: "settings", 0x01: "cookie_response", 0x02: "custom_payload", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "pong", 0x06: "resource_pack_receive", 0x07: "select_known_packs", 0x08: "custom_click_action", 0x09: "accept_code_of_conduct"}

func (ret *ConfigurationToServerPacket) Decode(r io.Reader) (err error) {
	var ConfigurationToServerPacketNameKey int32
	ConfigurationToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameMap, ConfigurationToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "accept_code_of_conduct":
		var ConfigurationToServerPacketParamsAcceptCodeOfConductTmp ConfigurationToServerPacketAcceptCodeOfConduct
		err = ConfigurationToServerPacketParamsAcceptCodeOfConductTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsAcceptCodeOfConductTmp
	case "cookie_response":
		var ConfigurationToServerPacketParamsCookieResponseTmp ConfigurationToServerPacketCommonCookieResponse
		err = ConfigurationToServerPacketParamsCookieResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsCookieResponseTmp
	case "custom_click_action":
		var ConfigurationToServerPacketParamsCustomClickActionTmp ConfigurationToServerPacketCommonCustomClickAction
		err = ConfigurationToServerPacketParamsCustomClickActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsCustomClickActionTmp
	case "custom_payload":
		var ConfigurationToServerPacketParamsCustomPayloadTmp ConfigurationToServerPacketCustomPayload
		err = ConfigurationToServerPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsCustomPayloadTmp
	case "finish_configuration":
		var ConfigurationToServerPacketParamsFinishConfigurationTmp ConfigurationToServerPacketFinishConfiguration
		err = ConfigurationToServerPacketParamsFinishConfigurationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsFinishConfigurationTmp
	case "keep_alive":
		var ConfigurationToServerPacketParamsKeepAliveTmp ConfigurationToServerPacketKeepAlive
		err = ConfigurationToServerPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsKeepAliveTmp
	case "pong":
		var ConfigurationToServerPacketParamsPongTmp ConfigurationToServerPacketPong
		err = ConfigurationToServerPacketParamsPongTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsPongTmp
	case "resource_pack_receive":
		var ConfigurationToServerPacketParamsResourcePackReceiveTmp ConfigurationToServerPacketResourcePackReceive
		err = ConfigurationToServerPacketParamsResourcePackReceiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsResourcePackReceiveTmp
	case "select_known_packs":
		var ConfigurationToServerPacketParamsSelectKnownPacksTmp ConfigurationToServerPacketCommonSelectKnownPacks
		err = ConfigurationToServerPacketParamsSelectKnownPacksTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsSelectKnownPacksTmp
	case "settings":
		var ConfigurationToServerPacketParamsSettingsTmp ConfigurationToServerPacketCommonSettings
		err = ConfigurationToServerPacketParamsSettingsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToServerPacketParamsSettingsTmp
	}
	return
}

var ConfigurationToServerPacketNameReverseMap = map[string]int32{"settings": 0x00, "cookie_response": 0x01, "custom_payload": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "pong": 0x05, "resource_pack_receive": 0x06, "select_known_packs": 0x07, "custom_click_action": 0x08, "accept_code_of_conduct": 0x09}

func (ret *ConfigurationToServerPacket) Encode(w io.Writer) (err error) {
	var vConfigurationToServerPacketName int32
	vConfigurationToServerPacketName, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "accept_code_of_conduct":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketAcceptCodeOfConduct)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "cookie_response":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCookieResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_click_action":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCustomClickAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "finish_configuration":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketFinishConfiguration)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "pong":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketPong)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_receive":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketResourcePackReceive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "select_known_packs":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSelectKnownPacks)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "settings":
		ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSettings)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketAcceptCodeOfConduct struct {
}

func (ret *ConfigurationToServerPacketAcceptCodeOfConduct) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToServerPacketAcceptCodeOfConduct) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToServerPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *ConfigurationToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent {
		var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *ConfigurationToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonClearDialog struct {
}

func (ret *ConfigurationToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToServerPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *ConfigurationToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *ConfigurationToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ConfigurationToServerPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if ConfigurationToServerPacketCommonCookieResponseValuePresent {
		var ConfigurationToServerPacketCommonCookieResponseValuePresentValue ByteArray
		err = ConfigurationToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &ConfigurationToServerPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *ConfigurationToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *ConfigurationToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ConfigurationToServerPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if ConfigurationToServerPacketCommonCustomClickActionNbtPresent {
		var ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *ConfigurationToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lConfigurationToServerPacketCommonCustomReportDetailsDetails int32
	lConfigurationToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lConfigurationToServerPacketCommonCustomReportDetailsDetails {
		var ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iConfigurationToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent {
		var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lConfigurationToServerPacketCommonSelectKnownPacksPacks int32
	lConfigurationToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lConfigurationToServerPacketCommonSelectKnownPacksPacks {
		var ConfigurationToServerPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, ConfigurationToServerPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iConfigurationToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *ConfigurationToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lConfigurationToServerPacketCommonServerLinksLinks int32
	lConfigurationToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lConfigurationToServerPacketCommonServerLinksLinks {
		var ConfigurationToServerPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			ConfigurationToServerPacketCommonServerLinksLinksElement.KnownType = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			ConfigurationToServerPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		ConfigurationToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, ConfigurationToServerPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *ConfigurationToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iConfigurationToServerPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType {
		case true:
			ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType {
		case false:
			ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToServerPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var ConfigurationToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *ConfigurationToServerPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var ConfigurationToServerPacketCommonSettingsParticleStatusKey int32
	ConfigurationToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusMap, ConfigurationToServerPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *ConfigurationToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vConfigurationToServerPacketCommonSettingsParticleStatus int32
	vConfigurationToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *ConfigurationToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *ConfigurationToServerPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *ConfigurationToServerPacketCustomPayload) Decode(r io.Reader) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketFinishConfiguration struct {
}

func (ret *ConfigurationToServerPacketFinishConfiguration) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToServerPacketFinishConfiguration) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToServerPacketKeepAlive struct {
	KeepAliveId int64
}

func (ret *ConfigurationToServerPacketKeepAlive) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketPong struct {
	Id int32
}

func (ret *ConfigurationToServerPacketPong) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketPong) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type ConfigurationToServerPacketResourcePackReceive struct {
	Uuid   uuid.UUID
	Result int32
}

func (ret *ConfigurationToServerPacketResourcePackReceive) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Result, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Result)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacket struct {
	Name   string
	Params any
}

var ConfigurationToClientPacketNameMap = map[int32]string{0x00: "cookie_request", 0x01: "custom_payload", 0x02: "disconnect", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "ping", 0x06: "reset_chat", 0x07: "registry_data", 0x08: "remove_resource_pack", 0x09: "add_resource_pack", 0x0a: "store_cookie", 0x0b: "transfer", 0x0c: "feature_flags", 0x0d: "tags", 0x0e: "select_known_packs", 0x0f: "custom_report_details", 0x10: "server_links", 0x11: "clear_dialog", 0x12: "show_dialog", 0x13: "code_of_conduct"}

func (ret *ConfigurationToClientPacket) Decode(r io.Reader) (err error) {
	var ConfigurationToClientPacketNameKey int32
	ConfigurationToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameMap, ConfigurationToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "add_resource_pack":
		var ConfigurationToClientPacketParamsAddResourcePackTmp ConfigurationToClientPacketCommonAddResourcePack
		err = ConfigurationToClientPacketParamsAddResourcePackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsAddResourcePackTmp
	case "clear_dialog":
		var ConfigurationToClientPacketParamsClearDialogTmp ConfigurationToClientPacketCommonClearDialog
		err = ConfigurationToClientPacketParamsClearDialogTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsClearDialogTmp
	case "code_of_conduct":
		var ConfigurationToClientPacketParamsCodeOfConductTmp ConfigurationToClientPacketCodeOfConduct
		err = ConfigurationToClientPacketParamsCodeOfConductTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsCodeOfConductTmp
	case "cookie_request":
		var ConfigurationToClientPacketParamsCookieRequestTmp ConfigurationToClientPacketCommonCookieRequest
		err = ConfigurationToClientPacketParamsCookieRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsCookieRequestTmp
	case "custom_payload":
		var ConfigurationToClientPacketParamsCustomPayloadTmp ConfigurationToClientPacketCustomPayload
		err = ConfigurationToClientPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsCustomPayloadTmp
	case "custom_report_details":
		var ConfigurationToClientPacketParamsCustomReportDetailsTmp ConfigurationToClientPacketCommonCustomReportDetails
		err = ConfigurationToClientPacketParamsCustomReportDetailsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsCustomReportDetailsTmp
	case "disconnect":
		var ConfigurationToClientPacketParamsDisconnectTmp ConfigurationToClientPacketDisconnect
		err = ConfigurationToClientPacketParamsDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsDisconnectTmp
	case "feature_flags":
		var ConfigurationToClientPacketParamsFeatureFlagsTmp ConfigurationToClientPacketFeatureFlags
		err = ConfigurationToClientPacketParamsFeatureFlagsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsFeatureFlagsTmp
	case "finish_configuration":
		var ConfigurationToClientPacketParamsFinishConfigurationTmp ConfigurationToClientPacketFinishConfiguration
		err = ConfigurationToClientPacketParamsFinishConfigurationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsFinishConfigurationTmp
	case "keep_alive":
		var ConfigurationToClientPacketParamsKeepAliveTmp ConfigurationToClientPacketKeepAlive
		err = ConfigurationToClientPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsKeepAliveTmp
	case "ping":
		var ConfigurationToClientPacketParamsPingTmp ConfigurationToClientPacketPing
		err = ConfigurationToClientPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsPingTmp
	case "registry_data":
		var ConfigurationToClientPacketParamsRegistryDataTmp ConfigurationToClientPacketRegistryData
		err = ConfigurationToClientPacketParamsRegistryDataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsRegistryDataTmp
	case "remove_resource_pack":
		var ConfigurationToClientPacketParamsRemoveResourcePackTmp ConfigurationToClientPacketCommonRemoveResourcePack
		err = ConfigurationToClientPacketParamsRemoveResourcePackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsRemoveResourcePackTmp
	case "reset_chat":
		var ConfigurationToClientPacketParamsResetChatTmp ConfigurationToClientPacketResetChat
		err = ConfigurationToClientPacketParamsResetChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsResetChatTmp
	case "select_known_packs":
		var ConfigurationToClientPacketParamsSelectKnownPacksTmp ConfigurationToClientPacketCommonSelectKnownPacks
		err = ConfigurationToClientPacketParamsSelectKnownPacksTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsSelectKnownPacksTmp
	case "server_links":
		var ConfigurationToClientPacketParamsServerLinksTmp ConfigurationToClientPacketCommonServerLinks
		err = ConfigurationToClientPacketParamsServerLinksTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsServerLinksTmp
	case "show_dialog":
		var ConfigurationToClientPacketParamsShowDialogTmp ConfigurationToClientPacketShowDialog
		err = ConfigurationToClientPacketParamsShowDialogTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsShowDialogTmp
	case "store_cookie":
		var ConfigurationToClientPacketParamsStoreCookieTmp ConfigurationToClientPacketCommonStoreCookie
		err = ConfigurationToClientPacketParamsStoreCookieTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsStoreCookieTmp
	case "tags":
		var ConfigurationToClientPacketParamsTagsTmp ConfigurationToClientPacketTags
		err = ConfigurationToClientPacketParamsTagsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsTagsTmp
	case "transfer":
		var ConfigurationToClientPacketParamsTransferTmp ConfigurationToClientPacketCommonTransfer
		err = ConfigurationToClientPacketParamsTransferTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = ConfigurationToClientPacketParamsTransferTmp
	}
	return
}

var ConfigurationToClientPacketNameReverseMap = map[string]int32{"cookie_request": 0x00, "custom_payload": 0x01, "disconnect": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "ping": 0x05, "reset_chat": 0x06, "registry_data": 0x07, "remove_resource_pack": 0x08, "add_resource_pack": 0x09, "store_cookie": 0x0a, "transfer": 0x0b, "feature_flags": 0x0c, "tags": 0x0d, "select_known_packs": 0x0e, "custom_report_details": 0x0f, "server_links": 0x10, "clear_dialog": 0x11, "show_dialog": 0x12, "code_of_conduct": 0x13}

func (ret *ConfigurationToClientPacket) Encode(w io.Writer) (err error) {
	var vConfigurationToClientPacketName int32
	vConfigurationToClientPacketName, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "add_resource_pack":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonAddResourcePack)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "clear_dialog":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonClearDialog)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "code_of_conduct":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCodeOfConduct)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "cookie_request":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCookieRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_report_details":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCustomReportDetails)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "disconnect":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "feature_flags":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFeatureFlags)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "finish_configuration":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFinishConfiguration)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "ping":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "registry_data":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketRegistryData)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "remove_resource_pack":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonRemoveResourcePack)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "reset_chat":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketResetChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "select_known_packs":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonSelectKnownPacks)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "server_links":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonServerLinks)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "show_dialog":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketShowDialog)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "store_cookie":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonStoreCookie)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tags":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketTags)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "transfer":
		ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonTransfer)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ConfigurationToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCodeOfConduct struct {
	Contents string
}

func (ret *ConfigurationToClientPacketCodeOfConduct) Decode(r io.Reader) (err error) {
	ret.Contents, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketCodeOfConduct) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Contents)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *ConfigurationToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent {
		var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *ConfigurationToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonClearDialog struct {
}

func (ret *ConfigurationToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToClientPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *ConfigurationToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *ConfigurationToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ConfigurationToClientPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if ConfigurationToClientPacketCommonCookieResponseValuePresent {
		var ConfigurationToClientPacketCommonCookieResponseValuePresentValue ByteArray
		err = ConfigurationToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &ConfigurationToClientPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *ConfigurationToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *ConfigurationToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ConfigurationToClientPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if ConfigurationToClientPacketCommonCustomClickActionNbtPresent {
		var ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *ConfigurationToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lConfigurationToClientPacketCommonCustomReportDetailsDetails int32
	lConfigurationToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lConfigurationToClientPacketCommonCustomReportDetailsDetails {
		var ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent {
		var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lConfigurationToClientPacketCommonSelectKnownPacksPacks int32
	lConfigurationToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lConfigurationToClientPacketCommonSelectKnownPacksPacks {
		var ConfigurationToClientPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, ConfigurationToClientPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *ConfigurationToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lConfigurationToClientPacketCommonServerLinksLinks int32
	lConfigurationToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lConfigurationToClientPacketCommonServerLinksLinks {
		var ConfigurationToClientPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			ConfigurationToClientPacketCommonServerLinksLinksElement.KnownType = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			ConfigurationToClientPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		ConfigurationToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, ConfigurationToClientPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *ConfigurationToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType {
		case true:
			ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType {
		case false:
			ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var ConfigurationToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *ConfigurationToClientPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var ConfigurationToClientPacketCommonSettingsParticleStatusKey int32
	ConfigurationToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusMap, ConfigurationToClientPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *ConfigurationToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vConfigurationToClientPacketCommonSettingsParticleStatus int32
	vConfigurationToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *ConfigurationToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *ConfigurationToClientPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *ConfigurationToClientPacketCustomPayload) Decode(r io.Reader) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketDisconnect struct {
	Reason nbt.Anon
}

func (ret *ConfigurationToClientPacketDisconnect) Decode(r io.Reader) (err error) {
	err = ret.Reason.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketDisconnect) Encode(w io.Writer) (err error) {
	err = ret.Reason.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketFeatureFlags struct {
	Features []string
}

func (ret *ConfigurationToClientPacketFeatureFlags) Decode(r io.Reader) (err error) {
	var lConfigurationToClientPacketFeatureFlagsFeatures int32
	lConfigurationToClientPacketFeatureFlagsFeatures, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Features = []string{}
	for range lConfigurationToClientPacketFeatureFlagsFeatures {
		var ConfigurationToClientPacketFeatureFlagsFeaturesElement string
		ConfigurationToClientPacketFeatureFlagsFeaturesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Features = append(ret.Features, ConfigurationToClientPacketFeatureFlagsFeaturesElement)
	}
	return
}
func (ret *ConfigurationToClientPacketFeatureFlags) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Features)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketFeatureFlagsFeatures := range len(ret.Features) {
		err = proto_base.EncodeString(w, ret.Features[iConfigurationToClientPacketFeatureFlagsFeatures])
		if err != nil {
			return
		}
	}
	return
}

type ConfigurationToClientPacketFinishConfiguration struct {
}

func (ret *ConfigurationToClientPacketFinishConfiguration) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToClientPacketFinishConfiguration) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToClientPacketKeepAlive struct {
	KeepAliveId int64
}

func (ret *ConfigurationToClientPacketKeepAlive) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketPing struct {
	Id int32
}

func (ret *ConfigurationToClientPacketPing) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketRegistryData struct {
	Id      string
	Entries []struct {
		Key   string
		Value *nbt.Anon
	}
}

func (ret *ConfigurationToClientPacketRegistryData) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lConfigurationToClientPacketRegistryDataEntries int32
	lConfigurationToClientPacketRegistryDataEntries, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Entries = []struct {
		Key   string
		Value *nbt.Anon
	}{}
	for range lConfigurationToClientPacketRegistryDataEntries {
		var ConfigurationToClientPacketRegistryDataEntriesElement struct {
			Key   string
			Value *nbt.Anon
		}
		ConfigurationToClientPacketRegistryDataEntriesElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var ConfigurationToClientPacketRegistryDataEntriesElementValuePresent bool
		err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketRegistryDataEntriesElementValuePresent)
		if err != nil {
			return
		}
		if ConfigurationToClientPacketRegistryDataEntriesElementValuePresent {
			var ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue nbt.Anon
			err = ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue.Decode(r)
			if err != nil {
				return
			}
			ConfigurationToClientPacketRegistryDataEntriesElement.Value = &ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue
		}
		ret.Entries = append(ret.Entries, ConfigurationToClientPacketRegistryDataEntriesElement)
	}
	return
}
func (ret *ConfigurationToClientPacketRegistryData) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketRegistryDataEntries := range len(ret.Entries) {
		err = proto_base.EncodeString(w, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Key)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil)
		if err != nil {
			return
		}
		if ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil {
			err = (*ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value).Encode(w)
			if err != nil {
				return
			}
		}
	}
	return
}

type ConfigurationToClientPacketResetChat struct {
}

func (ret *ConfigurationToClientPacketResetChat) Decode(r io.Reader) (err error) {
	return
}
func (ret *ConfigurationToClientPacketResetChat) Encode(w io.Writer) (err error) {
	return
}

type ConfigurationToClientPacketShowDialog struct {
	Dialog nbt.Anon
}

func (ret *ConfigurationToClientPacketShowDialog) Decode(r io.Reader) (err error) {
	err = ret.Dialog.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ConfigurationToClientPacketShowDialog) Encode(w io.Writer) (err error) {
	err = ret.Dialog.Encode(w)
	if err != nil {
		return
	}
	return
}

type ConfigurationToClientPacketTags struct {
	Tags []struct {
		TagType string
		Tags    Tags
	}
}

func (ret *ConfigurationToClientPacketTags) Decode(r io.Reader) (err error) {
	var lConfigurationToClientPacketTagsTags int32
	lConfigurationToClientPacketTagsTags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Tags = []struct {
		TagType string
		Tags    Tags
	}{}
	for range lConfigurationToClientPacketTagsTags {
		var ConfigurationToClientPacketTagsTagsElement struct {
			TagType string
			Tags    Tags
		}
		ConfigurationToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		err = ConfigurationToClientPacketTagsTagsElement.Tags.Decode(r)
		if err != nil {
			return
		}
		ret.Tags = append(ret.Tags, ConfigurationToClientPacketTagsTagsElement)
	}
	return
}
func (ret *ConfigurationToClientPacketTags) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Tags)))
	if err != nil {
		return
	}
	for iConfigurationToClientPacketTagsTags := range len(ret.Tags) {
		err = proto_base.EncodeString(w, ret.Tags[iConfigurationToClientPacketTagsTags].TagType)
		if err != nil {
			return
		}
		err = ret.Tags[iConfigurationToClientPacketTagsTags].Tags.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerMovementFlags struct {
	Val uint8
}

func (ret *PlayToServerMovementFlags) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Val)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerMovementFlags) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Val)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacket struct {
	Name   string
	Params any
}

var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "select_bundle_item", 0x03: "set_difficulty", 0x04: "change_gamemode", 0x05: "message_acknowledgement", 0x06: "chat_command", 0x07: "chat_command_signed", 0x08: "chat_message", 0x09: "chat_session_update", 0x0a: "chunk_batch_received", 0x0b: "client_command", 0x0c: "tick_end", 0x0d: "settings", 0x0e: "tab_complete", 0x0f: "configuration_acknowledged", 0x10: "enchant_item", 0x11: "window_click", 0x12: "close_window", 0x13: "set_slot_state", 0x14: "cookie_response", 0x15: "custom_payload", 0x16: "debug_subscription_request", 0x17: "edit_book", 0x18: "query_entity_nbt", 0x19: "use_entity", 0x1a: "generate_structure", 0x1b: "keep_alive", 0x1c: "lock_difficulty", 0x1d: "position", 0x1e: "position_look", 0x1f: "look", 0x20: "flying", 0x21: "vehicle_move", 0x22: "steer_boat", 0x23: "pick_item_from_block", 0x24: "pick_item_from_entity", 0x25: "ping_request", 0x26: "craft_recipe_request", 0x27: "abilities", 0x28: "block_dig", 0x29: "entity_action", 0x2a: "player_input", 0x2b: "player_loaded", 0x2c: "pong", 0x2d: "recipe_book", 0x2e: "displayed_recipe", 0x2f: "name_item", 0x30: "resource_pack_receive", 0x31: "advancement_tab", 0x32: "select_trade", 0x33: "set_beacon_effect", 0x34: "held_item_slot", 0x35: "update_command_block", 0x36: "update_command_block_minecart", 0x37: "set_creative_slot", 0x38: "update_jigsaw_block", 0x39: "update_structure_block", 0x3a: "set_test_block", 0x3b: "update_sign", 0x3c: "arm_animation", 0x3d: "spectate", 0x3e: "test_instance_block_action", 0x3f: "block_place", 0x40: "use_item", 0x41: "custom_click_action"}

func (ret *PlayToServerPacket) Decode(r io.Reader) (err error) {
	var PlayToServerPacketNameKey int32
	PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities
		err = PlayToServerPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsAbilitiesTmp
	case "advancement_tab":
		var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab
		err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsAdvancementTabTmp
	case "arm_animation":
		var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation
		err = PlayToServerPacketParamsArmAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsArmAnimationTmp
	case "block_dig":
		var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig
		err = PlayToServerPacketParamsBlockDigTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockDigTmp
	case "block_place":
		var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace
		err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsBlockPlaceTmp
	case "change_gamemode":
		var PlayToServerPacketParamsChangeGamemodeTmp PlayToServerPacketChangeGamemode
		err = PlayToServerPacketParamsChangeGamemodeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChangeGamemodeTmp
	case "chat_command":
		var PlayToServerPacketParamsChatCommandTmp PlayToServerPacketChatCommand
		err = PlayToServerPacketParamsChatCommandTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatCommandTmp
	case "chat_command_signed":
		var PlayToServerPacketParamsChatCommandSignedTmp PlayToServerPacketChatCommandSigned
		err = PlayToServerPacketParamsChatCommandSignedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatCommandSignedTmp
	case "chat_message":
		var PlayToServerPacketParamsChatMessageTmp PlayToServerPacketChatMessage
		err = PlayToServerPacketParamsChatMessageTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatMessageTmp
	case "chat_session_update":
		var PlayToServerPacketParamsChatSessionUpdateTmp PlayToServerPacketChatSessionUpdate
		err = PlayToServerPacketParamsChatSessionUpdateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChatSessionUpdateTmp
	case "chunk_batch_received":
		var PlayToServerPacketParamsChunkBatchReceivedTmp PlayToServerPacketChunkBatchReceived
		err = PlayToServerPacketParamsChunkBatchReceivedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsChunkBatchReceivedTmp
	case "client_command":
		var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand
		err = PlayToServerPacketParamsClientCommandTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsClientCommandTmp
	case "close_window":
		var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow
		err = PlayToServerPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCloseWindowTmp
	case "configuration_acknowledged":
		var PlayToServerPacketParamsConfigurationAcknowledgedTmp PlayToServerPacketConfigurationAcknowledged
		err = PlayToServerPacketParamsConfigurationAcknowledgedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsConfigurationAcknowledgedTmp
	case "cookie_response":
		var PlayToServerPacketParamsCookieResponseTmp PlayToServerPacketCommonCookieResponse
		err = PlayToServerPacketParamsCookieResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCookieResponseTmp
	case "craft_recipe_request":
		var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest
		err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp
	case "custom_click_action":
		var PlayToServerPacketParamsCustomClickActionTmp PlayToServerPacketCommonCustomClickAction
		err = PlayToServerPacketParamsCustomClickActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCustomClickActionTmp
	case "custom_payload":
		var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload
		err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsCustomPayloadTmp
	case "debug_subscription_request":
		var PlayToServerPacketParamsDebugSubscriptionRequestTmp PlayToServerPacketDebugSubscriptionRequest
		err = PlayToServerPacketParamsDebugSubscriptionRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsDebugSubscriptionRequestTmp
	case "displayed_recipe":
		var PlayToServerPacketParamsDisplayedRecipeTmp PlayToServerPacketDisplayedRecipe
		err = PlayToServerPacketParamsDisplayedRecipeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsDisplayedRecipeTmp
	case "edit_book":
		var PlayToServerPacketParamsEditBookTmp PlayToServerPacketEditBook
		err = PlayToServerPacketParamsEditBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEditBookTmp
	case "enchant_item":
		var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem
		err = PlayToServerPacketParamsEnchantItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEnchantItemTmp
	case "entity_action":
		var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction
		err = PlayToServerPacketParamsEntityActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsEntityActionTmp
	case "flying":
		var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying
		err = PlayToServerPacketParamsFlyingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsFlyingTmp
	case "generate_structure":
		var PlayToServerPacketParamsGenerateStructureTmp PlayToServerPacketGenerateStructure
		err = PlayToServerPacketParamsGenerateStructureTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsGenerateStructureTmp
	case "held_item_slot":
		var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot
		err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsHeldItemSlotTmp
	case "keep_alive":
		var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive
		err = PlayToServerPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsKeepAliveTmp
	case "lock_difficulty":
		var PlayToServerPacketParamsLockDifficultyTmp PlayToServerPacketLockDifficulty
		err = PlayToServerPacketParamsLockDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsLockDifficultyTmp
	case "look":
		var PlayToServerPacketParamsLookTmp PlayToServerPacketLook
		err = PlayToServerPacketParamsLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsLookTmp
	case "message_acknowledgement":
		var PlayToServerPacketParamsMessageAcknowledgementTmp PlayToServerPacketMessageAcknowledgement
		err = PlayToServerPacketParamsMessageAcknowledgementTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsMessageAcknowledgementTmp
	case "name_item":
		var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem
		err = PlayToServerPacketParamsNameItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsNameItemTmp
	case "pick_item_from_block":
		var PlayToServerPacketParamsPickItemFromBlockTmp PlayToServerPacketPickItemFromBlock
		err = PlayToServerPacketParamsPickItemFromBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPickItemFromBlockTmp
	case "pick_item_from_entity":
		var PlayToServerPacketParamsPickItemFromEntityTmp PlayToServerPacketPickItemFromEntity
		err = PlayToServerPacketParamsPickItemFromEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPickItemFromEntityTmp
	case "ping_request":
		var PlayToServerPacketParamsPingRequestTmp PlayToServerPacketPingRequest
		err = PlayToServerPacketParamsPingRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPingRequestTmp
	case "player_input":
		var PlayToServerPacketParamsPlayerInputTmp PlayToServerPacketPlayerInput
		err = PlayToServerPacketParamsPlayerInputTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPlayerInputTmp
	case "player_loaded":
		var PlayToServerPacketParamsPlayerLoadedTmp PlayToServerPacketPlayerLoaded
		err = PlayToServerPacketParamsPlayerLoadedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPlayerLoadedTmp
	case "pong":
		var PlayToServerPacketParamsPongTmp PlayToServerPacketPong
		err = PlayToServerPacketParamsPongTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPongTmp
	case "position":
		var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition
		err = PlayToServerPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionTmp
	case "position_look":
		var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook
		err = PlayToServerPacketParamsPositionLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsPositionLookTmp
	case "query_block_nbt":
		var PlayToServerPacketParamsQueryBlockNbtTmp PlayToServerPacketQueryBlockNbt
		err = PlayToServerPacketParamsQueryBlockNbtTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsQueryBlockNbtTmp
	case "query_entity_nbt":
		var PlayToServerPacketParamsQueryEntityNbtTmp PlayToServerPacketQueryEntityNbt
		err = PlayToServerPacketParamsQueryEntityNbtTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsQueryEntityNbtTmp
	case "recipe_book":
		var PlayToServerPacketParamsRecipeBookTmp PlayToServerPacketRecipeBook
		err = PlayToServerPacketParamsRecipeBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsRecipeBookTmp
	case "resource_pack_receive":
		var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive
		err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp
	case "select_bundle_item":
		var PlayToServerPacketParamsSelectBundleItemTmp PlayToServerPacketSelectBundleItem
		err = PlayToServerPacketParamsSelectBundleItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSelectBundleItemTmp
	case "select_trade":
		var PlayToServerPacketParamsSelectTradeTmp PlayToServerPacketSelectTrade
		err = PlayToServerPacketParamsSelectTradeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSelectTradeTmp
	case "set_beacon_effect":
		var PlayToServerPacketParamsSetBeaconEffectTmp PlayToServerPacketSetBeaconEffect
		err = PlayToServerPacketParamsSetBeaconEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetBeaconEffectTmp
	case "set_creative_slot":
		var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot
		err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp
	case "set_difficulty":
		var PlayToServerPacketParamsSetDifficultyTmp PlayToServerPacketSetDifficulty
		err = PlayToServerPacketParamsSetDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetDifficultyTmp
	case "set_slot_state":
		var PlayToServerPacketParamsSetSlotStateTmp PlayToServerPacketSetSlotState
		err = PlayToServerPacketParamsSetSlotStateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetSlotStateTmp
	case "set_test_block":
		var PlayToServerPacketParamsSetTestBlockTmp PlayToServerPacketSetTestBlock
		err = PlayToServerPacketParamsSetTestBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSetTestBlockTmp
	case "settings":
		var PlayToServerPacketParamsSettingsTmp PlayToServerPacketCommonSettings
		err = PlayToServerPacketParamsSettingsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSettingsTmp
	case "spectate":
		var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate
		err = PlayToServerPacketParamsSpectateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSpectateTmp
	case "steer_boat":
		var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat
		err = PlayToServerPacketParamsSteerBoatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsSteerBoatTmp
	case "tab_complete":
		var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete
		err = PlayToServerPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTabCompleteTmp
	case "teleport_confirm":
		var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm
		err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTeleportConfirmTmp
	case "test_instance_block_action":
		var PlayToServerPacketParamsTestInstanceBlockActionTmp PlayToServerPacketTestInstanceBlockAction
		err = PlayToServerPacketParamsTestInstanceBlockActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTestInstanceBlockActionTmp
	case "tick_end":
		var PlayToServerPacketParamsTickEndTmp PlayToServerPacketTickEnd
		err = PlayToServerPacketParamsTickEndTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsTickEndTmp
	case "update_command_block":
		var PlayToServerPacketParamsUpdateCommandBlockTmp PlayToServerPacketUpdateCommandBlock
		err = PlayToServerPacketParamsUpdateCommandBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateCommandBlockTmp
	case "update_command_block_minecart":
		var PlayToServerPacketParamsUpdateCommandBlockMinecartTmp PlayToServerPacketUpdateCommandBlockMinecart
		err = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp
	case "update_jigsaw_block":
		var PlayToServerPacketParamsUpdateJigsawBlockTmp PlayToServerPacketUpdateJigsawBlock
		err = PlayToServerPacketParamsUpdateJigsawBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateJigsawBlockTmp
	case "update_sign":
		var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign
		err = PlayToServerPacketParamsUpdateSignTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateSignTmp
	case "update_structure_block":
		var PlayToServerPacketParamsUpdateStructureBlockTmp PlayToServerPacketUpdateStructureBlock
		err = PlayToServerPacketParamsUpdateStructureBlockTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUpdateStructureBlockTmp
	case "use_entity":
		var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity
		err = PlayToServerPacketParamsUseEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUseEntityTmp
	case "use_item":
		var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem
		err = PlayToServerPacketParamsUseItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsUseItemTmp
	case "vehicle_move":
		var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove
		err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsVehicleMoveTmp
	case "window_click":
		var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick
		err = PlayToServerPacketParamsWindowClickTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToServerPacketParamsWindowClickTmp
	}
	return
}

var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "query_block_nbt": 0x01, "select_bundle_item": 0x02, "set_difficulty": 0x03, "change_gamemode": 0x04, "message_acknowledgement": 0x05, "chat_command": 0x06, "chat_command_signed": 0x07, "chat_message": 0x08, "chat_session_update": 0x09, "chunk_batch_received": 0x0a, "client_command": 0x0b, "tick_end": 0x0c, "settings": 0x0d, "tab_complete": 0x0e, "configuration_acknowledged": 0x0f, "enchant_item": 0x10, "window_click": 0x11, "close_window": 0x12, "set_slot_state": 0x13, "cookie_response": 0x14, "custom_payload": 0x15, "debug_subscription_request": 0x16, "edit_book": 0x17, "query_entity_nbt": 0x18, "use_entity": 0x19, "generate_structure": 0x1a, "keep_alive": 0x1b, "lock_difficulty": 0x1c, "position": 0x1d, "position_look": 0x1e, "look": 0x1f, "flying": 0x20, "vehicle_move": 0x21, "steer_boat": 0x22, "pick_item_from_block": 0x23, "pick_item_from_entity": 0x24, "ping_request": 0x25, "craft_recipe_request": 0x26, "abilities": 0x27, "block_dig": 0x28, "entity_action": 0x29, "player_input": 0x2a, "player_loaded": 0x2b, "pong": 0x2c, "recipe_book": 0x2d, "displayed_recipe": 0x2e, "name_item": 0x2f, "resource_pack_receive": 0x30, "advancement_tab": 0x31, "select_trade": 0x32, "set_beacon_effect": 0x33, "held_item_slot": 0x34, "update_command_block": 0x35, "update_command_block_minecart": 0x36, "set_creative_slot": 0x37, "update_jigsaw_block": 0x38, "update_structure_block": 0x39, "set_test_block": 0x3a, "update_sign": 0x3b, "arm_animation": 0x3c, "spectate": 0x3d, "test_instance_block_action": 0x3e, "block_place": 0x3f, "use_item": 0x40, "custom_click_action": 0x41}

func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) {
	var vPlayToServerPacketName int32
	vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "advancement_tab":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "arm_animation":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "block_dig":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "block_place":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "change_gamemode":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChangeGamemode)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chat_command":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommand)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chat_command_signed":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommandSigned)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chat_message":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatMessage)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chat_session_update":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatSessionUpdate)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chunk_batch_received":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChunkBatchReceived)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "client_command":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "configuration_acknowledged":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketConfigurationAcknowledged)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "cookie_response":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCookieResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "craft_recipe_request":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_click_action":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCustomClickAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_subscription_request":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDebugSubscriptionRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "displayed_recipe":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDisplayedRecipe)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "edit_book":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "enchant_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_action":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "flying":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "generate_structure":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketGenerateStructure)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "lock_difficulty":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "message_acknowledgement":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketMessageAcknowledgement)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "name_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "pick_item_from_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "pick_item_from_entity":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "ping_request":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPingRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_input":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerInput)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_loaded":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerLoaded)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "pong":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPong)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "position_look":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "query_block_nbt":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "query_entity_nbt":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "recipe_book":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketRecipeBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "resource_pack_receive":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "select_bundle_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectBundleItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "select_trade":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_beacon_effect":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_creative_slot":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_difficulty":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_slot_state":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetSlotState)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_test_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetTestBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "settings":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonSettings)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "spectate":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "steer_boat":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "teleport_confirm":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "test_instance_block_action":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTestInstanceBlockAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tick_end":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTickEnd)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_command_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_command_block_minecart":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_jigsaw_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_sign":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_structure_block":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "use_entity":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "use_item":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "vehicle_move":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "window_click":
		PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToServerPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketAbilities struct {
	Flags int8
}

func (ret *PlayToServerPacketAbilities) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketAdvancementTab struct {
	Action int32
	TabId  any
}

func (ret *PlayToServerPacketAdvancementTab) Decode(r io.Reader) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToServerPacketAdvancementTabTabId0Tmp string
		PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp
	case 1:
		var PlayToServerPacketAdvancementTabTabId1Tmp struct {
		}
		ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp
	}
	return
}
func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId)
		if err != nil {
			return
		}
	case 1:
		_, ok := ret.TabId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToServerPacketArmAnimation struct {
	Hand int32
}

func (ret *PlayToServerPacketArmAnimation) Decode(r io.Reader) (err error) {
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketBlockDig struct {
	Status   int32
	Location Position
	Face     int8
	Sequence int32
}

func (ret *PlayToServerPacketBlockDig) Decode(r io.Reader) (err error) {
	ret.Status, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Face)
	if err != nil {
		return
	}
	ret.Sequence, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Status)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Face)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Sequence)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketBlockPlace struct {
	Hand           int32
	Location       Position
	Direction      int32
	CursorX        float32
	CursorY        float32
	CursorZ        float32
	InsideBlock    bool
	WorldBorderHit bool
	Sequence       int32
}

func (ret *PlayToServerPacketBlockPlace) Decode(r io.Reader) (err error) {
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Direction, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CursorZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.InsideBlock)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.WorldBorderHit)
	if err != nil {
		return
	}
	ret.Sequence, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Direction)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.InsideBlock)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.WorldBorderHit)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Sequence)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChangeGamemode struct {
	Mode string
}

var PlayToServerPacketChangeGamemodeModeMap = map[int32]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"}

func (ret *PlayToServerPacketChangeGamemode) Decode(r io.Reader) (err error) {
	var PlayToServerPacketChangeGamemodeModeKey int32
	PlayToServerPacketChangeGamemodeModeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeMap, PlayToServerPacketChangeGamemodeModeKey)
	if err != nil {
		return
	}
	return
}

var PlayToServerPacketChangeGamemodeModeReverseMap = map[string]int32{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3}

func (ret *PlayToServerPacketChangeGamemode) Encode(w io.Writer) (err error) {
	var vPlayToServerPacketChangeGamemodeMode int32
	vPlayToServerPacketChangeGamemodeMode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeReverseMap, ret.Mode)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketChangeGamemodeMode)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChatCommand struct {
	Command string
}

func (ret *PlayToServerPacketChatCommand) Decode(r io.Reader) (err error) {
	ret.Command, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChatCommand) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Command)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChatCommandSigned struct {
	Command            string
	Timestamp          int64
	Salt               int64
	ArgumentSignatures []struct {
		ArgumentName string
		Signature    [256]byte
	}
	MessageCount int32
	Acknowledged [3]byte
	Checksum     int8
}

func (ret *PlayToServerPacketChatCommandSigned) Decode(r io.Reader) (err error) {
	ret.Command, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Salt)
	if err != nil {
		return
	}
	var lPlayToServerPacketChatCommandSignedArgumentSignatures int32
	lPlayToServerPacketChatCommandSignedArgumentSignatures, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ArgumentSignatures = []struct {
		ArgumentName string
		Signature    [256]byte
	}{}
	for range lPlayToServerPacketChatCommandSignedArgumentSignatures {
		var PlayToServerPacketChatCommandSignedArgumentSignaturesElement struct {
			ArgumentName string
			Signature    [256]byte
		}
		PlayToServerPacketChatCommandSignedArgumentSignaturesElement.ArgumentName, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		_, err = r.Read(PlayToServerPacketChatCommandSignedArgumentSignaturesElement.Signature[:])
		if err != nil {
			return
		}
		ret.ArgumentSignatures = append(ret.ArgumentSignatures, PlayToServerPacketChatCommandSignedArgumentSignaturesElement)
	}
	ret.MessageCount, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = r.Read(ret.Acknowledged[:])
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Checksum)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChatCommandSigned) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Command)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Salt)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ArgumentSignatures)))
	if err != nil {
		return
	}
	for iPlayToServerPacketChatCommandSignedArgumentSignatures := range len(ret.ArgumentSignatures) {
		err = proto_base.EncodeString(w, ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].ArgumentName)
		if err != nil {
			return
		}
		arr := ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].Signature
		_, err = w.Write(arr[:])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.MessageCount)
	if err != nil {
		return
	}
	arr := ret.Acknowledged
	_, err = w.Write(arr[:])
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Checksum)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChatMessage struct {
	Message      string
	Timestamp    int64
	Salt         int64
	Signature    *[256]byte
	Offset       int32
	Acknowledged [3]byte
	Checksum     uint8
}

func (ret *PlayToServerPacketChatMessage) Decode(r io.Reader) (err error) {
	ret.Message, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Salt)
	if err != nil {
		return
	}
	var PlayToServerPacketChatMessageSignaturePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketChatMessageSignaturePresent)
	if err != nil {
		return
	}
	if PlayToServerPacketChatMessageSignaturePresent {
		var PlayToServerPacketChatMessageSignaturePresentValue [256]byte
		_, err = r.Read(PlayToServerPacketChatMessageSignaturePresentValue[:])
		if err != nil {
			return
		}
		ret.Signature = &PlayToServerPacketChatMessageSignaturePresentValue
	}
	ret.Offset, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = r.Read(ret.Acknowledged[:])
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Checksum)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChatMessage) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Message)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Salt)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Signature != nil)
	if err != nil {
		return
	}
	if ret.Signature != nil {
		arr := *ret.Signature
		_, err = w.Write(arr[:])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.Offset)
	if err != nil {
		return
	}
	arr := ret.Acknowledged
	_, err = w.Write(arr[:])
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Checksum)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChatSessionUpdate struct {
	SessionUUID uuid.UUID
	ExpireTime  int64
	PublicKey   ByteArray
	Signature   ByteArray
}

func (ret *PlayToServerPacketChatSessionUpdate) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.SessionUUID[:])
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ExpireTime)
	if err != nil {
		return
	}
	err = ret.PublicKey.Decode(r)
	if err != nil {
		return
	}
	err = ret.Signature.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChatSessionUpdate) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.SessionUUID[:])
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ExpireTime)
	if err != nil {
		return
	}
	err = ret.PublicKey.Encode(w)
	if err != nil {
		return
	}
	err = ret.Signature.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketChunkBatchReceived struct {
	ChunksPerTick float32
}

func (ret *PlayToServerPacketChunkBatchReceived) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ChunksPerTick)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketChunkBatchReceived) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ChunksPerTick)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketClientCommand struct {
	ActionId int32
}

func (ret *PlayToServerPacketClientCommand) Decode(r io.Reader) (err error) {
	ret.ActionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ActionId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCloseWindow struct {
	WindowId ContainerID
}

func (ret *PlayToServerPacketCloseWindow) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *PlayToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var PlayToServerPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if PlayToServerPacketCommonAddResourcePackPromptMessagePresent {
		var PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *PlayToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonClearDialog struct {
}

func (ret *PlayToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type PlayToServerPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *PlayToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *PlayToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToServerPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if PlayToServerPacketCommonCookieResponseValuePresent {
		var PlayToServerPacketCommonCookieResponseValuePresentValue ByteArray
		err = PlayToServerPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &PlayToServerPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *PlayToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *PlayToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToServerPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketCommonCustomClickActionNbtPresent {
		var PlayToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = PlayToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &PlayToServerPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *PlayToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *PlayToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lPlayToServerPacketCommonCustomReportDetailsDetails int32
	lPlayToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lPlayToServerPacketCommonCustomReportDetailsDetails {
		var PlayToServerPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		PlayToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, PlayToServerPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *PlayToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iPlayToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *PlayToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var PlayToServerPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketCommonRemoveResourcePackUuidPresent {
		var PlayToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, PlayToServerPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &PlayToServerPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *PlayToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *PlayToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lPlayToServerPacketCommonSelectKnownPacksPacks int32
	lPlayToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lPlayToServerPacketCommonSelectKnownPacksPacks {
		var PlayToServerPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		PlayToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, PlayToServerPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *PlayToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iPlayToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *PlayToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lPlayToServerPacketCommonServerLinksLinks int32
	lPlayToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lPlayToServerPacketCommonServerLinksLinks {
		var PlayToServerPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToServerPacketCommonServerLinksLinksElement.KnownType = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToServerPacketCommonServerLinksLinksElement.UnknownType = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		PlayToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, PlayToServerPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *PlayToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iPlayToServerPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType {
		case true:
			PlayToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType {
		case false:
			PlayToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iPlayToServerPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var PlayToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *PlayToServerPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var PlayToServerPacketCommonSettingsParticleStatusKey int32
	PlayToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusMap, PlayToServerPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var PlayToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *PlayToServerPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vPlayToServerPacketCommonSettingsParticleStatus int32
	vPlayToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *PlayToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *PlayToServerPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketConfigurationAcknowledged struct {
}

func (ret *PlayToServerPacketConfigurationAcknowledged) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToServerPacketConfigurationAcknowledged) Encode(w io.Writer) (err error) {
	return
}

type PlayToServerPacketCraftRecipeRequest struct {
	WindowId ContainerID
	RecipeId int32
	MakeAll  bool
}

func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	ret.RecipeId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.MakeAll)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.RecipeId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.MakeAll)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *PlayToServerPacketCustomPayload) Decode(r io.Reader) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketDebugSubscriptionRequest struct {
	Subscriptions []DebugSubscriptionDataType
}

func (ret *PlayToServerPacketDebugSubscriptionRequest) Decode(r io.Reader) (err error) {
	var lPlayToServerPacketDebugSubscriptionRequestSubscriptions int32
	lPlayToServerPacketDebugSubscriptionRequestSubscriptions, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Subscriptions = []DebugSubscriptionDataType{}
	for range lPlayToServerPacketDebugSubscriptionRequestSubscriptions {
		var PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement DebugSubscriptionDataType
		err = PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement.Decode(r)
		if err != nil {
			return
		}
		ret.Subscriptions = append(ret.Subscriptions, PlayToServerPacketDebugSubscriptionRequestSubscriptionsElement)
	}
	return
}
func (ret *PlayToServerPacketDebugSubscriptionRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Subscriptions)))
	if err != nil {
		return
	}
	for iPlayToServerPacketDebugSubscriptionRequestSubscriptions := range len(ret.Subscriptions) {
		err = ret.Subscriptions[iPlayToServerPacketDebugSubscriptionRequestSubscriptions].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketDisplayedRecipe struct {
	RecipeId int32
}

func (ret *PlayToServerPacketDisplayedRecipe) Decode(r io.Reader) (err error) {
	ret.RecipeId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketDisplayedRecipe) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.RecipeId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketEditBook struct {
	Hand  int32
	Pages []string
	Title *string
}

func (ret *PlayToServerPacketEditBook) Decode(r io.Reader) (err error) {
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToServerPacketEditBookPages int32
	lPlayToServerPacketEditBookPages, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Pages = []string{}
	for range lPlayToServerPacketEditBookPages {
		var PlayToServerPacketEditBookPagesElement string
		PlayToServerPacketEditBookPagesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Pages = append(ret.Pages, PlayToServerPacketEditBookPagesElement)
	}
	var PlayToServerPacketEditBookTitlePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketEditBookTitlePresent)
	if err != nil {
		return
	}
	if PlayToServerPacketEditBookTitlePresent {
		var PlayToServerPacketEditBookTitlePresentValue string
		PlayToServerPacketEditBookTitlePresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Title = &PlayToServerPacketEditBookTitlePresentValue
	}
	return
}
func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Pages)))
	if err != nil {
		return
	}
	for iPlayToServerPacketEditBookPages := range len(ret.Pages) {
		err = proto_base.EncodeString(w, ret.Pages[iPlayToServerPacketEditBookPages])
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Title != nil)
	if err != nil {
		return
	}
	if ret.Title != nil {
		err = proto_base.EncodeString(w, *ret.Title)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketEnchantItem struct {
	WindowId    ContainerID
	Enchantment int8
}

func (ret *PlayToServerPacketEnchantItem) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Enchantment)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Enchantment)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketEntityAction struct {
	EntityId  int32
	ActionId  string
	JumpBoost int32
}

var PlayToServerPacketEntityActionActionIdMap = map[int32]string{0: "leave_bed", 1: "start_sprinting", 2: "stop_sprinting", 3: "start_horse_jump", 4: "stop_horse_jump", 5: "open_vehicle_inventory", 6: "start_elytra_flying"}

func (ret *PlayToServerPacketEntityAction) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToServerPacketEntityActionActionIdKey int32
	PlayToServerPacketEntityActionActionIdKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdMap, PlayToServerPacketEntityActionActionIdKey)
	if err != nil {
		return
	}
	ret.JumpBoost, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}

var PlayToServerPacketEntityActionActionIdReverseMap = map[string]int32{"leave_bed": 0, "start_sprinting": 1, "stop_sprinting": 2, "start_horse_jump": 3, "stop_horse_jump": 4, "open_vehicle_inventory": 5, "start_elytra_flying": 6}

func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	var vPlayToServerPacketEntityActionActionId int32
	vPlayToServerPacketEntityActionActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdReverseMap, ret.ActionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketEntityActionActionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.JumpBoost)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketFlying struct {
	Flags PlayToServerMovementFlags
}

func (ret *PlayToServerPacketFlying) Decode(r io.Reader) (err error) {
	err = ret.Flags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) {
	err = ret.Flags.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketGenerateStructure struct {
	Location    Position
	Levels      int32
	KeepJigsaws bool
}

func (ret *PlayToServerPacketGenerateStructure) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Levels, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.KeepJigsaws)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketGenerateStructure) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Levels)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.KeepJigsaws)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketHeldItemSlot struct {
	SlotId int16
}

func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.SlotId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.SlotId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketKeepAlive struct {
	KeepAliveId int64
}

func (ret *PlayToServerPacketKeepAlive) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketLockDifficulty struct {
	Locked bool
}

func (ret *PlayToServerPacketLockDifficulty) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Locked)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketLockDifficulty) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Locked)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketLook struct {
	Yaw   float32
	Pitch float32
	Flags PlayToServerMovementFlags
}

func (ret *PlayToServerPacketLook) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketLook) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketMessageAcknowledgement struct {
	Count int32
}

func (ret *PlayToServerPacketMessageAcknowledgement) Decode(r io.Reader) (err error) {
	ret.Count, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketMessageAcknowledgement) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Count)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketNameItem struct {
	Name string
}

func (ret *PlayToServerPacketNameItem) Decode(r io.Reader) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketNameItem) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPickItemFromBlock struct {
	Position    Position
	IncludeData bool
}

func (ret *PlayToServerPacketPickItemFromBlock) Decode(r io.Reader) (err error) {
	err = ret.Position.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IncludeData)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPickItemFromBlock) Encode(w io.Writer) (err error) {
	err = ret.Position.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IncludeData)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPickItemFromEntity struct {
	EntityId    int32
	IncludeData bool
}

func (ret *PlayToServerPacketPickItemFromEntity) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IncludeData)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPickItemFromEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IncludeData)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPingRequest struct {
	Id int64
}

func (ret *PlayToServerPacketPingRequest) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPingRequest) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPlayerInput struct {
	Inputs uint8
}

func (ret *PlayToServerPacketPlayerInput) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Inputs)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPlayerInput) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Inputs)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPlayerLoaded struct {
}

func (ret *PlayToServerPacketPlayerLoaded) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToServerPacketPlayerLoaded) Encode(w io.Writer) (err error) {
	return
}

type PlayToServerPacketPong struct {
	Id int32
}

func (ret *PlayToServerPacketPong) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPong) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPosition struct {
	X     float64
	Y     float64
	Z     float64
	Flags PlayToServerMovementFlags
}

func (ret *PlayToServerPacketPosition) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = ret.Flags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPosition) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = ret.Flags.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketPositionLook struct {
	X     float64
	Y     float64
	Z     float64
	Yaw   float32
	Pitch float32
	Flags PlayToServerMovementFlags
}

func (ret *PlayToServerPacketPositionLook) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketPositionLook) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketQueryBlockNbt struct {
	TransactionId int32
	Location      Position
}

func (ret *PlayToServerPacketQueryBlockNbt) Decode(r io.Reader) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketQueryBlockNbt) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketQueryEntityNbt struct {
	TransactionId int32
	EntityId      int32
}

func (ret *PlayToServerPacketQueryEntityNbt) Decode(r io.Reader) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketQueryEntityNbt) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketRecipeBook struct {
	BookId       int32
	BookOpen     bool
	FilterActive bool
}

func (ret *PlayToServerPacketRecipeBook) Decode(r io.Reader) (err error) {
	ret.BookId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.BookOpen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FilterActive)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketRecipeBook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.BookId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.BookOpen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilterActive)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketResourcePackReceive struct {
	Uuid   uuid.UUID
	Result int32
}

func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Result, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Result)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSelectBundleItem struct {
	SlotId            int32
	SelectedItemIndex int32
}

func (ret *PlayToServerPacketSelectBundleItem) Decode(r io.Reader) (err error) {
	ret.SlotId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SelectedItemIndex, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSelectBundleItem) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.SlotId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SelectedItemIndex)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSelectTrade struct {
	Slot int32
}

func (ret *PlayToServerPacketSelectTrade) Decode(r io.Reader) (err error) {
	ret.Slot, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSelectTrade) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Slot)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSetBeaconEffect struct {
	PrimaryEffect   *int32
	SecondaryEffect *int32
}

func (ret *PlayToServerPacketSetBeaconEffect) Decode(r io.Reader) (err error) {
	var PlayToServerPacketSetBeaconEffectPrimaryEffectPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectPrimaryEffectPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketSetBeaconEffectPrimaryEffectPresent {
		var PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue int32
		PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.PrimaryEffect = &PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue
	}
	var PlayToServerPacketSetBeaconEffectSecondaryEffectPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectSecondaryEffectPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketSetBeaconEffectSecondaryEffectPresent {
		var PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue int32
		PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.SecondaryEffect = &PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue
	}
	return
}
func (ret *PlayToServerPacketSetBeaconEffect) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.PrimaryEffect != nil)
	if err != nil {
		return
	}
	if ret.PrimaryEffect != nil {
		err = proto_base.EncodeVarInt(w, *ret.PrimaryEffect)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.SecondaryEffect != nil)
	if err != nil {
		return
	}
	if ret.SecondaryEffect != nil {
		err = proto_base.EncodeVarInt(w, *ret.SecondaryEffect)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketSetCreativeSlot struct {
	Slot int16
	Item UntrustedSlot
}

func (ret *PlayToServerPacketSetCreativeSlot) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSetCreativeSlot) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSetDifficulty struct {
	NewDifficulty string
}

var PlayToServerPacketSetDifficultyNewDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"}

func (ret *PlayToServerPacketSetDifficulty) Decode(r io.Reader) (err error) {
	var PlayToServerPacketSetDifficultyNewDifficultyKey int32
	PlayToServerPacketSetDifficultyNewDifficultyKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.NewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyMap, PlayToServerPacketSetDifficultyNewDifficultyKey)
	if err != nil {
		return
	}
	return
}

var PlayToServerPacketSetDifficultyNewDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3}

func (ret *PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) {
	var vPlayToServerPacketSetDifficultyNewDifficulty int32
	vPlayToServerPacketSetDifficultyNewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyReverseMap, ret.NewDifficulty)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToServerPacketSetDifficultyNewDifficulty)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSetSlotState struct {
	SlotId   int32
	WindowId ContainerID
	State    bool
}

func (ret *PlayToServerPacketSetSlotState) Decode(r io.Reader) (err error) {
	ret.SlotId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.State)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSetSlotState) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.SlotId)
	if err != nil {
		return
	}
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.State)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSetTestBlock struct {
	Position Position
	Mode     int32
	Message  string
}

func (ret *PlayToServerPacketSetTestBlock) Decode(r io.Reader) (err error) {
	err = ret.Position.Decode(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Message, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSetTestBlock) Encode(w io.Writer) (err error) {
	err = ret.Position.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Message)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSpectate struct {
	Target uuid.UUID
}

func (ret *PlayToServerPacketSpectate) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Target[:])
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Target[:])
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketSteerBoat struct {
	LeftPaddle  bool
	RightPaddle bool
}

func (ret *PlayToServerPacketSteerBoat) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.LeftPaddle)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.RightPaddle)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketSteerBoat) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.LeftPaddle)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.RightPaddle)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketTabComplete struct {
	TransactionId int32
	Text          string
}

func (ret *PlayToServerPacketTabComplete) Decode(r io.Reader) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Text, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketTeleportConfirm struct {
	TeleportId int32
}

func (ret *PlayToServerPacketTeleportConfirm) Decode(r io.Reader) (err error) {
	ret.TeleportId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TeleportId)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketTestInstanceBlockAction struct {
	Pos    Position
	Action int32
	Data   struct {
		Test           *string
		Size           Vec3i
		Rotation       int32
		IgnoreEntities bool
		Status         int32
		ErrorMessage   *nbt.Anon
	}
}

func (ret *PlayToServerPacketTestInstanceBlockAction) Decode(r io.Reader) (err error) {
	err = ret.Pos.Decode(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToServerPacketTestInstanceBlockActionDataTestPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataTestPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketTestInstanceBlockActionDataTestPresent {
		var PlayToServerPacketTestInstanceBlockActionDataTestPresentValue string
		PlayToServerPacketTestInstanceBlockActionDataTestPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Data.Test = &PlayToServerPacketTestInstanceBlockActionDataTestPresentValue
	}
	err = ret.Data.Size.Decode(r)
	if err != nil {
		return
	}
	ret.Data.Rotation, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Data.IgnoreEntities)
	if err != nil {
		return
	}
	ret.Data.Status, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent)
	if err != nil {
		return
	}
	if PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent {
		var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue nbt.Anon
		err = PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Data.ErrorMessage = &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue
	}
	return
}
func (ret *PlayToServerPacketTestInstanceBlockAction) Encode(w io.Writer) (err error) {
	err = ret.Pos.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data.Test != nil)
	if err != nil {
		return
	}
	if ret.Data.Test != nil {
		err = proto_base.EncodeString(w, *ret.Data.Test)
		if err != nil {
			return
		}
	}
	err = ret.Data.Size.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Data.Rotation)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data.IgnoreEntities)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Data.Status)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data.ErrorMessage != nil)
	if err != nil {
		return
	}
	if ret.Data.ErrorMessage != nil {
		err = (*ret.Data.ErrorMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToServerPacketTickEnd struct {
}

func (ret *PlayToServerPacketTickEnd) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToServerPacketTickEnd) Encode(w io.Writer) (err error) {
	return
}

type PlayToServerPacketUpdateCommandBlock struct {
	Location Position
	Command  string
	Mode     int32
	Flags    uint8
}

func (ret *PlayToServerPacketUpdateCommandBlock) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Command, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateCommandBlock) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Command)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateCommandBlockMinecart struct {
	EntityId    int32
	Command     string
	TrackOutput bool
}

func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Command, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.TrackOutput)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Command)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.TrackOutput)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateJigsawBlock struct {
	Location          Position
	Name              string
	Target            string
	Pool              string
	FinalState        string
	JointType         string
	SelectionPriority int32
	PlacementPriority int32
}

func (ret *PlayToServerPacketUpdateJigsawBlock) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Target, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Pool, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.FinalState, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.JointType, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.SelectionPriority, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PlacementPriority, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Target)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Pool)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.FinalState)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.JointType)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SelectionPriority)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.PlacementPriority)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateSign struct {
	Location    Position
	IsFrontText bool
	Text1       string
	Text2       string
	Text3       string
	Text4       string
}

func (ret *PlayToServerPacketUpdateSign) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFrontText)
	if err != nil {
		return
	}
	ret.Text1, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text2, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text3, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Text4, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUpdateSign) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFrontText)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text1)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text2)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text3)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Text4)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUpdateStructureBlock struct {
	Location  Position
	Action    int32
	Mode      int32
	Name      string
	OffsetX   int8
	OffsetY   int8
	OffsetZ   int8
	SizeX     int8
	SizeY     int8
	SizeZ     int8
	Mirror    int32
	Rotation  int32
	Metadata  string
	Integrity float32
	Seed      int32
	Flags     string
}

var PlayToServerPacketUpdateStructureBlockFlagsMap = map[uint8]string{0: "ignore_entities", 1: "show_air", 2: "show_bounding_box", 3: "strict"}

func (ret *PlayToServerPacketUpdateStructureBlock) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SizeZ)
	if err != nil {
		return
	}
	ret.Mirror, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Rotation, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Metadata, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Integrity)
	if err != nil {
		return
	}
	ret.Seed, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToServerPacketUpdateStructureBlockFlagsKey uint8
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUpdateStructureBlockFlagsKey)
	if err != nil {
		return
	}
	ret.Flags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsMap, PlayToServerPacketUpdateStructureBlockFlagsKey)
	if err != nil {
		return
	}
	return
}

var PlayToServerPacketUpdateStructureBlockFlagsReverseMap = map[string]uint8{"ignore_entities": 0, "show_air": 1, "show_bounding_box": 2, "strict": 3}

func (ret *PlayToServerPacketUpdateStructureBlock) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SizeZ)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mirror)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Rotation)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Metadata)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Integrity)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Seed)
	if err != nil {
		return
	}
	var vPlayToServerPacketUpdateStructureBlockFlags uint8
	vPlayToServerPacketUpdateStructureBlockFlags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsReverseMap, ret.Flags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, vPlayToServerPacketUpdateStructureBlockFlags)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUseEntity struct {
	Target   int32
	Mouse    int32
	X        any
	Y        any
	Z        any
	Hand     any
	Sneaking bool
}

func (ret *PlayToServerPacketUseEntity) Decode(r io.Reader) (err error) {
	ret.Target, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Mouse, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityX2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp)
		if err != nil {
			return
		}
		ret.X = PlayToServerPacketUseEntityX2Tmp
	default:
		var PlayToServerPacketUseEntityXTmp struct {
		}
		ret.X = PlayToServerPacketUseEntityXTmp
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityY2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp)
		if err != nil {
			return
		}
		ret.Y = PlayToServerPacketUseEntityY2Tmp
	default:
		var PlayToServerPacketUseEntityYTmp struct {
		}
		ret.Y = PlayToServerPacketUseEntityYTmp
	}
	switch ret.Mouse {
	case 2:
		var PlayToServerPacketUseEntityZ2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp)
		if err != nil {
			return
		}
		ret.Z = PlayToServerPacketUseEntityZ2Tmp
	default:
		var PlayToServerPacketUseEntityZTmp struct {
		}
		ret.Z = PlayToServerPacketUseEntityZTmp
	}
	switch ret.Mouse {
	case 0:
		var PlayToServerPacketUseEntityHand0Tmp int32
		PlayToServerPacketUseEntityHand0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Hand = PlayToServerPacketUseEntityHand0Tmp
	case 2:
		var PlayToServerPacketUseEntityHand2Tmp int32
		PlayToServerPacketUseEntityHand2Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Hand = PlayToServerPacketUseEntityHand2Tmp
	default:
		var PlayToServerPacketUseEntityHandTmp struct {
		}
		ret.Hand = PlayToServerPacketUseEntityHandTmp
	}
	err = binary.Read(r, binary.BigEndian, &ret.Sneaking)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Target)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mouse)
	if err != nil {
		return
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityX, ok := ret.X.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX)
		if err != nil {
			return
		}
	default:
		_, ok := ret.X.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityY, ok := ret.Y.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Y.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mouse {
	case 2:
		PlayToServerPacketUseEntityZ, ok := ret.Z.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Z.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mouse {
	case 0:
		PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
		if err != nil {
			return
		}
	case 2:
		PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Hand.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Sneaking)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketUseItem struct {
	Hand     int32
	Sequence int32
	Rotation Vec2f
}

func (ret *PlayToServerPacketUseItem) Decode(r io.Reader) (err error) {
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Sequence, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Rotation.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketUseItem) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Sequence)
	if err != nil {
		return
	}
	err = ret.Rotation.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketVehicleMove struct {
	X        float64
	Y        float64
	Z        float64
	Yaw      float32
	Pitch    float32
	OnGround bool
}

func (ret *PlayToServerPacketVehicleMove) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToServerPacketVehicleMove) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToServerPacketWindowClick struct {
	WindowId     ContainerID
	StateId      int32
	Slot         int16
	MouseButton  int8
	Mode         int32
	ChangedSlots []struct {
		Location int16
		Item     *HashedSlot
	}
	CursorItem *HashedSlot
}

func (ret *PlayToServerPacketWindowClick) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	ret.StateId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.MouseButton)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToServerPacketWindowClickChangedSlots int32
	lPlayToServerPacketWindowClickChangedSlots, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChangedSlots = []struct {
		Location int16
		Item     *HashedSlot
	}{}
	for range lPlayToServerPacketWindowClickChangedSlots {
		var PlayToServerPacketWindowClickChangedSlotsElement struct {
			Location int16
			Item     *HashedSlot
		}
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElement.Location)
		if err != nil {
			return
		}
		var PlayToServerPacketWindowClickChangedSlotsElementItemPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElementItemPresent)
		if err != nil {
			return
		}
		if PlayToServerPacketWindowClickChangedSlotsElementItemPresent {
			var PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue HashedSlot
			err = PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue.Decode(r)
			if err != nil {
				return
			}
			PlayToServerPacketWindowClickChangedSlotsElement.Item = &PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue
		}
		ret.ChangedSlots = append(ret.ChangedSlots, PlayToServerPacketWindowClickChangedSlotsElement)
	}
	var PlayToServerPacketWindowClickCursorItemPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickCursorItemPresent)
	if err != nil {
		return
	}
	if PlayToServerPacketWindowClickCursorItemPresent {
		var PlayToServerPacketWindowClickCursorItemPresentValue HashedSlot
		err = PlayToServerPacketWindowClickCursorItemPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.CursorItem = &PlayToServerPacketWindowClickCursorItemPresentValue
	}
	return
}
func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.StateId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.MouseButton)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Mode)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ChangedSlots)))
	if err != nil {
		return
	}
	for iPlayToServerPacketWindowClickChangedSlots := range len(ret.ChangedSlots) {
		err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Location)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil)
		if err != nil {
			return
		}
		if ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil {
			err = (*ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item).Encode(w)
			if err != nil {
				return
			}
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.CursorItem != nil)
	if err != nil {
		return
	}
	if ret.CursorItem != nil {
		err = (*ret.CursorItem).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ArmorTrimMaterial struct {
	AssetBase           string
	OverrideArmorAssets []struct {
		Key   string
		Value string
	}
	Description nbt.Anon
}

func (ret *ArmorTrimMaterial) Decode(r io.Reader) (err error) {
	ret.AssetBase, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lArmorTrimMaterialOverrideArmorAssets int32
	lArmorTrimMaterialOverrideArmorAssets, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.OverrideArmorAssets = []struct {
		Key   string
		Value string
	}{}
	for range lArmorTrimMaterialOverrideArmorAssets {
		var ArmorTrimMaterialOverrideArmorAssetsElement struct {
			Key   string
			Value string
		}
		ArmorTrimMaterialOverrideArmorAssetsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ArmorTrimMaterialOverrideArmorAssetsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.OverrideArmorAssets = append(ret.OverrideArmorAssets, ArmorTrimMaterialOverrideArmorAssetsElement)
	}
	err = ret.Description.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ArmorTrimMaterial) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.AssetBase)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.OverrideArmorAssets)))
	if err != nil {
		return
	}
	for iArmorTrimMaterialOverrideArmorAssets := range len(ret.OverrideArmorAssets) {
		err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Value)
		if err != nil {
			return
		}
	}
	err = ret.Description.Encode(w)
	if err != nil {
		return
	}
	return
}

type ArmorTrimPattern struct {
	AssetId     string
	Description nbt.Anon
	Decal       bool
}

func (ret *ArmorTrimPattern) Decode(r io.Reader) (err error) {
	ret.AssetId, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Description.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Decal)
	if err != nil {
		return
	}
	return
}
func (ret *ArmorTrimPattern) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.AssetId)
	if err != nil {
		return
	}
	err = ret.Description.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Decal)
	if err != nil {
		return
	}
	return
}

type BannerPattern struct {
	AssetId        string
	TranslationKey string
}

func (ret *BannerPattern) Decode(r io.Reader) (err error) {
	ret.AssetId, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.TranslationKey, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *BannerPattern) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.AssetId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.TranslationKey)
	if err != nil {
		return
	}
	return
}

type BannerPatternLayer struct {
	Pattern any
	ColorId int32
}

func (ret *BannerPatternLayer) Decode(r io.Reader) (err error) {
	var BannerPatternLayerPatternId int32
	BannerPatternLayerPatternId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	if BannerPatternLayerPatternId != 0 {
		ret.Pattern = BannerPatternLayerPatternId
	} else {
		var BannerPatternLayerPatternResult BannerPattern
		err = BannerPatternLayerPatternResult.Decode(r)
		if err != nil {
			return
		}
		ret.Pattern = BannerPatternLayerPatternResult
	}
	ret.ColorId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *BannerPatternLayer) Encode(w io.Writer) (err error) {
	switch BannerPatternLayerPatternKnownType := ret.Pattern.(type) {
	case int32:
		err = proto_base.EncodeVarInt(w, BannerPatternLayerPatternKnownType)
		if err != nil {
			return
		}
	case BannerPattern:
		err = proto_base.EncodeVarInt(w, 0)
		if err != nil {
			return
		}
		err = BannerPatternLayerPatternKnownType.Encode(w)
		if err != nil {
			return
		}
	default:
		err = proto_base.BadTypeError
	}
	err = proto_base.EncodeVarInt(w, ret.ColorId)
	if err != nil {
		return
	}
	return
}

type ByteArray struct {
	Val []byte
}

func (ret *ByteArray) Decode(r io.Reader) (err error) {
	var lByteArray int32
	lByteArray, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = io.ReadAll(io.LimitReader(r, int64(lByteArray)))
	if err != nil {
		return
	}
	return
}
func (ret *ByteArray) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.Val)
	if err != nil {
		return
	}
	return
}

type ContainerID struct {
	Val int32
}

func (ret *ContainerID) Decode(r io.Reader) (err error) {
	ret.Val, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *ContainerID) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Val)
	if err != nil {
		return
	}
	return
}

type DataComponentMatchers struct {
	ExactMatchers   ExactComponentMatcher
	PartialMatchers []int32
}

func (ret *DataComponentMatchers) Decode(r io.Reader) (err error) {
	err = ret.ExactMatchers.Decode(r)
	if err != nil {
		return
	}
	var lDataComponentMatchersPartialMatchers int32
	lDataComponentMatchersPartialMatchers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PartialMatchers = []int32{}
	for range lDataComponentMatchersPartialMatchers {
		var DataComponentMatchersPartialMatchersElement int32
		DataComponentMatchersPartialMatchersElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.PartialMatchers = append(ret.PartialMatchers, DataComponentMatchersPartialMatchersElement)
	}
	return
}
func (ret *DataComponentMatchers) Encode(w io.Writer) (err error) {
	err = ret.ExactMatchers.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.PartialMatchers)))
	if err != nil {
		return
	}
	for iDataComponentMatchersPartialMatchers := range len(ret.PartialMatchers) {
		err = proto_base.EncodeVarInt(w, ret.PartialMatchers[iDataComponentMatchersPartialMatchers])
		if err != nil {
			return
		}
	}
	return
}

type DebugStructureInfo struct {
	BoundingBoxMin Position
	BoundingBoxMax Position
	Pieces         []struct {
		BoundingBoxMin Position
		BoundingBoxMax Position
		IsStart        bool
	}
}

func (ret *DebugStructureInfo) Decode(r io.Reader) (err error) {
	err = ret.BoundingBoxMin.Decode(r)
	if err != nil {
		return
	}
	err = ret.BoundingBoxMax.Decode(r)
	if err != nil {
		return
	}
	var lDebugStructureInfoPieces int32
	lDebugStructureInfoPieces, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Pieces = []struct {
		BoundingBoxMin Position
		BoundingBoxMax Position
		IsStart        bool
	}{}
	for range lDebugStructureInfoPieces {
		var DebugStructureInfoPiecesElement struct {
			BoundingBoxMin Position
			BoundingBoxMax Position
			IsStart        bool
		}
		err = DebugStructureInfoPiecesElement.BoundingBoxMin.Decode(r)
		if err != nil {
			return
		}
		err = DebugStructureInfoPiecesElement.BoundingBoxMax.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &DebugStructureInfoPiecesElement.IsStart)
		if err != nil {
			return
		}
		ret.Pieces = append(ret.Pieces, DebugStructureInfoPiecesElement)
	}
	return
}
func (ret *DebugStructureInfo) Encode(w io.Writer) (err error) {
	err = ret.BoundingBoxMin.Encode(w)
	if err != nil {
		return
	}
	err = ret.BoundingBoxMax.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Pieces)))
	if err != nil {
		return
	}
	for iDebugStructureInfoPieces := range len(ret.Pieces) {
		err = ret.Pieces[iDebugStructureInfoPieces].BoundingBoxMin.Encode(w)
		if err != nil {
			return
		}
		err = ret.Pieces[iDebugStructureInfoPieces].BoundingBoxMax.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Pieces[iDebugStructureInfoPieces].IsStart)
		if err != nil {
			return
		}
	}
	return
}

type DebugSubscriptionDataType struct {
	Val string
}

var DebugSubscriptionDataTypeMap = map[int32]string{0: "DedicatedServerTickTime", 1: "Bees", 10: "VillageSections", 11: "Raids", 12: "Structures", 13: "GameEventListeners", 14: "NeighborUpdates", 15: "GameEvents", 2: "Brains", 3: "Breezes", 4: "GoalSelectors", 5: "EntityPaths", 6: "EntityBlockIntersections", 7: "BeeHives", 8: "Pois", 9: "RedstoneWireOrientations"}

func (ret *DebugSubscriptionDataType) Decode(r io.Reader) (err error) {
	var DebugSubscriptionDataTypeKey int32
	DebugSubscriptionDataTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = proto_base.ErroringIndex(DebugSubscriptionDataTypeMap, DebugSubscriptionDataTypeKey)
	if err != nil {
		return
	}
	return
}

var DebugSubscriptionDataTypeReverseMap = map[string]int32{"DedicatedServerTickTime": 0, "Bees": 1, "VillageSections": 10, "Raids": 11, "Structures": 12, "GameEventListeners": 13, "NeighborUpdates": 14, "GameEvents": 15, "Brains": 2, "Breezes": 3, "GoalSelectors": 4, "EntityPaths": 5, "EntityBlockIntersections": 6, "BeeHives": 7, "Pois": 8, "RedstoneWireOrientations": 9}

func (ret *DebugSubscriptionDataType) Encode(w io.Writer) (err error) {
	var vDebugSubscriptionDataType int32
	vDebugSubscriptionDataType, err = proto_base.ErroringIndex(DebugSubscriptionDataTypeReverseMap, ret.Val)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vDebugSubscriptionDataType)
	if err != nil {
		return
	}
	return
}

type DebugSubscriptionEvent struct {
	Type  DebugSubscriptionDataType
	Value any
}

func (ret *DebugSubscriptionEvent) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *DebugSubscriptionEvent) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type DebugSubscriptionUpdate struct {
	Type DebugSubscriptionDataType
	Anon any
}

func (ret *DebugSubscriptionUpdate) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *DebugSubscriptionUpdate) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type EntityMetadataPaintingVariant struct {
	Width   int32
	Height  int32
	AssetId string
	Title   *nbt.Anon
	Author  *nbt.Anon
}

func (ret *EntityMetadataPaintingVariant) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Width)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Height)
	if err != nil {
		return
	}
	ret.AssetId, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var EntityMetadataPaintingVariantTitlePresent bool
	err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantTitlePresent)
	if err != nil {
		return
	}
	if EntityMetadataPaintingVariantTitlePresent {
		var EntityMetadataPaintingVariantTitlePresentValue nbt.Anon
		err = EntityMetadataPaintingVariantTitlePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Title = &EntityMetadataPaintingVariantTitlePresentValue
	}
	var EntityMetadataPaintingVariantAuthorPresent bool
	err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantAuthorPresent)
	if err != nil {
		return
	}
	if EntityMetadataPaintingVariantAuthorPresent {
		var EntityMetadataPaintingVariantAuthorPresentValue nbt.Anon
		err = EntityMetadataPaintingVariantAuthorPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Author = &EntityMetadataPaintingVariantAuthorPresentValue
	}
	return
}
func (ret *EntityMetadataPaintingVariant) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Width)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Height)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.AssetId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Title != nil)
	if err != nil {
		return
	}
	if ret.Title != nil {
		err = (*ret.Title).Encode(w)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Author != nil)
	if err != nil {
		return
	}
	if ret.Author != nil {
		err = (*ret.Author).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ExactComponentMatcher struct {
	Val []SlotComponent
}

func (ret *ExactComponentMatcher) Decode(r io.Reader) (err error) {
	var lExactComponentMatcher int32
	lExactComponentMatcher, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []SlotComponent{}
	for range lExactComponentMatcher {
		var ExactComponentMatcherElement SlotComponent
		err = ExactComponentMatcherElement.Decode(r)
		if err != nil {
			return
		}
		ret.Val = append(ret.Val, ExactComponentMatcherElement)
	}
	return
}
func (ret *ExactComponentMatcher) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iExactComponentMatcher := range len(ret.Val) {
		err = ret.Val[iExactComponentMatcher].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type GameProfile struct {
	Uuid       uuid.UUID
	Name       string
	Properties []GameProfileProperty
}

func (ret *GameProfile) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lGameProfileProperties int32
	lGameProfileProperties, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Properties = []GameProfileProperty{}
	for range lGameProfileProperties {
		var GameProfilePropertiesElement GameProfileProperty
		err = GameProfilePropertiesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Properties = append(ret.Properties, GameProfilePropertiesElement)
	}
	return
}
func (ret *GameProfile) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iGameProfileProperties := range len(ret.Properties) {
		err = ret.Properties[iGameProfileProperties].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type GameProfileProperty struct {
	Name      string
	Value     string
	Signature *string
}

func (ret *GameProfileProperty) Decode(r io.Reader) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Value, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var GameProfilePropertySignaturePresent bool
	err = binary.Read(r, binary.BigEndian, &GameProfilePropertySignaturePresent)
	if err != nil {
		return
	}
	if GameProfilePropertySignaturePresent {
		var GameProfilePropertySignaturePresentValue string
		GameProfilePropertySignaturePresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Signature = &GameProfilePropertySignaturePresentValue
	}
	return
}
func (ret *GameProfileProperty) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Value)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Signature != nil)
	if err != nil {
		return
	}
	if ret.Signature != nil {
		err = proto_base.EncodeString(w, *ret.Signature)
		if err != nil {
			return
		}
	}
	return
}

type GlobalPos struct {
	DimensionName string
	Location      Position
}

func (ret *GlobalPos) Decode(r io.Reader) (err error) {
	ret.DimensionName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *GlobalPos) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.DimensionName)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	return
}

type HashedSlot struct {
	ItemId     int32
	ItemCount  int32
	Components []struct {
		Type SlotComponentType
		Hash int32
	}
	RemoveComponents []struct {
		Type SlotComponentType
	}
}

func (ret *HashedSlot) Decode(r io.Reader) (err error) {
	ret.ItemId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ItemCount, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lHashedSlotComponents int32
	lHashedSlotComponents, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Components = []struct {
		Type SlotComponentType
		Hash int32
	}{}
	for range lHashedSlotComponents {
		var HashedSlotComponentsElement struct {
			Type SlotComponentType
			Hash int32
		}
		err = HashedSlotComponentsElement.Type.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &HashedSlotComponentsElement.Hash)
		if err != nil {
			return
		}
		ret.Components = append(ret.Components, HashedSlotComponentsElement)
	}
	var lHashedSlotRemoveComponents int32
	lHashedSlotRemoveComponents, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.RemoveComponents = []struct {
		Type SlotComponentType
	}{}
	for range lHashedSlotRemoveComponents {
		var HashedSlotRemoveComponentsElement struct {
			Type SlotComponentType
		}
		err = HashedSlotRemoveComponentsElement.Type.Decode(r)
		if err != nil {
			return
		}
		ret.RemoveComponents = append(ret.RemoveComponents, HashedSlotRemoveComponentsElement)
	}
	return
}
func (ret *HashedSlot) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ItemId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ItemCount)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Components)))
	if err != nil {
		return
	}
	for iHashedSlotComponents := range len(ret.Components) {
		err = ret.Components[iHashedSlotComponents].Type.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Components[iHashedSlotComponents].Hash)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.RemoveComponents)))
	if err != nil {
		return
	}
	for iHashedSlotRemoveComponents := range len(ret.RemoveComponents) {
		err = ret.RemoveComponents[iHashedSlotRemoveComponents].Type.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type IDSet struct {
	Val any
}

func (ret *IDSet) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *IDSet) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type InstrumentData struct {
	SoundEvent  ItemSoundHolder
	UseDuration float32
	Range       float32
	Description nbt.Anon
}

func (ret *InstrumentData) Decode(r io.Reader) (err error) {
	err = ret.SoundEvent.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.UseDuration)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Range)
	if err != nil {
		return
	}
	err = ret.Description.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *InstrumentData) Encode(w io.Writer) (err error) {
	err = ret.SoundEvent.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.UseDuration)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Range)
	if err != nil {
		return
	}
	err = ret.Description.Encode(w)
	if err != nil {
		return
	}
	return
}

type ItemBlockPredicate struct {
	BlockSet   *any
	Properties *[]ItemBlockProperty
	Nbt        nbt.Anon
	Components DataComponentMatchers
}

func (ret *ItemBlockPredicate) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *ItemBlockPredicate) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type ItemBlockProperty struct {
	Name         string
	IsExactMatch bool
	Value        any
}

func (ret *ItemBlockProperty) Decode(r io.Reader) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsExactMatch)
	if err != nil {
		return
	}
	switch ret.IsExactMatch {
	case false:
		var ItemBlockPropertyValueFalseTmp struct {
			MinValue string
			MaxValue string
		}
		ItemBlockPropertyValueFalseTmp.MinValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ItemBlockPropertyValueFalseTmp.MaxValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Value = ItemBlockPropertyValueFalseTmp
	case true:
		var ItemBlockPropertyValueTrueTmp struct {
			ExactValue string
		}
		ItemBlockPropertyValueTrueTmp.ExactValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Value = ItemBlockPropertyValueTrueTmp
	}
	return
}
func (ret *ItemBlockProperty) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsExactMatch)
	if err != nil {
		return
	}
	switch ret.IsExactMatch {
	case false:
		ItemBlockPropertyValue, ok := ret.Value.(struct {
			MinValue string
			MaxValue string
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, ItemBlockPropertyValue.MinValue)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ItemBlockPropertyValue.MaxValue)
		if err != nil {
			return
		}
	case true:
		ItemBlockPropertyValue, ok := ret.Value.(struct {
			ExactValue string
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, ItemBlockPropertyValue.ExactValue)
		if err != nil {
			return
		}
	}
	return
}

type ItemBookPage struct {
	Content         string
	FilteredContent *string
}

func (ret *ItemBookPage) Decode(r io.Reader) (err error) {
	ret.Content, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ItemBookPageFilteredContentPresent bool
	err = binary.Read(r, binary.BigEndian, &ItemBookPageFilteredContentPresent)
	if err != nil {
		return
	}
	if ItemBookPageFilteredContentPresent {
		var ItemBookPageFilteredContentPresentValue string
		ItemBookPageFilteredContentPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.FilteredContent = &ItemBookPageFilteredContentPresentValue
	}
	return
}
func (ret *ItemBookPage) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Content)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FilteredContent != nil)
	if err != nil {
		return
	}
	if ret.FilteredContent != nil {
		err = proto_base.EncodeString(w, *ret.FilteredContent)
		if err != nil {
			return
		}
	}
	return
}

type ItemConsumeEffect struct {
	Type string
	Anon any
}

var ItemConsumeEffectTypeMap = map[int32]string{0: "apply_effects", 1: "remove_effects", 2: "clear_all_effects", 3: "teleport_randomly", 4: "play_sound"}

func (ret *ItemConsumeEffect) Decode(r io.Reader) (err error) {
	var ItemConsumeEffectTypeKey int32
	ItemConsumeEffectTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(ItemConsumeEffectTypeMap, ItemConsumeEffectTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "apply_effects":
		var ItemConsumeEffectAnonApplyEffectsTmp struct {
			Effects     []ItemPotionEffect
			Probability float32
		}
		var lItemConsumeEffectAnonEffects int32
		lItemConsumeEffectAnonEffects, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ItemConsumeEffectAnonApplyEffectsTmp.Effects = []ItemPotionEffect{}
		for range lItemConsumeEffectAnonEffects {
			var ItemConsumeEffectAnonEffectsElement ItemPotionEffect
			err = ItemConsumeEffectAnonEffectsElement.Decode(r)
			if err != nil {
				return
			}
			ItemConsumeEffectAnonApplyEffectsTmp.Effects = append(ItemConsumeEffectAnonApplyEffectsTmp.Effects, ItemConsumeEffectAnonEffectsElement)
		}
		err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonApplyEffectsTmp.Probability)
		if err != nil {
			return
		}
		ret.Anon = ItemConsumeEffectAnonApplyEffectsTmp
	case "clear_all_effects":
		var ItemConsumeEffectAnonClearAllEffectsTmp struct {
		}
		ret.Anon = ItemConsumeEffectAnonClearAllEffectsTmp
	case "play_sound":
		var ItemConsumeEffectAnonPlaySoundTmp struct {
			Sound ItemSoundHolder
		}
		err = ItemConsumeEffectAnonPlaySoundTmp.Sound.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = ItemConsumeEffectAnonPlaySoundTmp
	case "remove_effects":
		var ItemConsumeEffectAnonRemoveEffectsTmp struct {
			Effects IDSet
		}
		err = ItemConsumeEffectAnonRemoveEffectsTmp.Effects.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = ItemConsumeEffectAnonRemoveEffectsTmp
	case "teleport_randomly":
		var ItemConsumeEffectAnonTeleportRandomlyTmp struct {
			Diameter float32
		}
		err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonTeleportRandomlyTmp.Diameter)
		if err != nil {
			return
		}
		ret.Anon = ItemConsumeEffectAnonTeleportRandomlyTmp
	}
	return
}

var ItemConsumeEffectTypeReverseMap = map[string]int32{"apply_effects": 0, "remove_effects": 1, "clear_all_effects": 2, "teleport_randomly": 3, "play_sound": 4}

func (ret *ItemConsumeEffect) Encode(w io.Writer) (err error) {
	var vItemConsumeEffectType int32
	vItemConsumeEffectType, err = proto_base.ErroringIndex(ItemConsumeEffectTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vItemConsumeEffectType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "apply_effects":
		ItemConsumeEffectAnon, ok := ret.Anon.(struct {
			Effects     []ItemPotionEffect
			Probability float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ItemConsumeEffectAnon.Effects)))
		if err != nil {
			return
		}
		for iItemConsumeEffectAnonEffects := range len(ItemConsumeEffectAnon.Effects) {
			err = ItemConsumeEffectAnon.Effects[iItemConsumeEffectAnonEffects].Encode(w)
			if err != nil {
				return
			}
		}
		err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Probability)
		if err != nil {
			return
		}
	case "clear_all_effects":
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case "play_sound":
		ItemConsumeEffectAnon, ok := ret.Anon.(struct {
			Sound ItemSoundHolder
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ItemConsumeEffectAnon.Sound.Encode(w)
		if err != nil {
			return
		}
	case "remove_effects":
		ItemConsumeEffectAnon, ok := ret.Anon.(struct {
			Effects IDSet
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ItemConsumeEffectAnon.Effects.Encode(w)
		if err != nil {
			return
		}
	case "teleport_randomly":
		ItemConsumeEffectAnon, ok := ret.Anon.(struct {
			Diameter float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Diameter)
		if err != nil {
			return
		}
	}
	return
}

type ItemEffectDetail struct {
	Amplifier     int32
	Duration      int32
	Ambient       bool
	ShowParticles bool
	ShowIcon      bool
	HiddenEffect  *ItemEffectDetail
}

func (ret *ItemEffectDetail) Decode(r io.Reader) (err error) {
	ret.Amplifier, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Duration, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Ambient)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ShowParticles)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ShowIcon)
	if err != nil {
		return
	}
	var ItemEffectDetailHiddenEffectPresent bool
	err = binary.Read(r, binary.BigEndian, &ItemEffectDetailHiddenEffectPresent)
	if err != nil {
		return
	}
	if ItemEffectDetailHiddenEffectPresent {
		var ItemEffectDetailHiddenEffectPresentValue ItemEffectDetail
		err = ItemEffectDetailHiddenEffectPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.HiddenEffect = &ItemEffectDetailHiddenEffectPresentValue
	}
	return
}
func (ret *ItemEffectDetail) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Amplifier)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Duration)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Ambient)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ShowParticles)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ShowIcon)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HiddenEffect != nil)
	if err != nil {
		return
	}
	if ret.HiddenEffect != nil {
		err = (*ret.HiddenEffect).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type ItemFireworkExplosion struct {
	Shape      string
	Colors     []int32
	FadeColors []int32
	HasTrail   bool
	HasTwinkle bool
}

var ItemFireworkExplosionShapeMap = map[int32]string{0: "small_ball", 1: "large_ball", 2: "star", 3: "creeper", 4: "burst"}

func (ret *ItemFireworkExplosion) Decode(r io.Reader) (err error) {
	var ItemFireworkExplosionShapeKey int32
	ItemFireworkExplosionShapeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Shape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeMap, ItemFireworkExplosionShapeKey)
	if err != nil {
		return
	}
	var lItemFireworkExplosionColors int32
	lItemFireworkExplosionColors, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Colors = []int32{}
	for range lItemFireworkExplosionColors {
		var ItemFireworkExplosionColorsElement int32
		err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionColorsElement)
		if err != nil {
			return
		}
		ret.Colors = append(ret.Colors, ItemFireworkExplosionColorsElement)
	}
	var lItemFireworkExplosionFadeColors int32
	lItemFireworkExplosionFadeColors, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.FadeColors = []int32{}
	for range lItemFireworkExplosionFadeColors {
		var ItemFireworkExplosionFadeColorsElement int32
		err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionFadeColorsElement)
		if err != nil {
			return
		}
		ret.FadeColors = append(ret.FadeColors, ItemFireworkExplosionFadeColorsElement)
	}
	err = binary.Read(r, binary.BigEndian, &ret.HasTrail)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HasTwinkle)
	if err != nil {
		return
	}
	return
}

var ItemFireworkExplosionShapeReverseMap = map[string]int32{"small_ball": 0, "large_ball": 1, "star": 2, "creeper": 3, "burst": 4}

func (ret *ItemFireworkExplosion) Encode(w io.Writer) (err error) {
	var vItemFireworkExplosionShape int32
	vItemFireworkExplosionShape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeReverseMap, ret.Shape)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vItemFireworkExplosionShape)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Colors)))
	if err != nil {
		return
	}
	for iItemFireworkExplosionColors := range len(ret.Colors) {
		err = binary.Write(w, binary.BigEndian, ret.Colors[iItemFireworkExplosionColors])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.FadeColors)))
	if err != nil {
		return
	}
	for iItemFireworkExplosionFadeColors := range len(ret.FadeColors) {
		err = binary.Write(w, binary.BigEndian, ret.FadeColors[iItemFireworkExplosionFadeColors])
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.HasTrail)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HasTwinkle)
	if err != nil {
		return
	}
	return
}

type ItemPotionEffect struct {
	Id      int32
	Details ItemEffectDetail
}

func (ret *ItemPotionEffect) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Details.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ItemPotionEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Id)
	if err != nil {
		return
	}
	err = ret.Details.Encode(w)
	if err != nil {
		return
	}
	return
}

type ItemSoundEvent struct {
	SoundName  string
	FixedRange *float32
}

func (ret *ItemSoundEvent) Decode(r io.Reader) (err error) {
	ret.SoundName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var ItemSoundEventFixedRangePresent bool
	err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresent)
	if err != nil {
		return
	}
	if ItemSoundEventFixedRangePresent {
		var ItemSoundEventFixedRangePresentValue float32
		err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresentValue)
		if err != nil {
			return
		}
		ret.FixedRange = &ItemSoundEventFixedRangePresentValue
	}
	return
}
func (ret *ItemSoundEvent) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.SoundName)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FixedRange != nil)
	if err != nil {
		return
	}
	if ret.FixedRange != nil {
		err = binary.Write(w, binary.BigEndian, *ret.FixedRange)
		if err != nil {
			return
		}
	}
	return
}

type ItemSoundHolder struct {
	Val any
}

func (ret *ItemSoundHolder) Decode(r io.Reader) (err error) {
	var ItemSoundHolderId int32
	ItemSoundHolderId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	if ItemSoundHolderId != 0 {
		ret.Val = ItemSoundHolderId
	} else {
		var ItemSoundHolderResult ItemSoundEvent
		err = ItemSoundHolderResult.Decode(r)
		if err != nil {
			return
		}
		ret.Val = ItemSoundHolderResult
	}
	return
}
func (ret *ItemSoundHolder) Encode(w io.Writer) (err error) {
	switch ItemSoundHolderKnownType := ret.Val.(type) {
	case int32:
		err = proto_base.EncodeVarInt(w, ItemSoundHolderKnownType)
		if err != nil {
			return
		}
	case ItemSoundEvent:
		err = proto_base.EncodeVarInt(w, 0)
		if err != nil {
			return
		}
		err = ItemSoundHolderKnownType.Encode(w)
		if err != nil {
			return
		}
	default:
		err = proto_base.BadTypeError
	}
	return
}

type ItemWrittenBookPage struct {
	Content         nbt.Anon
	FilteredContent nbt.Anon
}

func (ret *ItemWrittenBookPage) Decode(r io.Reader) (err error) {
	err = ret.Content.Decode(r)
	if err != nil {
		return
	}
	err = ret.FilteredContent.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ItemWrittenBookPage) Encode(w io.Writer) (err error) {
	err = ret.Content.Encode(w)
	if err != nil {
		return
	}
	err = ret.FilteredContent.Encode(w)
	if err != nil {
		return
	}
	return
}

type JukeboxSongData struct {
	SoundEvent       ItemSoundHolder
	Description      nbt.Anon
	LengthInSeconds  float32
	ComparatorOutput int32
}

func (ret *JukeboxSongData) Decode(r io.Reader) (err error) {
	err = ret.SoundEvent.Decode(r)
	if err != nil {
		return
	}
	err = ret.Description.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.LengthInSeconds)
	if err != nil {
		return
	}
	ret.ComparatorOutput, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *JukeboxSongData) Encode(w io.Writer) (err error) {
	err = ret.SoundEvent.Encode(w)
	if err != nil {
		return
	}
	err = ret.Description.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.LengthInSeconds)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ComparatorOutput)
	if err != nil {
		return
	}
	return
}

type Node struct {
	Position       Vec3i32
	WalkedDistance float32
	CostMalus      float32
	Closed         bool
	Type           string
	F              float32
}

var NodeTypeMap = map[int32]string{0: "blocked", 1: "open", 10: "water_border", 11: "rail", 12: "unpassable_rail", 13: "danger_fire", 14: "damage_fire", 15: "danger_other", 16: "damage_other", 17: "door_open", 18: "door_wood_closed", 19: "door_iron_closed", 2: "walkable", 20: "breach", 21: "leaves", 22: "sticky_honey", 23: "cocoa", 24: "damage_cautious", 25: "danger_trapdoor", 3: "walkable_door", 4: "trapdoor", 5: "powder_snow", 6: "danger_powder_snow", 7: "fence", 8: "lava", 9: "water"}

func (ret *Node) Decode(r io.Reader) (err error) {
	err = ret.Position.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.WalkedDistance)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CostMalus)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Closed)
	if err != nil {
		return
	}
	var NodeTypeKey int32
	NodeTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(NodeTypeMap, NodeTypeKey)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.F)
	if err != nil {
		return
	}
	return
}

var NodeTypeReverseMap = map[string]int32{"blocked": 0, "open": 1, "water_border": 10, "rail": 11, "unpassable_rail": 12, "danger_fire": 13, "damage_fire": 14, "danger_other": 15, "damage_other": 16, "door_open": 17, "door_wood_closed": 18, "door_iron_closed": 19, "walkable": 2, "breach": 20, "leaves": 21, "sticky_honey": 22, "cocoa": 23, "damage_cautious": 24, "danger_trapdoor": 25, "walkable_door": 3, "trapdoor": 4, "powder_snow": 5, "danger_powder_snow": 6, "fence": 7, "lava": 8, "water": 9}

func (ret *Node) Encode(w io.Writer) (err error) {
	err = ret.Position.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.WalkedDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CostMalus)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Closed)
	if err != nil {
		return
	}
	var vNodeType int32
	vNodeType, err = proto_base.ErroringIndex(NodeTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vNodeType)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.F)
	if err != nil {
		return
	}
	return
}

type PartialResolvableProfile struct {
	Name       *string
	Uuid       *uuid.UUID
	Properties []GameProfileProperty
}

func (ret *PartialResolvableProfile) Decode(r io.Reader) (err error) {
	var PartialResolvableProfileNamePresent bool
	err = binary.Read(r, binary.BigEndian, &PartialResolvableProfileNamePresent)
	if err != nil {
		return
	}
	if PartialResolvableProfileNamePresent {
		var PartialResolvableProfileNamePresentValue string
		PartialResolvableProfileNamePresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Name = &PartialResolvableProfileNamePresentValue
	}
	var PartialResolvableProfileUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &PartialResolvableProfileUuidPresent)
	if err != nil {
		return
	}
	if PartialResolvableProfileUuidPresent {
		var PartialResolvableProfileUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, PartialResolvableProfileUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &PartialResolvableProfileUuidPresentValue
	}
	var lPartialResolvableProfileProperties int32
	lPartialResolvableProfileProperties, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Properties = []GameProfileProperty{}
	for range lPartialResolvableProfileProperties {
		var PartialResolvableProfilePropertiesElement GameProfileProperty
		err = PartialResolvableProfilePropertiesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Properties = append(ret.Properties, PartialResolvableProfilePropertiesElement)
	}
	return
}
func (ret *PartialResolvableProfile) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Name != nil)
	if err != nil {
		return
	}
	if ret.Name != nil {
		err = proto_base.EncodeString(w, *ret.Name)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iPartialResolvableProfileProperties := range len(ret.Properties) {
		err = ret.Properties[iPartialResolvableProfileProperties].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type Particle struct {
	Type string
	Data any
}

var ParticleTypeMap = map[int32]string{0: "angry_villager", 1: "block", 10: "falling_lava", 100: "wax_off", 101: "electric_spark", 102: "scrape", 103: "shriek", 104: "egg_crack", 105: "dust_plume", 106: "trial_spawner_detected_player", 107: "trial_spawner_detected_player_ominous", 108: "vault_connection", 109: "dust_pillar", 11: "landing_lava", 110: "ominous_spawning", 111: "raid_omen", 112: "trial_omen", 113: "block_crumble", 114: "firefly", 12: "dripping_water", 13: "falling_water", 14: "dust", 15: "dust_color_transition", 16: "effect", 17: "elder_guardian", 18: "enchanted_hit", 19: "enchant", 2: "block_marker", 20: "end_rod", 21: "entity_effect", 22: "explosion_emitter", 23: "explosion", 24: "gust", 25: "small_gust", 26: "gust_emitter_large", 27: "gust_emitter_small", 28: "sonic_boom", 29: "falling_dust", 3: "bubble", 30: "firework", 31: "fishing", 32: "flame", 33: "infested", 34: "cherry_leaves", 35: "pale_oak_leaves", 36: "tinted_leaves", 37: "sculk_soul", 38: "sculk_charge", 39: "sculk_charge_pop", 4: "cloud", 40: "soul_fire_flame", 41: "soul", 42: "flash", 43: "happy_villager", 44: "composter", 45: "heart", 46: "instant_effect", 47: "item", 48: "vibration", 49: "trail", 5: "copper_fire_flame", 50: "item_slime", 51: "item_cobweb", 52: "item_snowball", 53: "large_smoke", 54: "lava", 55: "mycelium", 56: "note", 57: "poof", 58: "portal", 59: "rain", 6: "crit", 60: "smoke", 61: "white_smoke", 62: "sneeze", 63: "spit", 64: "squid_ink", 65: "sweep_attack", 66: "totem_of_undying", 67: "underwater", 68: "splash", 69: "witch", 7: "damage_indicator", 70: "bubble_pop", 71: "current_down", 72: "bubble_column_up", 73: "nautilus", 74: "dolphin", 75: "campfire_cosy_smoke", 76: "campfire_signal_smoke", 77: "dripping_honey", 78: "falling_honey", 79: "landing_honey", 8: "dragon_breath", 80: "falling_nectar", 81: "falling_spore_blossom", 82: "ash", 83: "crimson_spore", 84: "warped_spore", 85: "spore_blossom_air", 86: "dripping_obsidian_tear", 87: "falling_obsidian_tear", 88: "landing_obsidian_tear", 89: "reverse_portal", 9: "dripping_lava", 90: "white_ash", 91: "small_flame", 92: "snowflake", 93: "dripping_dripstone_lava", 94: "falling_dripstone_lava", 95: "dripping_dripstone_water", 96: "falling_dripstone_water", 97: "glow_squid_ink", 98: "glow", 99: "wax_on"}
var ParticleDataPositionTypeMap = map[int32]string{0: "block", 1: "entity"}

func (ret *Particle) Decode(r io.Reader) (err error) {
	var ParticleTypeKey int32
	ParticleTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(ParticleTypeMap, ParticleTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "block":
		var ParticleDataBlockTmp int32
		ParticleDataBlockTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataBlockTmp
	case "block_crumble":
		var ParticleDataBlockCrumbleTmp int32
		ParticleDataBlockCrumbleTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataBlockCrumbleTmp
	case "block_marker":
		var ParticleDataBlockMarkerTmp int32
		ParticleDataBlockMarkerTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataBlockMarkerTmp
	case "dragon_breath":
		var ParticleDataDragonBreathTmp struct {
			Power float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDragonBreathTmp.Power)
		if err != nil {
			return
		}
		ret.Data = ParticleDataDragonBreathTmp
	case "dust":
		var ParticleDataDustTmp struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Red)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Green)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Blue)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Scale)
		if err != nil {
			return
		}
		ret.Data = ParticleDataDustTmp
	case "dust_color_transition":
		var ParticleDataDustColorTransitionTmp struct {
			FromRed   float32
			FromGreen float32
			FromBlue  float32
			Scale     float32
			ToRed     float32
			ToGreen   float32
			ToBlue    float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromRed)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromGreen)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromBlue)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.Scale)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToRed)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToGreen)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToBlue)
		if err != nil {
			return
		}
		ret.Data = ParticleDataDustColorTransitionTmp
	case "dust_pillar":
		var ParticleDataDustPillarTmp int32
		ParticleDataDustPillarTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataDustPillarTmp
	case "effect":
		var ParticleDataEffectTmp struct {
			Color int32
			Power float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataEffectTmp.Color)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataEffectTmp.Power)
		if err != nil {
			return
		}
		ret.Data = ParticleDataEffectTmp
	case "entity_effect":
		var ParticleDataEntityEffectTmp int32
		err = binary.Read(r, binary.BigEndian, &ParticleDataEntityEffectTmp)
		if err != nil {
			return
		}
		ret.Data = ParticleDataEntityEffectTmp
	case "falling_dust":
		var ParticleDataFallingDustTmp int32
		ParticleDataFallingDustTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataFallingDustTmp
	case "firefly":
		var ParticleDataFireflyTmp struct {
		}
		ret.Data = ParticleDataFireflyTmp
	case "flash":
		var ParticleDataFlashTmp int32
		err = binary.Read(r, binary.BigEndian, &ParticleDataFlashTmp)
		if err != nil {
			return
		}
		ret.Data = ParticleDataFlashTmp
	case "instant_effect":
		var ParticleDataInstantEffectTmp struct {
			Color int32
			Power float32
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataInstantEffectTmp.Color)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataInstantEffectTmp.Power)
		if err != nil {
			return
		}
		ret.Data = ParticleDataInstantEffectTmp
	case "item":
		var ParticleDataItemTmp Slot
		err = ParticleDataItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataItemTmp
	case "sculk_charge":
		var ParticleDataSculkChargeTmp float32
		err = binary.Read(r, binary.BigEndian, &ParticleDataSculkChargeTmp)
		if err != nil {
			return
		}
		ret.Data = ParticleDataSculkChargeTmp
	case "shriek":
		var ParticleDataShriekTmp int32
		ParticleDataShriekTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataShriekTmp
	case "tinted_leaves":
		var ParticleDataTintedLeavesTmp int32
		err = binary.Read(r, binary.BigEndian, &ParticleDataTintedLeavesTmp)
		if err != nil {
			return
		}
		ret.Data = ParticleDataTintedLeavesTmp
	case "trail":
		var ParticleDataTrailTmp struct {
			Target Vec3f64
			Color  uint8
		}
		err = ParticleDataTrailTmp.Target.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ParticleDataTrailTmp.Color)
		if err != nil {
			return
		}
		ret.Data = ParticleDataTrailTmp
	case "vibration":
		var ParticleDataVibrationTmp struct {
			PositionType string
			Position     any
			Ticks        int32
		}
		var ParticleDataPositionTypeKey int32
		ParticleDataPositionTypeKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ParticleDataVibrationTmp.PositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeMap, ParticleDataPositionTypeKey)
		if err != nil {
			return
		}
		switch ParticleDataVibrationTmp.PositionType {
		case "block":
			var ParticleDataPositionBlockTmp Position
			err = ParticleDataPositionBlockTmp.Decode(r)
			if err != nil {
				return
			}
			ParticleDataVibrationTmp.Position = ParticleDataPositionBlockTmp
		case "entity":
			var ParticleDataPositionEntityTmp struct {
				EntityId        int32
				EntityEyeHeight float32
			}
			ParticleDataPositionEntityTmp.EntityId, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &ParticleDataPositionEntityTmp.EntityEyeHeight)
			if err != nil {
				return
			}
			ParticleDataVibrationTmp.Position = ParticleDataPositionEntityTmp
		}
		ParticleDataVibrationTmp.Ticks, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = ParticleDataVibrationTmp
	}
	return
}

var ParticleTypeReverseMap = map[string]int32{"angry_villager": 0, "block": 1, "falling_lava": 10, "wax_off": 100, "electric_spark": 101, "scrape": 102, "shriek": 103, "egg_crack": 104, "dust_plume": 105, "trial_spawner_detected_player": 106, "trial_spawner_detected_player_ominous": 107, "vault_connection": 108, "dust_pillar": 109, "landing_lava": 11, "ominous_spawning": 110, "raid_omen": 111, "trial_omen": 112, "block_crumble": 113, "firefly": 114, "dripping_water": 12, "falling_water": 13, "dust": 14, "dust_color_transition": 15, "effect": 16, "elder_guardian": 17, "enchanted_hit": 18, "enchant": 19, "block_marker": 2, "end_rod": 20, "entity_effect": 21, "explosion_emitter": 22, "explosion": 23, "gust": 24, "small_gust": 25, "gust_emitter_large": 26, "gust_emitter_small": 27, "sonic_boom": 28, "falling_dust": 29, "bubble": 3, "firework": 30, "fishing": 31, "flame": 32, "infested": 33, "cherry_leaves": 34, "pale_oak_leaves": 35, "tinted_leaves": 36, "sculk_soul": 37, "sculk_charge": 38, "sculk_charge_pop": 39, "cloud": 4, "soul_fire_flame": 40, "soul": 41, "flash": 42, "happy_villager": 43, "composter": 44, "heart": 45, "instant_effect": 46, "item": 47, "vibration": 48, "trail": 49, "copper_fire_flame": 5, "item_slime": 50, "item_cobweb": 51, "item_snowball": 52, "large_smoke": 53, "lava": 54, "mycelium": 55, "note": 56, "poof": 57, "portal": 58, "rain": 59, "crit": 6, "smoke": 60, "white_smoke": 61, "sneeze": 62, "spit": 63, "squid_ink": 64, "sweep_attack": 65, "totem_of_undying": 66, "underwater": 67, "splash": 68, "witch": 69, "damage_indicator": 7, "bubble_pop": 70, "current_down": 71, "bubble_column_up": 72, "nautilus": 73, "dolphin": 74, "campfire_cosy_smoke": 75, "campfire_signal_smoke": 76, "dripping_honey": 77, "falling_honey": 78, "landing_honey": 79, "dragon_breath": 8, "falling_nectar": 80, "falling_spore_blossom": 81, "ash": 82, "crimson_spore": 83, "warped_spore": 84, "spore_blossom_air": 85, "dripping_obsidian_tear": 86, "falling_obsidian_tear": 87, "landing_obsidian_tear": 88, "reverse_portal": 89, "dripping_lava": 9, "white_ash": 90, "small_flame": 91, "snowflake": 92, "dripping_dripstone_lava": 93, "falling_dripstone_lava": 94, "dripping_dripstone_water": 95, "falling_dripstone_water": 96, "glow_squid_ink": 97, "glow": 98, "wax_on": 99}
var ParticleDataPositionTypeReverseMap = map[string]int32{"block": 0, "entity": 1}

func (ret *Particle) Encode(w io.Writer) (err error) {
	var vParticleType int32
	vParticleType, err = proto_base.ErroringIndex(ParticleTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vParticleType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "block":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "block_crumble":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "block_marker":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "dragon_breath":
		ParticleData, ok := ret.Data.(struct {
			Power float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Power)
		if err != nil {
			return
		}
	case "dust":
		ParticleData, ok := ret.Data.(struct {
			Red   float32
			Green float32
			Blue  float32
			Scale float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Red)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Green)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Blue)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
		if err != nil {
			return
		}
	case "dust_color_transition":
		ParticleData, ok := ret.Data.(struct {
			FromRed   float32
			FromGreen float32
			FromBlue  float32
			Scale     float32
			ToRed     float32
			ToGreen   float32
			ToBlue    float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.FromRed)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.FromGreen)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.FromBlue)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Scale)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.ToRed)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.ToGreen)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.ToBlue)
		if err != nil {
			return
		}
	case "dust_pillar":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "effect":
		ParticleData, ok := ret.Data.(struct {
			Color int32
			Power float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Color)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Power)
		if err != nil {
			return
		}
	case "entity_effect":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData)
		if err != nil {
			return
		}
	case "falling_dust":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "firefly":
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case "flash":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData)
		if err != nil {
			return
		}
	case "instant_effect":
		ParticleData, ok := ret.Data.(struct {
			Color int32
			Power float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Color)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Power)
		if err != nil {
			return
		}
	case "item":
		ParticleData, ok := ret.Data.(Slot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ParticleData.Encode(w)
		if err != nil {
			return
		}
	case "sculk_charge":
		ParticleData, ok := ret.Data.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData)
		if err != nil {
			return
		}
	case "shriek":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ParticleData)
		if err != nil {
			return
		}
	case "tinted_leaves":
		ParticleData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData)
		if err != nil {
			return
		}
	case "trail":
		ParticleData, ok := ret.Data.(struct {
			Target Vec3f64
			Color  uint8
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ParticleData.Target.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ParticleData.Color)
		if err != nil {
			return
		}
	case "vibration":
		ParticleData, ok := ret.Data.(struct {
			PositionType string
			Position     any
			Ticks        int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		var vParticleDataPositionType int32
		vParticleDataPositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeReverseMap, ParticleData.PositionType)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vParticleDataPositionType)
		if err != nil {
			return
		}
		switch ParticleData.PositionType {
		case "block":
			ParticleDataPosition, ok := ParticleData.Position.(Position)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = ParticleDataPosition.Encode(w)
			if err != nil {
				return
			}
		case "entity":
			ParticleDataPosition, ok := ParticleData.Position.(struct {
				EntityId        int32
				EntityEyeHeight float32
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, ParticleDataPosition.EntityId)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ParticleDataPosition.EntityEyeHeight)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeVarInt(w, ParticleData.Ticks)
		if err != nil {
			return
		}
	}
	return
}

type Path struct {
	Reached       bool
	NextNodeIndex int32
	Target        Position
	Nodes         []Node
	DebugData     PathDebugData
}

func (ret *Path) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Reached)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.NextNodeIndex)
	if err != nil {
		return
	}
	err = ret.Target.Decode(r)
	if err != nil {
		return
	}
	var lPathNodes int32
	lPathNodes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Nodes = []Node{}
	for range lPathNodes {
		var PathNodesElement Node
		err = PathNodesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Nodes = append(ret.Nodes, PathNodesElement)
	}
	err = ret.DebugData.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *Path) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Reached)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.NextNodeIndex)
	if err != nil {
		return
	}
	err = ret.Target.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes)))
	if err != nil {
		return
	}
	for iPathNodes := range len(ret.Nodes) {
		err = ret.Nodes[iPathNodes].Encode(w)
		if err != nil {
			return
		}
	}
	err = ret.DebugData.Encode(w)
	if err != nil {
		return
	}
	return
}

type PathDebugData struct {
	OpenSet     []Node
	ClosedSet   []Node
	TargetNodes []Node
}

func (ret *PathDebugData) Decode(r io.Reader) (err error) {
	var lPathDebugDataOpenSet int32
	lPathDebugDataOpenSet, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.OpenSet = []Node{}
	for range lPathDebugDataOpenSet {
		var PathDebugDataOpenSetElement Node
		err = PathDebugDataOpenSetElement.Decode(r)
		if err != nil {
			return
		}
		ret.OpenSet = append(ret.OpenSet, PathDebugDataOpenSetElement)
	}
	var lPathDebugDataClosedSet int32
	lPathDebugDataClosedSet, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ClosedSet = []Node{}
	for range lPathDebugDataClosedSet {
		var PathDebugDataClosedSetElement Node
		err = PathDebugDataClosedSetElement.Decode(r)
		if err != nil {
			return
		}
		ret.ClosedSet = append(ret.ClosedSet, PathDebugDataClosedSetElement)
	}
	var lPathDebugDataTargetNodes int32
	lPathDebugDataTargetNodes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.TargetNodes = []Node{}
	for range lPathDebugDataTargetNodes {
		var PathDebugDataTargetNodesElement Node
		err = PathDebugDataTargetNodesElement.Decode(r)
		if err != nil {
			return
		}
		ret.TargetNodes = append(ret.TargetNodes, PathDebugDataTargetNodesElement)
	}
	return
}
func (ret *PathDebugData) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.OpenSet)))
	if err != nil {
		return
	}
	for iPathDebugDataOpenSet := range len(ret.OpenSet) {
		err = ret.OpenSet[iPathDebugDataOpenSet].Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ClosedSet)))
	if err != nil {
		return
	}
	for iPathDebugDataClosedSet := range len(ret.ClosedSet) {
		err = ret.ClosedSet[iPathDebugDataClosedSet].Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.TargetNodes)))
	if err != nil {
		return
	}
	for iPathDebugDataTargetNodes := range len(ret.TargetNodes) {
		err = ret.TargetNodes[iPathDebugDataTargetNodes].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayerSkinPatch struct {
	Body   *string
	Cape   *string
	Elytra *string
	Model  *string
}

var PlayerSkinPatchModelMap = map[int32]string{0: "wide", 1: "slim"}

func (ret *PlayerSkinPatch) Decode(r io.Reader) (err error) {
	var PlayerSkinPatchBodyPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchBodyPresent)
	if err != nil {
		return
	}
	if PlayerSkinPatchBodyPresent {
		var PlayerSkinPatchBodyPresentValue string
		PlayerSkinPatchBodyPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Body = &PlayerSkinPatchBodyPresentValue
	}
	var PlayerSkinPatchCapePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchCapePresent)
	if err != nil {
		return
	}
	if PlayerSkinPatchCapePresent {
		var PlayerSkinPatchCapePresentValue string
		PlayerSkinPatchCapePresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Cape = &PlayerSkinPatchCapePresentValue
	}
	var PlayerSkinPatchElytraPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchElytraPresent)
	if err != nil {
		return
	}
	if PlayerSkinPatchElytraPresent {
		var PlayerSkinPatchElytraPresentValue string
		PlayerSkinPatchElytraPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Elytra = &PlayerSkinPatchElytraPresentValue
	}
	var PlayerSkinPatchModelPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayerSkinPatchModelPresent)
	if err != nil {
		return
	}
	if PlayerSkinPatchModelPresent {
		var PlayerSkinPatchModelPresentValue string
		var PlayerSkinPatchModelKey int32
		PlayerSkinPatchModelKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayerSkinPatchModelPresentValue, err = proto_base.ErroringIndex(PlayerSkinPatchModelMap, PlayerSkinPatchModelKey)
		if err != nil {
			return
		}
		ret.Model = &PlayerSkinPatchModelPresentValue
	}
	return
}

var PlayerSkinPatchModelReverseMap = map[string]int32{"wide": 0, "slim": 1}

func (ret *PlayerSkinPatch) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Body != nil)
	if err != nil {
		return
	}
	if ret.Body != nil {
		err = proto_base.EncodeString(w, *ret.Body)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Cape != nil)
	if err != nil {
		return
	}
	if ret.Cape != nil {
		err = proto_base.EncodeString(w, *ret.Cape)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Elytra != nil)
	if err != nil {
		return
	}
	if ret.Elytra != nil {
		err = proto_base.EncodeString(w, *ret.Elytra)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Model != nil)
	if err != nil {
		return
	}
	if ret.Model != nil {
		var vPlayerSkinPatchModel int32
		vPlayerSkinPatchModel, err = proto_base.ErroringIndex(PlayerSkinPatchModelReverseMap, *ret.Model)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayerSkinPatchModel)
		if err != nil {
			return
		}
	}
	return
}

type ResolvableProfile struct {
	Type      string
	Anon      any
	SkinPatch PlayerSkinPatch
}

var ResolvableProfileTypeMap = map[int32]string{0: "partial", 1: "complete"}

func (ret *ResolvableProfile) Decode(r io.Reader) (err error) {
	var ResolvableProfileTypeKey int32
	ResolvableProfileTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(ResolvableProfileTypeMap, ResolvableProfileTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "complete":
		var ResolvableProfileAnonCompleteTmp GameProfile
		err = ResolvableProfileAnonCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = ResolvableProfileAnonCompleteTmp
	case "partial":
		var ResolvableProfileAnonPartialTmp PartialResolvableProfile
		err = ResolvableProfileAnonPartialTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = ResolvableProfileAnonPartialTmp
	}
	err = ret.SkinPatch.Decode(r)
	if err != nil {
		return
	}
	return
}

var ResolvableProfileTypeReverseMap = map[string]int32{"partial": 0, "complete": 1}

func (ret *ResolvableProfile) Encode(w io.Writer) (err error) {
	var vResolvableProfileType int32
	vResolvableProfileType, err = proto_base.ErroringIndex(ResolvableProfileTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vResolvableProfileType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "complete":
		ResolvableProfileAnon, ok := ret.Anon.(GameProfile)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ResolvableProfileAnon.Encode(w)
		if err != nil {
			return
		}
	case "partial":
		ResolvableProfileAnon, ok := ret.Anon.(PartialResolvableProfile)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = ResolvableProfileAnon.Encode(w)
		if err != nil {
			return
		}
	}
	err = ret.SkinPatch.Encode(w)
	if err != nil {
		return
	}
	return
}

type RespawnData struct {
	GlobalPos GlobalPos
	Yaw       float32
	Pitch     float32
}

func (ret *RespawnData) Decode(r io.Reader) (err error) {
	err = ret.GlobalPos.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	return
}
func (ret *RespawnData) Encode(w io.Writer) (err error) {
	err = ret.GlobalPos.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	return
}

type ServerLinkType struct {
	Val string
}

var ServerLinkTypeMap = map[int32]string{0: "bug_report", 1: "community_guidelines", 2: "support", 3: "status", 4: "feedback", 5: "community", 6: "website", 7: "forums", 8: "news", 9: "announcements"}

func (ret *ServerLinkType) Decode(r io.Reader) (err error) {
	var ServerLinkTypeKey int32
	ServerLinkTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = proto_base.ErroringIndex(ServerLinkTypeMap, ServerLinkTypeKey)
	if err != nil {
		return
	}
	return
}

var ServerLinkTypeReverseMap = map[string]int32{"bug_report": 0, "community_guidelines": 1, "support": 2, "status": 3, "feedback": 4, "community": 5, "website": 6, "forums": 7, "news": 8, "announcements": 9}

func (ret *ServerLinkType) Encode(w io.Writer) (err error) {
	var vServerLinkType int32
	vServerLinkType, err = proto_base.ErroringIndex(ServerLinkTypeReverseMap, ret.Val)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vServerLinkType)
	if err != nil {
		return
	}
	return
}

type Slot struct {
	ItemCount int32
	Anon      any
}

func (ret *Slot) Decode(r io.Reader) (err error) {
	ret.ItemCount, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.ItemCount {
	case 0:
		var SlotAnon0Tmp struct {
		}
		ret.Anon = SlotAnon0Tmp
	default:
		var SlotAnonTmp struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}
		SlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		SlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		SlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		var lSlotAnonComponents int32
		lSlotAnonComponents = SlotAnonTmp.AddedComponentCount
		SlotAnonTmp.Components = []SlotComponent{}
		for range lSlotAnonComponents {
			var SlotAnonComponentsElement SlotComponent
			err = SlotAnonComponentsElement.Decode(r)
			if err != nil {
				return
			}
			SlotAnonTmp.Components = append(SlotAnonTmp.Components, SlotAnonComponentsElement)
		}
		var lSlotAnonRemoveComponents int32
		lSlotAnonRemoveComponents = SlotAnonTmp.RemovedComponentCount
		SlotAnonTmp.RemoveComponents = []struct {
			Type SlotComponentType
		}{}
		for range lSlotAnonRemoveComponents {
			var SlotAnonRemoveComponentsElement struct {
				Type SlotComponentType
			}
			err = SlotAnonRemoveComponentsElement.Type.Decode(r)
			if err != nil {
				return
			}
			SlotAnonTmp.RemoveComponents = append(SlotAnonTmp.RemoveComponents, SlotAnonRemoveComponentsElement)
		}
		ret.Anon = SlotAnonTmp
	}
	return
}
func (ret *Slot) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ItemCount)
	if err != nil {
		return
	}
	switch ret.ItemCount {
	case 0:
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).ItemId)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).AddedComponentCount)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).RemovedComponentCount)
		if err != nil {
			return
		}
		for iSlotAnonComponents := range len(ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).Components) {
			err = ret.Anon.(struct {
				ItemId                int32
				AddedComponentCount   int32
				RemovedComponentCount int32
				Components            []SlotComponent
				RemoveComponents      []struct {
					Type SlotComponentType
				}
			}).Components[iSlotAnonComponents].Encode(w)
			if err != nil {
				return
			}
		}
		for iSlotAnonRemoveComponents := range len(ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []SlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).RemoveComponents) {
			err = ret.Anon.(struct {
				ItemId                int32
				AddedComponentCount   int32
				RemovedComponentCount int32
				Components            []SlotComponent
				RemoveComponents      []struct {
					Type SlotComponentType
				}
			}).RemoveComponents[iSlotAnonRemoveComponents].Type.Encode(w)
			if err != nil {
				return
			}
		}
	}
	return
}

type SlotComponent struct {
	Type SlotComponentType
	Data any
}

func (ret *SlotComponent) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *SlotComponent) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type SlotComponentType struct {
	Val string
}

var SlotComponentTypeMap = map[int32]string{0: "custom_data", 1: "max_stack_size", 10: "enchantments", 11: "can_place_on", 12: "can_break", 13: "attribute_modifiers", 14: "custom_model_data", 15: "tooltip_display", 16: "repair_cost", 17: "creative_slot_lock", 18: "enchantment_glint_override", 19: "intangible_projectile", 2: "max_damage", 20: "food", 21: "consumable", 22: "use_remainder", 23: "use_cooldown", 24: "damage_resistant", 25: "tool", 26: "weapon", 27: "enchantable", 28: "equippable", 29: "repairable", 3: "damage", 30: "glider", 31: "tooltip_style", 32: "death_protection", 33: "blocks_attacks", 34: "stored_enchantments", 35: "dyed_color", 36: "map_color", 37: "map_id", 38: "map_decorations", 39: "map_post_processing", 4: "unbreakable", 40: "potion_duration_scale", 41: "charged_projectiles", 42: "bundle_contents", 43: "potion_contents", 44: "suspicious_stew_effects", 45: "writable_book_content", 46: "written_book_content", 47: "trim", 48: "debug_stick_state", 49: "entity_data", 5: "custom_name", 50: "bucket_entity_data", 51: "block_entity_data", 52: "instrument", 53: "provides_trim_material", 54: "ominous_bottle_amplifier", 55: "jukebox_playable", 56: "provides_banner_patterns", 57: "recipes", 58: "lodestone_tracker", 59: "firework_explosion", 6: "item_name", 60: "fireworks", 61: "profile", 62: "note_block_sound", 63: "banner_patterns", 64: "base_color", 65: "pot_decorations", 66: "container", 67: "block_state", 68: "bees", 69: "lock", 7: "item_model", 70: "container_loot", 71: "break_sound", 72: "villager/variant", 73: "wolf/variant", 74: "wolf/sound_variant", 75: "wolf/collar", 76: "fox/variant", 77: "salmon/size", 78: "parrot/variant", 79: "tropical_fish/pattern", 8: "lore", 80: "tropical_fish/base_color", 81: "tropical_fish/pattern_color", 82: "mooshroom/variant", 83: "rabbit/variant", 84: "pig/variant", 85: "cow/variant", 86: "chicken/variant", 87: "frog/variant", 88: "horse/variant", 89: "painting/variant", 9: "rarity", 90: "llama/variant", 91: "axolotl/variant", 92: "cat/variant", 93: "cat/collar", 94: "sheep/color", 95: "shulker/color"}

func (ret *SlotComponentType) Decode(r io.Reader) (err error) {
	var SlotComponentTypeKey int32
	SlotComponentTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = proto_base.ErroringIndex(SlotComponentTypeMap, SlotComponentTypeKey)
	if err != nil {
		return
	}
	return
}

var SlotComponentTypeReverseMap = map[string]int32{"custom_data": 0, "max_stack_size": 1, "enchantments": 10, "can_place_on": 11, "can_break": 12, "attribute_modifiers": 13, "custom_model_data": 14, "tooltip_display": 15, "repair_cost": 16, "creative_slot_lock": 17, "enchantment_glint_override": 18, "intangible_projectile": 19, "max_damage": 2, "food": 20, "consumable": 21, "use_remainder": 22, "use_cooldown": 23, "damage_resistant": 24, "tool": 25, "weapon": 26, "enchantable": 27, "equippable": 28, "repairable": 29, "damage": 3, "glider": 30, "tooltip_style": 31, "death_protection": 32, "blocks_attacks": 33, "stored_enchantments": 34, "dyed_color": 35, "map_color": 36, "map_id": 37, "map_decorations": 38, "map_post_processing": 39, "unbreakable": 4, "potion_duration_scale": 40, "charged_projectiles": 41, "bundle_contents": 42, "potion_contents": 43, "suspicious_stew_effects": 44, "writable_book_content": 45, "written_book_content": 46, "trim": 47, "debug_stick_state": 48, "entity_data": 49, "custom_name": 5, "bucket_entity_data": 50, "block_entity_data": 51, "instrument": 52, "provides_trim_material": 53, "ominous_bottle_amplifier": 54, "jukebox_playable": 55, "provides_banner_patterns": 56, "recipes": 57, "lodestone_tracker": 58, "firework_explosion": 59, "item_name": 6, "fireworks": 60, "profile": 61, "note_block_sound": 62, "banner_patterns": 63, "base_color": 64, "pot_decorations": 65, "container": 66, "block_state": 67, "bees": 68, "lock": 69, "item_model": 7, "container_loot": 70, "break_sound": 71, "villager/variant": 72, "wolf/variant": 73, "wolf/sound_variant": 74, "wolf/collar": 75, "fox/variant": 76, "salmon/size": 77, "parrot/variant": 78, "tropical_fish/pattern": 79, "lore": 8, "tropical_fish/base_color": 80, "tropical_fish/pattern_color": 81, "mooshroom/variant": 82, "rabbit/variant": 83, "pig/variant": 84, "cow/variant": 85, "chicken/variant": 86, "frog/variant": 87, "horse/variant": 88, "painting/variant": 89, "rarity": 9, "llama/variant": 90, "axolotl/variant": 91, "cat/variant": 92, "cat/collar": 93, "sheep/color": 94, "shulker/color": 95}

func (ret *SlotComponentType) Encode(w io.Writer) (err error) {
	var vSlotComponentType int32
	vSlotComponentType, err = proto_base.ErroringIndex(SlotComponentTypeReverseMap, ret.Val)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vSlotComponentType)
	if err != nil {
		return
	}
	return
}

type UntrustedSlot struct {
	ItemCount int32
	Anon      any
}

func (ret *UntrustedSlot) Decode(r io.Reader) (err error) {
	ret.ItemCount, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.ItemCount {
	case 0:
		var UntrustedSlotAnon0Tmp struct {
		}
		ret.Anon = UntrustedSlotAnon0Tmp
	default:
		var UntrustedSlotAnonTmp struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}
		UntrustedSlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		UntrustedSlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		UntrustedSlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		var lUntrustedSlotAnonComponents int32
		lUntrustedSlotAnonComponents = UntrustedSlotAnonTmp.AddedComponentCount
		UntrustedSlotAnonTmp.Components = []UntrustedSlotComponent{}
		for range lUntrustedSlotAnonComponents {
			var UntrustedSlotAnonComponentsElement UntrustedSlotComponent
			err = UntrustedSlotAnonComponentsElement.Decode(r)
			if err != nil {
				return
			}
			UntrustedSlotAnonTmp.Components = append(UntrustedSlotAnonTmp.Components, UntrustedSlotAnonComponentsElement)
		}
		var lUntrustedSlotAnonRemoveComponents int32
		lUntrustedSlotAnonRemoveComponents = UntrustedSlotAnonTmp.RemovedComponentCount
		UntrustedSlotAnonTmp.RemoveComponents = []struct {
			Type SlotComponentType
		}{}
		for range lUntrustedSlotAnonRemoveComponents {
			var UntrustedSlotAnonRemoveComponentsElement struct {
				Type SlotComponentType
			}
			err = UntrustedSlotAnonRemoveComponentsElement.Type.Decode(r)
			if err != nil {
				return
			}
			UntrustedSlotAnonTmp.RemoveComponents = append(UntrustedSlotAnonTmp.RemoveComponents, UntrustedSlotAnonRemoveComponentsElement)
		}
		ret.Anon = UntrustedSlotAnonTmp
	}
	return
}
func (ret *UntrustedSlot) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ItemCount)
	if err != nil {
		return
	}
	switch ret.ItemCount {
	case 0:
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).ItemId)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).AddedComponentCount)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).RemovedComponentCount)
		if err != nil {
			return
		}
		for iUntrustedSlotAnonComponents := range len(ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).Components) {
			err = ret.Anon.(struct {
				ItemId                int32
				AddedComponentCount   int32
				RemovedComponentCount int32
				Components            []UntrustedSlotComponent
				RemoveComponents      []struct {
					Type SlotComponentType
				}
			}).Components[iUntrustedSlotAnonComponents].Encode(w)
			if err != nil {
				return
			}
		}
		for iUntrustedSlotAnonRemoveComponents := range len(ret.Anon.(struct {
			ItemId                int32
			AddedComponentCount   int32
			RemovedComponentCount int32
			Components            []UntrustedSlotComponent
			RemoveComponents      []struct {
				Type SlotComponentType
			}
		}).RemoveComponents) {
			err = ret.Anon.(struct {
				ItemId                int32
				AddedComponentCount   int32
				RemovedComponentCount int32
				Components            []UntrustedSlotComponent
				RemoveComponents      []struct {
					Type SlotComponentType
				}
			}).RemoveComponents[iUntrustedSlotAnonRemoveComponents].Type.Encode(w)
			if err != nil {
				return
			}
		}
	}
	return
}

type UntrustedSlotComponent struct {
	Type SlotComponentType
	Data ByteArray
}

func (ret *UntrustedSlotComponent) Decode(r io.Reader) (err error) {
	err = ret.Type.Decode(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *UntrustedSlotComponent) Encode(w io.Writer) (err error) {
	err = ret.Type.Encode(w)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type ChatSession struct {
	Val *struct {
		Uuid      uuid.UUID
		PublicKey struct {
			ExpireTime   int64
			KeyBytes     []byte
			KeySignature []byte
		}
	}
}

func (ret *ChatSession) Decode(r io.Reader) (err error) {
	var ChatSessionPresent bool
	err = binary.Read(r, binary.BigEndian, &ChatSessionPresent)
	if err != nil {
		return
	}
	if ChatSessionPresent {
		var ChatSessionPresentValue struct {
			Uuid      uuid.UUID
			PublicKey struct {
				ExpireTime   int64
				KeyBytes     []byte
				KeySignature []byte
			}
		}
		_, err = io.ReadFull(r, ChatSessionPresentValue.Uuid[:])
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &ChatSessionPresentValue.PublicKey.ExpireTime)
		if err != nil {
			return
		}
		var lChatSessionPublicKeyKeyBytes int32
		lChatSessionPublicKeyKeyBytes, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ChatSessionPresentValue.PublicKey.KeyBytes, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeyBytes)))
		if err != nil {
			return
		}
		var lChatSessionPublicKeyKeySignature int32
		lChatSessionPublicKeyKeySignature, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ChatSessionPresentValue.PublicKey.KeySignature, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeySignature)))
		if err != nil {
			return
		}
		ret.Val = &ChatSessionPresentValue
	}
	return
}
func (ret *ChatSession) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Val != nil)
	if err != nil {
		return
	}
	if ret.Val != nil {
		_, err = w.Write((*ret.Val).Uuid[:])
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, (*ret.Val).PublicKey.ExpireTime)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeyBytes)))
		if err != nil {
			return
		}
		_, err = w.Write((*ret.Val).PublicKey.KeyBytes)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeySignature)))
		if err != nil {
			return
		}
		_, err = w.Write((*ret.Val).PublicKey.KeySignature)
		if err != nil {
			return
		}
	}
	return
}

type ChunkBlockEntity struct {
	Anon struct {
		X uint8
		Z uint8
	}
	Y       int16
	Type    int32
	NbtData nbt.Anon
}

func (ret *ChunkBlockEntity) Decode(r io.Reader) (err error) {
	var ChunkBlockEntityAnonPacked uint8
	err = binary.Read(r, binary.BigEndian, &ChunkBlockEntityAnonPacked)
	if err != nil {
		return
	}
	ret.Anon.X = ChunkBlockEntityAnonPacked << 0 >> 4
	ret.Anon.Z = ChunkBlockEntityAnonPacked << 4 >> 4
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.NbtData.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *ChunkBlockEntity) Encode(w io.Writer) (err error) {
	var ChunkBlockEntityAnonPacked uint8
	ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.Z) & 0xF) << 0x0
	ChunkBlockEntityAnonPacked |= (uint8(ret.Anon.X) & 0xF) << 0x4
	err = binary.Write(w, binary.BigEndian, ChunkBlockEntityAnonPacked)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	err = ret.NbtData.Encode(w)
	if err != nil {
		return
	}
	return
}

type CommandNode struct {
	Flags struct {
		Unused               uint8
		AllowsRestricted     bool
		HasCustomSuggestions bool
		HasRedirectNode      bool
		HasCommand           bool
		CommandNodeType      uint8
	}
	Children      []int32
	RedirectNode  any
	ExtraNodeData any
}

func (ret *CommandNode) Decode(r io.Reader) (err error) {
	var CommandNodeFlagsPacked uint8
	err = binary.Read(r, binary.BigEndian, &CommandNodeFlagsPacked)
	if err != nil {
		return
	}
	ret.Flags.Unused = CommandNodeFlagsPacked << 0 >> 6
	ret.Flags.AllowsRestricted = CommandNodeFlagsPacked<<2>>7 == 1
	ret.Flags.HasCustomSuggestions = CommandNodeFlagsPacked<<3>>7 == 1
	ret.Flags.HasRedirectNode = CommandNodeFlagsPacked<<4>>7 == 1
	ret.Flags.HasCommand = CommandNodeFlagsPacked<<5>>7 == 1
	ret.Flags.CommandNodeType = CommandNodeFlagsPacked << 6 >> 6
	var lCommandNodeChildren int32
	lCommandNodeChildren, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Children = []int32{}
	for range lCommandNodeChildren {
		var CommandNodeChildrenElement int32
		CommandNodeChildrenElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Children = append(ret.Children, CommandNodeChildrenElement)
	}
	switch ret.Flags.HasRedirectNode {
	case true:
		var CommandNodeRedirectNode1Tmp int32
		CommandNodeRedirectNode1Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.RedirectNode = CommandNodeRedirectNode1Tmp
	default:
		var CommandNodeRedirectNodeTmp struct {
		}
		ret.RedirectNode = CommandNodeRedirectNodeTmp
	}
	return
}
func (ret *CommandNode) Encode(w io.Writer) (err error) {
	var CommandNodeFlagsPacked uint8
	CommandNodeFlagsPacked |= (uint8(ret.Flags.CommandNodeType) & 0x3) << 0x0
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCommand) & 0x1) << 0x2
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasRedirectNode) & 0x1) << 0x3
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.HasCustomSuggestions) & 0x1) << 0x4
	CommandNodeFlagsPacked |= (proto_base.Bool2uint8(ret.Flags.AllowsRestricted) & 0x1) << 0x5
	CommandNodeFlagsPacked |= (uint8(ret.Flags.Unused) & 0x3) << 0x6
	err = binary.Write(w, binary.BigEndian, CommandNodeFlagsPacked)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Children)))
	if err != nil {
		return
	}
	for iCommandNodeChildren := range len(ret.Children) {
		err = proto_base.EncodeVarInt(w, ret.Children[iCommandNodeChildren])
		if err != nil {
			return
		}
	}
	switch ret.Flags.HasRedirectNode {
	case true:
		CommandNodeRedirectNode, ok := ret.RedirectNode.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, CommandNodeRedirectNode)
		if err != nil {
			return
		}
	default:
		_, ok := ret.RedirectNode.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type EntityMetadata struct {
	Val proto_base.ToDo
}

func (ret *EntityMetadata) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *EntityMetadata) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type EntityMetadataEntry struct {
	Key   uint8
	Type  string
	Value any
}

var EntityMetadataEntryTypeMap = map[int32]string{0: "byte", 1: "int", 10: "block_pos", 11: "optional_block_pos", 12: "direction", 13: "optional_uuid", 14: "block_state", 15: "optional_block_state", 16: "particle", 17: "particles", 18: "villager_data", 19: "optional_unsigned_int", 2: "long", 20: "pose", 21: "cat_variant", 22: "cow_variant", 23: "wolf_variant", 24: "wolf_sound_variant", 25: "frog_variant", 26: "pig_variant", 27: "chicken_variant", 28: "optional_global_pos", 29: "painting_variant", 3: "float", 30: "sniffer_state", 31: "armadillo_state", 32: "copper_golem_state", 33: "weathering_copper_golem_state", 34: "vector3", 35: "quaternion", 36: "resolvable_profile", 4: "string", 5: "component", 6: "optional_component", 7: "item_stack", 8: "boolean", 9: "rotations"}

func (ret *EntityMetadataEntry) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Key)
	if err != nil {
		return
	}
	var EntityMetadataEntryTypeKey int32
	EntityMetadataEntryTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(EntityMetadataEntryTypeMap, EntityMetadataEntryTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "armadillo_state":
		var EntityMetadataEntryValueArmadilloStateTmp int32
		EntityMetadataEntryValueArmadilloStateTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueArmadilloStateTmp
	case "block_pos":
		var EntityMetadataEntryValueBlockPosTmp Position
		err = EntityMetadataEntryValueBlockPosTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueBlockPosTmp
	case "block_state":
		var EntityMetadataEntryValueBlockStateTmp int32
		EntityMetadataEntryValueBlockStateTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueBlockStateTmp
	case "boolean":
		var EntityMetadataEntryValueBooleanTmp bool
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueBooleanTmp)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueBooleanTmp
	case "byte":
		var EntityMetadataEntryValueByteTmp int8
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueByteTmp)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueByteTmp
	case "cat_variant":
		var EntityMetadataEntryValueCatVariantTmp int32
		EntityMetadataEntryValueCatVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueCatVariantTmp
	case "chicken_variant":
		var EntityMetadataEntryValueChickenVariantTmp int32
		EntityMetadataEntryValueChickenVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueChickenVariantTmp
	case "component":
		var EntityMetadataEntryValueComponentTmp nbt.Anon
		err = EntityMetadataEntryValueComponentTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueComponentTmp
	case "copper_golem_state":
		var EntityMetadataEntryValueCopperGolemStateTmp int32
		EntityMetadataEntryValueCopperGolemStateTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueCopperGolemStateTmp
	case "cow_variant":
		var EntityMetadataEntryValueCowVariantTmp int32
		EntityMetadataEntryValueCowVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueCowVariantTmp
	case "direction":
		var EntityMetadataEntryValueDirectionTmp int32
		EntityMetadataEntryValueDirectionTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueDirectionTmp
	case "float":
		var EntityMetadataEntryValueFloatTmp float32
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueFloatTmp)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueFloatTmp
	case "frog_variant":
		var EntityMetadataEntryValueFrogVariantTmp int32
		EntityMetadataEntryValueFrogVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueFrogVariantTmp
	case "int":
		var EntityMetadataEntryValueIntTmp int32
		EntityMetadataEntryValueIntTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueIntTmp
	case "item_stack":
		var EntityMetadataEntryValueItemStackTmp Slot
		err = EntityMetadataEntryValueItemStackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueItemStackTmp
	case "long":
		var EntityMetadataEntryValueLongTmp int64
		EntityMetadataEntryValueLongTmp, err = proto_base.DecodeVarLong(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueLongTmp
	case "optional_block_pos":
		var EntityMetadataEntryValueOptionalBlockPosTmp *Position
		var EntityMetadataEntryValuePresent bool
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent)
		if err != nil {
			return
		}
		if EntityMetadataEntryValuePresent {
			var EntityMetadataEntryValuePresentValue Position
			err = EntityMetadataEntryValuePresentValue.Decode(r)
			if err != nil {
				return
			}
			EntityMetadataEntryValueOptionalBlockPosTmp = &EntityMetadataEntryValuePresentValue
		}
		ret.Value = EntityMetadataEntryValueOptionalBlockPosTmp
	case "optional_block_state":
		var EntityMetadataEntryValueOptionalBlockStateTmp Optvarint
		err = EntityMetadataEntryValueOptionalBlockStateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueOptionalBlockStateTmp
	case "optional_component":
		var EntityMetadataEntryValueOptionalComponentTmp *nbt.Anon
		var EntityMetadataEntryValuePresent bool
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent)
		if err != nil {
			return
		}
		if EntityMetadataEntryValuePresent {
			var EntityMetadataEntryValuePresentValue nbt.Anon
			err = EntityMetadataEntryValuePresentValue.Decode(r)
			if err != nil {
				return
			}
			EntityMetadataEntryValueOptionalComponentTmp = &EntityMetadataEntryValuePresentValue
		}
		ret.Value = EntityMetadataEntryValueOptionalComponentTmp
	case "optional_global_pos":
		var EntityMetadataEntryValueOptionalGlobalPosTmp *GlobalPos
		var EntityMetadataEntryValuePresent bool
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent)
		if err != nil {
			return
		}
		if EntityMetadataEntryValuePresent {
			var EntityMetadataEntryValuePresentValue GlobalPos
			err = EntityMetadataEntryValuePresentValue.Decode(r)
			if err != nil {
				return
			}
			EntityMetadataEntryValueOptionalGlobalPosTmp = &EntityMetadataEntryValuePresentValue
		}
		ret.Value = EntityMetadataEntryValueOptionalGlobalPosTmp
	case "optional_unsigned_int":
		var EntityMetadataEntryValueOptionalUnsignedIntTmp Optvarint
		err = EntityMetadataEntryValueOptionalUnsignedIntTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueOptionalUnsignedIntTmp
	case "optional_uuid":
		var EntityMetadataEntryValueOptionalUuidTmp *uuid.UUID
		var EntityMetadataEntryValuePresent bool
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent)
		if err != nil {
			return
		}
		if EntityMetadataEntryValuePresent {
			var EntityMetadataEntryValuePresentValue uuid.UUID
			_, err = io.ReadFull(r, EntityMetadataEntryValuePresentValue[:])
			if err != nil {
				return
			}
			EntityMetadataEntryValueOptionalUuidTmp = &EntityMetadataEntryValuePresentValue
		}
		ret.Value = EntityMetadataEntryValueOptionalUuidTmp
	case "painting_variant":
		var EntityMetadataEntryValuePaintingVariantTmp any
		var EntityMetadataEntryValueId int32
		EntityMetadataEntryValueId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		if EntityMetadataEntryValueId != 0 {
			EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValueId
		} else {
			var EntityMetadataEntryValueResult EntityMetadataPaintingVariant
			err = EntityMetadataEntryValueResult.Decode(r)
			if err != nil {
				return
			}
			EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValueResult
		}
		ret.Value = EntityMetadataEntryValuePaintingVariantTmp
	case "particle":
		var EntityMetadataEntryValueParticleTmp Particle
		err = EntityMetadataEntryValueParticleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueParticleTmp
	case "particles":
		var EntityMetadataEntryValueParticlesTmp []Particle
		var lEntityMetadataEntryValue int32
		lEntityMetadataEntryValue, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		EntityMetadataEntryValueParticlesTmp = []Particle{}
		for range lEntityMetadataEntryValue {
			var EntityMetadataEntryValueElement Particle
			err = EntityMetadataEntryValueElement.Decode(r)
			if err != nil {
				return
			}
			EntityMetadataEntryValueParticlesTmp = append(EntityMetadataEntryValueParticlesTmp, EntityMetadataEntryValueElement)
		}
		ret.Value = EntityMetadataEntryValueParticlesTmp
	case "pig_variant":
		var EntityMetadataEntryValuePigVariantTmp int32
		EntityMetadataEntryValuePigVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValuePigVariantTmp
	case "pose":
		var EntityMetadataEntryValuePoseTmp int32
		EntityMetadataEntryValuePoseTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValuePoseTmp
	case "quaternion":
		var EntityMetadataEntryValueQuaternionTmp Vec4f
		err = EntityMetadataEntryValueQuaternionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueQuaternionTmp
	case "resolvable_profile":
		var EntityMetadataEntryValueResolvableProfileTmp ResolvableProfile
		err = EntityMetadataEntryValueResolvableProfileTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueResolvableProfileTmp
	case "rotations":
		var EntityMetadataEntryValueRotationsTmp struct {
			Pitch float32
			Yaw   float32
			Roll  float32
		}
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Pitch)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Yaw)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Roll)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueRotationsTmp
	case "sniffer_state":
		var EntityMetadataEntryValueSnifferStateTmp int32
		EntityMetadataEntryValueSnifferStateTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueSnifferStateTmp
	case "string":
		var EntityMetadataEntryValueStringTmp string
		EntityMetadataEntryValueStringTmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueStringTmp
	case "vector3":
		var EntityMetadataEntryValueVector3Tmp Vec3f
		err = EntityMetadataEntryValueVector3Tmp.Decode(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueVector3Tmp
	case "villager_data":
		var EntityMetadataEntryValueVillagerDataTmp struct {
			VillagerType       int32
			VillagerProfession int32
			Level              int32
		}
		EntityMetadataEntryValueVillagerDataTmp.VillagerType, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		EntityMetadataEntryValueVillagerDataTmp.VillagerProfession, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		EntityMetadataEntryValueVillagerDataTmp.Level, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueVillagerDataTmp
	case "weathering_copper_golem_state":
		var EntityMetadataEntryValueWeatheringCopperGolemStateTmp int32
		EntityMetadataEntryValueWeatheringCopperGolemStateTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueWeatheringCopperGolemStateTmp
	case "wolf_sound_variant":
		var EntityMetadataEntryValueWolfSoundVariantTmp int32
		EntityMetadataEntryValueWolfSoundVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueWolfSoundVariantTmp
	case "wolf_variant":
		var EntityMetadataEntryValueWolfVariantTmp int32
		EntityMetadataEntryValueWolfVariantTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Value = EntityMetadataEntryValueWolfVariantTmp
	}
	return
}

var EntityMetadataEntryTypeReverseMap = map[string]int32{"byte": 0, "int": 1, "block_pos": 10, "optional_block_pos": 11, "direction": 12, "optional_uuid": 13, "block_state": 14, "optional_block_state": 15, "particle": 16, "particles": 17, "villager_data": 18, "optional_unsigned_int": 19, "long": 2, "pose": 20, "cat_variant": 21, "cow_variant": 22, "wolf_variant": 23, "wolf_sound_variant": 24, "frog_variant": 25, "pig_variant": 26, "chicken_variant": 27, "optional_global_pos": 28, "painting_variant": 29, "float": 3, "sniffer_state": 30, "armadillo_state": 31, "copper_golem_state": 32, "weathering_copper_golem_state": 33, "vector3": 34, "quaternion": 35, "resolvable_profile": 36, "string": 4, "component": 5, "optional_component": 6, "item_stack": 7, "boolean": 8, "rotations": 9}

func (ret *EntityMetadataEntry) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Key)
	if err != nil {
		return
	}
	var vEntityMetadataEntryType int32
	vEntityMetadataEntryType, err = proto_base.ErroringIndex(EntityMetadataEntryTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vEntityMetadataEntryType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "armadillo_state":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "block_pos":
		EntityMetadataEntryValue, ok := ret.Value.(Position)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "block_state":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "boolean":
		EntityMetadataEntryValue, ok := ret.Value.(bool)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "byte":
		EntityMetadataEntryValue, ok := ret.Value.(int8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "cat_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "chicken_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "component":
		EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "copper_golem_state":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "cow_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "direction":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "float":
		EntityMetadataEntryValue, ok := ret.Value.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "frog_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "int":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "item_stack":
		EntityMetadataEntryValue, ok := ret.Value.(Slot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "long":
		EntityMetadataEntryValue, ok := ret.Value.(int64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarLong(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "optional_block_pos":
		EntityMetadataEntryValue, ok := ret.Value.(*Position)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
		if err != nil {
			return
		}
		if EntityMetadataEntryValue != nil {
			err = (*EntityMetadataEntryValue).Encode(w)
			if err != nil {
				return
			}
		}
	case "optional_block_state":
		EntityMetadataEntryValue, ok := ret.Value.(Optvarint)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "optional_component":
		EntityMetadataEntryValue, ok := ret.Value.(*nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
		if err != nil {
			return
		}
		if EntityMetadataEntryValue != nil {
			err = (*EntityMetadataEntryValue).Encode(w)
			if err != nil {
				return
			}
		}
	case "optional_global_pos":
		EntityMetadataEntryValue, ok := ret.Value.(*GlobalPos)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
		if err != nil {
			return
		}
		if EntityMetadataEntryValue != nil {
			err = (*EntityMetadataEntryValue).Encode(w)
			if err != nil {
				return
			}
		}
	case "optional_unsigned_int":
		EntityMetadataEntryValue, ok := ret.Value.(Optvarint)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "optional_uuid":
		EntityMetadataEntryValue, ok := ret.Value.(*uuid.UUID)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil)
		if err != nil {
			return
		}
		if EntityMetadataEntryValue != nil {
			_, err = w.Write((*EntityMetadataEntryValue)[:])
			if err != nil {
				return
			}
		}
	case "painting_variant":
		EntityMetadataEntryValue, ok := ret.Value.(any)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) {
		case int32:
			err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType)
			if err != nil {
				return
			}
		case EntityMetadataPaintingVariant:
			err = proto_base.EncodeVarInt(w, 0)
			if err != nil {
				return
			}
			err = EntityMetadataEntryValueKnownType.Encode(w)
			if err != nil {
				return
			}
		default:
			err = proto_base.BadTypeError
		}
	case "particle":
		EntityMetadataEntryValue, ok := ret.Value.(Particle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "particles":
		EntityMetadataEntryValue, ok := ret.Value.([]Particle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(EntityMetadataEntryValue)))
		if err != nil {
			return
		}
		for iEntityMetadataEntryValue := range len(EntityMetadataEntryValue) {
			err = EntityMetadataEntryValue[iEntityMetadataEntryValue].Encode(w)
			if err != nil {
				return
			}
		}
	case "pig_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "pose":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "quaternion":
		EntityMetadataEntryValue, ok := ret.Value.(Vec4f)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "resolvable_profile":
		EntityMetadataEntryValue, ok := ret.Value.(ResolvableProfile)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "rotations":
		EntityMetadataEntryValue, ok := ret.Value.(struct {
			Pitch float32
			Yaw   float32
			Roll  float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Pitch)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Yaw)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Roll)
		if err != nil {
			return
		}
	case "sniffer_state":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "string":
		EntityMetadataEntryValue, ok := ret.Value.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "vector3":
		EntityMetadataEntryValue, ok := ret.Value.(Vec3f)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = EntityMetadataEntryValue.Encode(w)
		if err != nil {
			return
		}
	case "villager_data":
		EntityMetadataEntryValue, ok := ret.Value.(struct {
			VillagerType       int32
			VillagerProfession int32
			Level              int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerType)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerProfession)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.Level)
		if err != nil {
			return
		}
	case "weathering_copper_golem_state":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "wolf_sound_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	case "wolf_variant":
		EntityMetadataEntryValue, ok := ret.Value.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue)
		if err != nil {
			return
		}
	}
	return
}

type GameProfileNameProp struct {
	Name       string
	Properties []GameProfileProperty
}

func (ret *GameProfileNameProp) Decode(r io.Reader) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lGameProfileNamePropProperties int32
	lGameProfileNamePropProperties, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Properties = []GameProfileProperty{}
	for range lGameProfileNamePropProperties {
		var GameProfileNamePropPropertiesElement GameProfileProperty
		err = GameProfileNamePropPropertiesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Properties = append(ret.Properties, GameProfileNamePropPropertiesElement)
	}
	return
}
func (ret *GameProfileNameProp) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iGameProfileNamePropProperties := range len(ret.Properties) {
		err = ret.Properties[iGameProfileNamePropProperties].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type Ingredient struct {
	Val []Slot
}

func (ret *Ingredient) Decode(r io.Reader) (err error) {
	var lIngredient int32
	lIngredient, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []Slot{}
	for range lIngredient {
		var IngredientElement Slot
		err = IngredientElement.Decode(r)
		if err != nil {
			return
		}
		ret.Val = append(ret.Val, IngredientElement)
	}
	return
}
func (ret *Ingredient) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iIngredient := range len(ret.Val) {
		err = ret.Val[iIngredient].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type Optvarint struct {
	Val int32
}

func (ret *Optvarint) Decode(r io.Reader) (err error) {
	ret.Val, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *Optvarint) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Val)
	if err != nil {
		return
	}
	return
}

type PackedChunkPos struct {
	Z int32
	X int32
}

func (ret *PackedChunkPos) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	return
}
func (ret *PackedChunkPos) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	return
}

type Position struct {
	X int32
	Z int32
	Y int16
}

func (ret *Position) Decode(r io.Reader) (err error) {
	var PositionPacked uint64
	err = binary.Read(r, binary.BigEndian, &PositionPacked)
	if err != nil {
		return
	}
	ret.X = int32(PositionPacked << 0 >> 38)
	if ret.X >= 1<<25 {
		ret.X -= 1 << 26
	}
	ret.Z = int32(PositionPacked << 26 >> 38)
	if ret.Z >= 1<<25 {
		ret.Z -= 1 << 26
	}
	ret.Y = int16(PositionPacked << 52 >> 52)
	if ret.Y >= 1<<11 {
		ret.Y -= 1 << 12
	}
	return
}
func (ret *Position) Encode(w io.Writer) (err error) {
	var PositionPacked uint64
	PositionPacked |= (uint64(ret.Y) & 0xFFF) << 0x0
	PositionPacked |= (uint64(ret.Z) & 0x3FFFFFF) << 0xC
	PositionPacked |= (uint64(ret.X) & 0x3FFFFFF) << 0x26
	err = binary.Write(w, binary.BigEndian, PositionPacked)
	if err != nil {
		return
	}
	return
}

type PreviousMessages struct {
	Val []struct {
		Id        int32
		Signature any
	}
}

func (ret *PreviousMessages) Decode(r io.Reader) (err error) {
	var lPreviousMessages int32
	lPreviousMessages, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []struct {
		Id        int32
		Signature any
	}{}
	for range lPreviousMessages {
		var PreviousMessagesElement struct {
			Id        int32
			Signature any
		}
		PreviousMessagesElement.Id, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		switch PreviousMessagesElement.Id {
		case 0:
			var PreviousMessagesElementSignature0Tmp [256]byte
			_, err = r.Read(PreviousMessagesElementSignature0Tmp[:])
			if err != nil {
				return
			}
			PreviousMessagesElement.Signature = PreviousMessagesElementSignature0Tmp
		default:
			var PreviousMessagesElementSignatureTmp struct {
			}
			PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp
		}
		ret.Val = append(ret.Val, PreviousMessagesElement)
	}
	return
}
func (ret *PreviousMessages) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iPreviousMessages := range len(ret.Val) {
		err = proto_base.EncodeVarInt(w, ret.Val[iPreviousMessages].Id)
		if err != nil {
			return
		}
		switch ret.Val[iPreviousMessages].Id {
		case 0:
			PreviousMessagesInnerSignature, ok := ret.Val[iPreviousMessages].Signature.([256]byte)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			arr := PreviousMessagesInnerSignature
			_, err = w.Write(arr[:])
			if err != nil {
				return
			}
		default:
			_, ok := ret.Val[iPreviousMessages].Signature.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
	}
	return
}

type SoundSource struct {
	Val string
}

var SoundSourceMap = map[int32]string{0: "master", 1: "music", 10: "ui", 2: "record", 3: "weather", 4: "block", 5: "hostile", 6: "neutral", 7: "player", 8: "ambient", 9: "voice"}

func (ret *SoundSource) Decode(r io.Reader) (err error) {
	var SoundSourceKey int32
	SoundSourceKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = proto_base.ErroringIndex(SoundSourceMap, SoundSourceKey)
	if err != nil {
		return
	}
	return
}

var SoundSourceReverseMap = map[string]int32{"master": 0, "music": 1, "ui": 10, "record": 2, "weather": 3, "block": 4, "hostile": 5, "neutral": 6, "player": 7, "ambient": 8, "voice": 9}

func (ret *SoundSource) Encode(w io.Writer) (err error) {
	var vSoundSource int32
	vSoundSource, err = proto_base.ErroringIndex(SoundSourceReverseMap, ret.Val)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vSoundSource)
	if err != nil {
		return
	}
	return
}

type Tags struct {
	Val []struct {
		TagName string
		Entries []int32
	}
}

func (ret *Tags) Decode(r io.Reader) (err error) {
	var lTags int32
	lTags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val = []struct {
		TagName string
		Entries []int32
	}{}
	for range lTags {
		var TagsElement struct {
			TagName string
			Entries []int32
		}
		TagsElement.TagName, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var lTagsElementEntries int32
		lTagsElementEntries, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		TagsElement.Entries = []int32{}
		for range lTagsElementEntries {
			var TagsElementEntriesElement int32
			TagsElementEntriesElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			TagsElement.Entries = append(TagsElement.Entries, TagsElementEntriesElement)
		}
		ret.Val = append(ret.Val, TagsElement)
	}
	return
}
func (ret *Tags) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Val)))
	if err != nil {
		return
	}
	for iTags := range len(ret.Val) {
		err = proto_base.EncodeString(w, ret.Val[iTags].TagName)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Val[iTags].Entries)))
		if err != nil {
			return
		}
		for iTagsInnerEntries := range len(ret.Val[iTags].Entries) {
			err = proto_base.EncodeVarInt(w, ret.Val[iTags].Entries[iTagsInnerEntries])
			if err != nil {
				return
			}
		}
	}
	return
}

type Vec2f struct {
	X float32
	Y float32
}

func (ret *Vec2f) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	return
}
func (ret *Vec2f) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	return
}

type Vec3f struct {
	X float32
	Y float32
	Z float32
}

func (ret *Vec3f) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *Vec3f) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type Vec3f64 struct {
	X float64
	Y float64
	Z float64
}

func (ret *Vec3f64) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *Vec3f64) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type Vec3i struct {
	X int32
	Y int32
	Z int32
}

func (ret *Vec3i) Decode(r io.Reader) (err error) {
	ret.X, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Y, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Z, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *Vec3i) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.X)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Y)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Z)
	if err != nil {
		return
	}
	return
}

type Vec3i32 struct {
	X int32
	Y int32
	Z int32
}

func (ret *Vec3i32) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *Vec3i32) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type Vec4f struct {
	X float32
	Y float32
	Z float32
	W float32
}

func (ret *Vec4f) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.W)
	if err != nil {
		return
	}
	return
}
func (ret *Vec4f) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.W)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacket struct {
	Name   string
	Params any
}

var HandshakingToClientPacketNameMap = map[int32]string{}

func (ret *HandshakingToClientPacket) Decode(r io.Reader) (err error) {
	var HandshakingToClientPacketNameKey int32
	HandshakingToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey)
	if err != nil {
		return
	}
	return
}

var HandshakingToClientPacketNameReverseMap = map[string]int32{}

func (ret *HandshakingToClientPacket) Encode(w io.Writer) (err error) {
	var vHandshakingToClientPacketName int32
	vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketName)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *HandshakingToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent {
		var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *HandshakingToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonClearDialog struct {
}

func (ret *HandshakingToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *HandshakingToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type HandshakingToClientPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *HandshakingToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *HandshakingToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var HandshakingToClientPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if HandshakingToClientPacketCommonCookieResponseValuePresent {
		var HandshakingToClientPacketCommonCookieResponseValuePresentValue ByteArray
		err = HandshakingToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &HandshakingToClientPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *HandshakingToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *HandshakingToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var HandshakingToClientPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if HandshakingToClientPacketCommonCustomClickActionNbtPresent {
		var HandshakingToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = HandshakingToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &HandshakingToClientPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *HandshakingToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *HandshakingToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lHandshakingToClientPacketCommonCustomReportDetailsDetails int32
	lHandshakingToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lHandshakingToClientPacketCommonCustomReportDetailsDetails {
		var HandshakingToClientPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, HandshakingToClientPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *HandshakingToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iHandshakingToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var HandshakingToClientPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if HandshakingToClientPacketCommonRemoveResourcePackUuidPresent {
		var HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lHandshakingToClientPacketCommonSelectKnownPacksPacks int32
	lHandshakingToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lHandshakingToClientPacketCommonSelectKnownPacksPacks {
		var HandshakingToClientPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, HandshakingToClientPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iHandshakingToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *HandshakingToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lHandshakingToClientPacketCommonServerLinksLinks int32
	lHandshakingToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lHandshakingToClientPacketCommonServerLinksLinks {
		var HandshakingToClientPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			HandshakingToClientPacketCommonServerLinksLinksElement.KnownType = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			HandshakingToClientPacketCommonServerLinksLinksElement.UnknownType = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		HandshakingToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, HandshakingToClientPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *HandshakingToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iHandshakingToClientPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType {
		case true:
			HandshakingToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = HandshakingToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType {
		case false:
			HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type HandshakingToClientPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var HandshakingToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *HandshakingToClientPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var HandshakingToClientPacketCommonSettingsParticleStatusKey int32
	HandshakingToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusMap, HandshakingToClientPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var HandshakingToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *HandshakingToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vHandshakingToClientPacketCommonSettingsParticleStatus int32
	vHandshakingToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *HandshakingToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type HandshakingToClientPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *HandshakingToClientPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *HandshakingToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacket struct {
	Name   string
	Params any
}

var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"}

func (ret *StatusToClientPacket) Decode(r io.Reader) (err error) {
	var StatusToClientPacketNameKey int32
	StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		var StatusToClientPacketParamsPingTmp StatusToClientPacketPing
		err = StatusToClientPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToClientPacketParamsPingTmp
	case "server_info":
		var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo
		err = StatusToClientPacketParamsServerInfoTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = StatusToClientPacketParamsServerInfoTmp
	}
	return
}

var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01}

func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) {
	var vStatusToClientPacketName int32
	vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "ping":
		StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = StatusToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "server_info":
		StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = StatusToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *StatusToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var StatusToClientPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if StatusToClientPacketCommonAddResourcePackPromptMessagePresent {
		var StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *StatusToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonClearDialog struct {
}

func (ret *StatusToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *StatusToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type StatusToClientPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *StatusToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *StatusToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var StatusToClientPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if StatusToClientPacketCommonCookieResponseValuePresent {
		var StatusToClientPacketCommonCookieResponseValuePresentValue ByteArray
		err = StatusToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &StatusToClientPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *StatusToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *StatusToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var StatusToClientPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if StatusToClientPacketCommonCustomClickActionNbtPresent {
		var StatusToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = StatusToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &StatusToClientPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *StatusToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *StatusToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lStatusToClientPacketCommonCustomReportDetailsDetails int32
	lStatusToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lStatusToClientPacketCommonCustomReportDetailsDetails {
		var StatusToClientPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		StatusToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, StatusToClientPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *StatusToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iStatusToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *StatusToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var StatusToClientPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if StatusToClientPacketCommonRemoveResourcePackUuidPresent {
		var StatusToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, StatusToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &StatusToClientPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *StatusToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *StatusToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lStatusToClientPacketCommonSelectKnownPacksPacks int32
	lStatusToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lStatusToClientPacketCommonSelectKnownPacksPacks {
		var StatusToClientPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		StatusToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		StatusToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, StatusToClientPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *StatusToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iStatusToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *StatusToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lStatusToClientPacketCommonServerLinksLinks int32
	lStatusToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lStatusToClientPacketCommonServerLinksLinks {
		var StatusToClientPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			StatusToClientPacketCommonServerLinksLinksElement.KnownType = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			StatusToClientPacketCommonServerLinksLinksElement.UnknownType = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		StatusToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, StatusToClientPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *StatusToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iStatusToClientPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType {
		case true:
			StatusToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = StatusToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType {
		case false:
			StatusToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = StatusToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iStatusToClientPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type StatusToClientPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var StatusToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *StatusToClientPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var StatusToClientPacketCommonSettingsParticleStatusKey int32
	StatusToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusMap, StatusToClientPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var StatusToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *StatusToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vStatusToClientPacketCommonSettingsParticleStatus int32
	vStatusToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vStatusToClientPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *StatusToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *StatusToClientPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketPing struct {
	Time int64
}

func (ret *StatusToClientPacketPing) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	return
}

type StatusToClientPacketServerInfo struct {
	Response string
}

func (ret *StatusToClientPacketServerInfo) Decode(r io.Reader) (err error) {
	ret.Response, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Response)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacket struct {
	Name   string
	Params any
}

var LoginToClientPacketNameMap = map[int32]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress", 0x04: "login_plugin_request", 0x05: "cookie_request"}

func (ret *LoginToClientPacket) Decode(r io.Reader) (err error) {
	var LoginToClientPacketNameKey int32
	LoginToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "compress":
		var LoginToClientPacketParamsCompressTmp LoginToClientPacketCompress
		err = LoginToClientPacketParamsCompressTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsCompressTmp
	case "cookie_request":
		var LoginToClientPacketParamsCookieRequestTmp LoginToClientPacketCommonCookieRequest
		err = LoginToClientPacketParamsCookieRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsCookieRequestTmp
	case "disconnect":
		var LoginToClientPacketParamsDisconnectTmp LoginToClientPacketDisconnect
		err = LoginToClientPacketParamsDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsDisconnectTmp
	case "encryption_begin":
		var LoginToClientPacketParamsEncryptionBeginTmp LoginToClientPacketEncryptionBegin
		err = LoginToClientPacketParamsEncryptionBeginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsEncryptionBeginTmp
	case "login_plugin_request":
		var LoginToClientPacketParamsLoginPluginRequestTmp LoginToClientPacketLoginPluginRequest
		err = LoginToClientPacketParamsLoginPluginRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsLoginPluginRequestTmp
	case "success":
		var LoginToClientPacketParamsSuccessTmp LoginToClientPacketSuccess
		err = LoginToClientPacketParamsSuccessTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = LoginToClientPacketParamsSuccessTmp
	}
	return
}

var LoginToClientPacketNameReverseMap = map[string]int32{"disconnect": 0x00, "encryption_begin": 0x01, "success": 0x02, "compress": 0x03, "login_plugin_request": 0x04, "cookie_request": 0x05}

func (ret *LoginToClientPacket) Encode(w io.Writer) (err error) {
	var vLoginToClientPacketName int32
	vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "compress":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "cookie_request":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCommonCookieRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "disconnect":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "encryption_begin":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "login_plugin_request":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketLoginPluginRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "success":
		LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = LoginToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *LoginToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var LoginToClientPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if LoginToClientPacketCommonAddResourcePackPromptMessagePresent {
		var LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *LoginToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonClearDialog struct {
}

func (ret *LoginToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *LoginToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type LoginToClientPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *LoginToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *LoginToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var LoginToClientPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if LoginToClientPacketCommonCookieResponseValuePresent {
		var LoginToClientPacketCommonCookieResponseValuePresentValue ByteArray
		err = LoginToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &LoginToClientPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *LoginToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *LoginToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var LoginToClientPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if LoginToClientPacketCommonCustomClickActionNbtPresent {
		var LoginToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = LoginToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &LoginToClientPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *LoginToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *LoginToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lLoginToClientPacketCommonCustomReportDetailsDetails int32
	lLoginToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lLoginToClientPacketCommonCustomReportDetailsDetails {
		var LoginToClientPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		LoginToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, LoginToClientPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *LoginToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iLoginToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *LoginToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var LoginToClientPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if LoginToClientPacketCommonRemoveResourcePackUuidPresent {
		var LoginToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, LoginToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &LoginToClientPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *LoginToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *LoginToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lLoginToClientPacketCommonSelectKnownPacksPacks int32
	lLoginToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lLoginToClientPacketCommonSelectKnownPacksPacks {
		var LoginToClientPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		LoginToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, LoginToClientPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *LoginToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iLoginToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *LoginToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lLoginToClientPacketCommonServerLinksLinks int32
	lLoginToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lLoginToClientPacketCommonServerLinksLinks {
		var LoginToClientPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			LoginToClientPacketCommonServerLinksLinksElement.KnownType = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			LoginToClientPacketCommonServerLinksLinksElement.UnknownType = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		LoginToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, LoginToClientPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *LoginToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iLoginToClientPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType {
		case true:
			LoginToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = LoginToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType {
		case false:
			LoginToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = LoginToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iLoginToClientPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type LoginToClientPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var LoginToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *LoginToClientPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var LoginToClientPacketCommonSettingsParticleStatusKey int32
	LoginToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusMap, LoginToClientPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var LoginToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *LoginToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vLoginToClientPacketCommonSettingsParticleStatus int32
	vLoginToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vLoginToClientPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *LoginToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *LoginToClientPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketCompress struct {
	Threshold int32
}

func (ret *LoginToClientPacketCompress) Decode(r io.Reader) (err error) {
	ret.Threshold, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketCompress) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Threshold)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketDisconnect struct {
	Reason string
}

func (ret *LoginToClientPacketDisconnect) Decode(r io.Reader) (err error) {
	ret.Reason, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketDisconnect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Reason)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketEncryptionBegin struct {
	ServerId           string
	PublicKey          []byte
	VerifyToken        []byte
	ShouldAuthenticate bool
}

func (ret *LoginToClientPacketEncryptionBegin) Decode(r io.Reader) (err error) {
	ret.ServerId, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lLoginToClientPacketEncryptionBeginPublicKey int32
	lLoginToClientPacketEncryptionBeginPublicKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey)))
	if err != nil {
		return
	}
	var lLoginToClientPacketEncryptionBeginVerifyToken int32
	lLoginToClientPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginVerifyToken)))
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ShouldAuthenticate)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketEncryptionBegin) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.ServerId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.PublicKey)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.PublicKey)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken)))
	if err != nil {
		return
	}
	_, err = w.Write(ret.VerifyToken)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ShouldAuthenticate)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketLoginPluginRequest struct {
	MessageId int32
	Channel   string
	Data      proto_base.RestBuffer
}

func (ret *LoginToClientPacketLoginPluginRequest) Decode(r io.Reader) (err error) {
	ret.MessageId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *LoginToClientPacketLoginPluginRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.MessageId)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type LoginToClientPacketSuccess struct {
	Uuid       uuid.UUID
	Username   string
	Properties []struct {
		Name      string
		Value     string
		Signature *string
	}
}

func (ret *LoginToClientPacketSuccess) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Username, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lLoginToClientPacketSuccessProperties int32
	lLoginToClientPacketSuccessProperties, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Properties = []struct {
		Name      string
		Value     string
		Signature *string
	}{}
	for range lLoginToClientPacketSuccessProperties {
		var LoginToClientPacketSuccessPropertiesElement struct {
			Name      string
			Value     string
			Signature *string
		}
		LoginToClientPacketSuccessPropertiesElement.Name, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		LoginToClientPacketSuccessPropertiesElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var LoginToClientPacketSuccessPropertiesElementSignaturePresent bool
		err = binary.Read(r, binary.BigEndian, &LoginToClientPacketSuccessPropertiesElementSignaturePresent)
		if err != nil {
			return
		}
		if LoginToClientPacketSuccessPropertiesElementSignaturePresent {
			var LoginToClientPacketSuccessPropertiesElementSignaturePresentValue string
			LoginToClientPacketSuccessPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			LoginToClientPacketSuccessPropertiesElement.Signature = &LoginToClientPacketSuccessPropertiesElementSignaturePresentValue
		}
		ret.Properties = append(ret.Properties, LoginToClientPacketSuccessPropertiesElement)
	}
	return
}
func (ret *LoginToClientPacketSuccess) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Username)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iLoginToClientPacketSuccessProperties := range len(ret.Properties) {
		err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Name)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Value)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil)
		if err != nil {
			return
		}
		if ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil {
			err = proto_base.EncodeString(w, *ret.Properties[iLoginToClientPacketSuccessProperties].Signature)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientChatType struct {
	TranslationKey string
	Parameters     []PlayToClientChatTypeParameterType
	Style          nbt.Anon
}

func (ret *PlayToClientChatType) Decode(r io.Reader) (err error) {
	ret.TranslationKey, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var lPlayToClientChatTypeParameters int32
	lPlayToClientChatTypeParameters, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Parameters = []PlayToClientChatTypeParameterType{}
	for range lPlayToClientChatTypeParameters {
		var PlayToClientChatTypeParametersElement PlayToClientChatTypeParameterType
		err = PlayToClientChatTypeParametersElement.Decode(r)
		if err != nil {
			return
		}
		ret.Parameters = append(ret.Parameters, PlayToClientChatTypeParametersElement)
	}
	err = ret.Style.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientChatType) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.TranslationKey)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Parameters)))
	if err != nil {
		return
	}
	for iPlayToClientChatTypeParameters := range len(ret.Parameters) {
		err = ret.Parameters[iPlayToClientChatTypeParameters].Encode(w)
		if err != nil {
			return
		}
	}
	err = ret.Style.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientChatTypeParameterType struct {
	Val string
}

var PlayToClientChatTypeParameterTypeMap = map[int32]string{0: "content", 1: "sender", 2: "target"}

func (ret *PlayToClientChatTypeParameterType) Decode(r io.Reader) (err error) {
	var PlayToClientChatTypeParameterTypeKey int32
	PlayToClientChatTypeParameterTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Val, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeMap, PlayToClientChatTypeParameterTypeKey)
	if err != nil {
		return
	}
	return
}

var PlayToClientChatTypeParameterTypeReverseMap = map[string]int32{"content": 0, "sender": 1, "target": 2}

func (ret *PlayToClientChatTypeParameterType) Encode(w io.Writer) (err error) {
	var vPlayToClientChatTypeParameterType int32
	vPlayToClientChatTypeParameterType, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeReverseMap, ret.Val)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientChatTypeParameterType)
	if err != nil {
		return
	}
	return
}

type PlayToClientChatTypes struct {
	Chat      PlayToClientChatType
	Narration PlayToClientChatType
}

func (ret *PlayToClientChatTypes) Decode(r io.Reader) (err error) {
	err = ret.Chat.Decode(r)
	if err != nil {
		return
	}
	err = ret.Narration.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientChatTypes) Encode(w io.Writer) (err error) {
	err = ret.Chat.Encode(w)
	if err != nil {
		return
	}
	err = ret.Narration.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientChatTypesHolder struct {
	Val any
}

func (ret *PlayToClientChatTypesHolder) Decode(r io.Reader) (err error) {
	var PlayToClientChatTypesHolderId int32
	PlayToClientChatTypesHolderId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	if PlayToClientChatTypesHolderId != 0 {
		ret.Val = PlayToClientChatTypesHolderId
	} else {
		var PlayToClientChatTypesHolderResult PlayToClientChatTypes
		err = PlayToClientChatTypesHolderResult.Decode(r)
		if err != nil {
			return
		}
		ret.Val = PlayToClientChatTypesHolderResult
	}
	return
}
func (ret *PlayToClientChatTypesHolder) Encode(w io.Writer) (err error) {
	switch PlayToClientChatTypesHolderKnownType := ret.Val.(type) {
	case int32:
		err = proto_base.EncodeVarInt(w, PlayToClientChatTypesHolderKnownType)
		if err != nil {
			return
		}
	case PlayToClientChatTypes:
		err = proto_base.EncodeVarInt(w, 0)
		if err != nil {
			return
		}
		err = PlayToClientChatTypesHolderKnownType.Encode(w)
		if err != nil {
			return
		}
	default:
		err = proto_base.BadTypeError
	}
	return
}

type PlayToClientExplosionParticleEntry struct {
	Data   PlayToClientExplosionParticleInfo
	Weight int32
}

func (ret *PlayToClientExplosionParticleEntry) Decode(r io.Reader) (err error) {
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	ret.Weight, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientExplosionParticleEntry) Encode(w io.Writer) (err error) {
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Weight)
	if err != nil {
		return
	}
	return
}

type PlayToClientExplosionParticleInfo struct {
	Particle Particle
	Scaling  float32
	Speed    float32
}

func (ret *PlayToClientExplosionParticleInfo) Decode(r io.Reader) (err error) {
	err = ret.Particle.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Scaling)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Speed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientExplosionParticleInfo) Encode(w io.Writer) (err error) {
	err = ret.Particle.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Scaling)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Speed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPositionUpdateRelatives struct {
	Val uint32
}

func (ret *PlayToClientPositionUpdateRelatives) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Val)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPositionUpdateRelatives) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Val)
	if err != nil {
		return
	}
	return
}

type PlayToClientRecipeBookSetting struct {
	Open      bool
	Filtering bool
}

func (ret *PlayToClientRecipeBookSetting) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Open)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Filtering)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientRecipeBookSetting) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Open)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Filtering)
	if err != nil {
		return
	}
	return
}

type PlayToClientRecipeDisplay struct {
	Type string
	Data any
}

var PlayToClientRecipeDisplayTypeMap = map[int32]string{0: "crafting_shapeless", 1: "crafting_shaped", 2: "furnace", 3: "stonecutter", 4: "smithing"}

func (ret *PlayToClientRecipeDisplay) Decode(r io.Reader) (err error) {
	var PlayToClientRecipeDisplayTypeKey int32
	PlayToClientRecipeDisplayTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeMap, PlayToClientRecipeDisplayTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "crafting_shaped":
		var PlayToClientRecipeDisplayDataCraftingShapedTmp struct {
			Width           int32
			Height          int32
			Ingredients     []PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		}
		PlayToClientRecipeDisplayDataCraftingShapedTmp.Width, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientRecipeDisplayDataCraftingShapedTmp.Height, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		var lPlayToClientRecipeDisplayDataIngredients int32
		lPlayToClientRecipeDisplayDataIngredients, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = []PlayToClientSlotDisplay{}
		for range lPlayToClientRecipeDisplayDataIngredients {
			var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay
			err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r)
			if err != nil {
				return
			}
			PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement)
		}
		err = PlayToClientRecipeDisplayDataCraftingShapedTmp.Result.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataCraftingShapedTmp.CraftingStation.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientRecipeDisplayDataCraftingShapedTmp
	case "crafting_shapeless":
		var PlayToClientRecipeDisplayDataCraftingShapelessTmp struct {
			Ingredients     []PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		}
		var lPlayToClientRecipeDisplayDataIngredients int32
		lPlayToClientRecipeDisplayDataIngredients, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = []PlayToClientSlotDisplay{}
		for range lPlayToClientRecipeDisplayDataIngredients {
			var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay
			err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r)
			if err != nil {
				return
			}
			PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement)
		}
		err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.Result.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.CraftingStation.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientRecipeDisplayDataCraftingShapelessTmp
	case "furnace":
		var PlayToClientRecipeDisplayDataFurnaceTmp struct {
			Ingredient      PlayToClientSlotDisplay
			Fuel            PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
			Duration        int32
			Experience      float32
		}
		err = PlayToClientRecipeDisplayDataFurnaceTmp.Ingredient.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataFurnaceTmp.Fuel.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataFurnaceTmp.Result.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataFurnaceTmp.CraftingStation.Decode(r)
		if err != nil {
			return
		}
		PlayToClientRecipeDisplayDataFurnaceTmp.Duration, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientRecipeDisplayDataFurnaceTmp.Experience)
		if err != nil {
			return
		}
		ret.Data = PlayToClientRecipeDisplayDataFurnaceTmp
	case "smithing":
		var PlayToClientRecipeDisplayDataSmithingTmp struct {
			Template        PlayToClientSlotDisplay
			Base            PlayToClientSlotDisplay
			Addition        PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		}
		err = PlayToClientRecipeDisplayDataSmithingTmp.Template.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataSmithingTmp.Base.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataSmithingTmp.Addition.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataSmithingTmp.Result.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataSmithingTmp.CraftingStation.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientRecipeDisplayDataSmithingTmp
	case "stonecutter":
		var PlayToClientRecipeDisplayDataStonecutterTmp struct {
			Ingredient      PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		}
		err = PlayToClientRecipeDisplayDataStonecutterTmp.Ingredient.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataStonecutterTmp.Result.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayDataStonecutterTmp.CraftingStation.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientRecipeDisplayDataStonecutterTmp
	}
	return
}

var PlayToClientRecipeDisplayTypeReverseMap = map[string]int32{"crafting_shapeless": 0, "crafting_shaped": 1, "furnace": 2, "stonecutter": 3, "smithing": 4}

func (ret *PlayToClientRecipeDisplay) Encode(w io.Writer) (err error) {
	var vPlayToClientRecipeDisplayType int32
	vPlayToClientRecipeDisplayType, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientRecipeDisplayType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "crafting_shaped":
		PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
			Width           int32
			Height          int32
			Ingredients     []PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Width)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Height)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients)))
		if err != nil {
			return
		}
		for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) {
			err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w)
			if err != nil {
				return
			}
		}
		err = PlayToClientRecipeDisplayData.Result.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
		if err != nil {
			return
		}
	case "crafting_shapeless":
		PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
			Ingredients     []PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients)))
		if err != nil {
			return
		}
		for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) {
			err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w)
			if err != nil {
				return
			}
		}
		err = PlayToClientRecipeDisplayData.Result.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
		if err != nil {
			return
		}
	case "furnace":
		PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
			Ingredient      PlayToClientSlotDisplay
			Fuel            PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
			Duration        int32
			Experience      float32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientRecipeDisplayData.Ingredient.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Fuel.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Result.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Duration)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientRecipeDisplayData.Experience)
		if err != nil {
			return
		}
	case "smithing":
		PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
			Template        PlayToClientSlotDisplay
			Base            PlayToClientSlotDisplay
			Addition        PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientRecipeDisplayData.Template.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Base.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Addition.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Result.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
		if err != nil {
			return
		}
	case "stonecutter":
		PlayToClientRecipeDisplayData, ok := ret.Data.(struct {
			Ingredient      PlayToClientSlotDisplay
			Result          PlayToClientSlotDisplay
			CraftingStation PlayToClientSlotDisplay
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientRecipeDisplayData.Ingredient.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.Result.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientSlotDisplay struct {
	Type string
	Data any
}

var PlayToClientSlotDisplayTypeMap = map[int32]string{0: "empty", 1: "any_fuel", 2: "item", 3: "item_stack", 4: "tag", 5: "smithing_trim", 6: "with_remainder", 7: "composite"}

func (ret *PlayToClientSlotDisplay) Decode(r io.Reader) (err error) {
	var PlayToClientSlotDisplayTypeKey int32
	PlayToClientSlotDisplayTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeMap, PlayToClientSlotDisplayTypeKey)
	if err != nil {
		return
	}
	switch ret.Type {
	case "any_fuel":
		var PlayToClientSlotDisplayDataAnyFuelTmp struct {
		}
		ret.Data = PlayToClientSlotDisplayDataAnyFuelTmp
	case "composite":
		var PlayToClientSlotDisplayDataCompositeTmp []PlayToClientSlotDisplay
		var lPlayToClientSlotDisplayData int32
		lPlayToClientSlotDisplayData, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientSlotDisplayDataCompositeTmp = []PlayToClientSlotDisplay{}
		for range lPlayToClientSlotDisplayData {
			var PlayToClientSlotDisplayDataElement PlayToClientSlotDisplay
			err = PlayToClientSlotDisplayDataElement.Decode(r)
			if err != nil {
				return
			}
			PlayToClientSlotDisplayDataCompositeTmp = append(PlayToClientSlotDisplayDataCompositeTmp, PlayToClientSlotDisplayDataElement)
		}
		ret.Data = PlayToClientSlotDisplayDataCompositeTmp
	case "empty":
		var PlayToClientSlotDisplayDataEmptyTmp struct {
		}
		ret.Data = PlayToClientSlotDisplayDataEmptyTmp
	case "item":
		var PlayToClientSlotDisplayDataItemTmp int32
		PlayToClientSlotDisplayDataItemTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientSlotDisplayDataItemTmp
	case "item_stack":
		var PlayToClientSlotDisplayDataItemStackTmp Slot
		err = PlayToClientSlotDisplayDataItemStackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientSlotDisplayDataItemStackTmp
	case "smithing_trim":
		var PlayToClientSlotDisplayDataSmithingTrimTmp struct {
			Base     PlayToClientSlotDisplay
			Material PlayToClientSlotDisplay
			Pattern  any
		}
		err = PlayToClientSlotDisplayDataSmithingTrimTmp.Base.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientSlotDisplayDataSmithingTrimTmp.Material.Decode(r)
		if err != nil {
			return
		}
		var PlayToClientSlotDisplayDataPatternId int32
		PlayToClientSlotDisplayDataPatternId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		if PlayToClientSlotDisplayDataPatternId != 0 {
			PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataPatternId
		} else {
			var PlayToClientSlotDisplayDataPatternResult ArmorTrimPattern
			err = PlayToClientSlotDisplayDataPatternResult.Decode(r)
			if err != nil {
				return
			}
			PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataPatternResult
		}
		ret.Data = PlayToClientSlotDisplayDataSmithingTrimTmp
	case "tag":
		var PlayToClientSlotDisplayDataTagTmp string
		PlayToClientSlotDisplayDataTagTmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientSlotDisplayDataTagTmp
	case "with_remainder":
		var PlayToClientSlotDisplayDataWithRemainderTmp struct {
			Input     PlayToClientSlotDisplay
			Remainder PlayToClientSlotDisplay
		}
		err = PlayToClientSlotDisplayDataWithRemainderTmp.Input.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientSlotDisplayDataWithRemainderTmp.Remainder.Decode(r)
		if err != nil {
			return
		}
		ret.Data = PlayToClientSlotDisplayDataWithRemainderTmp
	}
	return
}

var PlayToClientSlotDisplayTypeReverseMap = map[string]int32{"empty": 0, "any_fuel": 1, "item": 2, "item_stack": 3, "tag": 4, "smithing_trim": 5, "with_remainder": 6, "composite": 7}

func (ret *PlayToClientSlotDisplay) Encode(w io.Writer) (err error) {
	var vPlayToClientSlotDisplayType int32
	vPlayToClientSlotDisplayType, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeReverseMap, ret.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientSlotDisplayType)
	if err != nil {
		return
	}
	switch ret.Type {
	case "any_fuel":
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case "composite":
		PlayToClientSlotDisplayData, ok := ret.Data.([]PlayToClientSlotDisplay)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientSlotDisplayData)))
		if err != nil {
			return
		}
		for iPlayToClientSlotDisplayData := range len(PlayToClientSlotDisplayData) {
			err = PlayToClientSlotDisplayData[iPlayToClientSlotDisplayData].Encode(w)
			if err != nil {
				return
			}
		}
	case "empty":
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case "item":
		PlayToClientSlotDisplayData, ok := ret.Data.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayData)
		if err != nil {
			return
		}
	case "item_stack":
		PlayToClientSlotDisplayData, ok := ret.Data.(Slot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientSlotDisplayData.Encode(w)
		if err != nil {
			return
		}
	case "smithing_trim":
		PlayToClientSlotDisplayData, ok := ret.Data.(struct {
			Base     PlayToClientSlotDisplay
			Material PlayToClientSlotDisplay
			Pattern  any
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientSlotDisplayData.Base.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientSlotDisplayData.Material.Encode(w)
		if err != nil {
			return
		}
		switch PlayToClientSlotDisplayDataPatternKnownType := PlayToClientSlotDisplayData.Pattern.(type) {
		case int32:
			err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayDataPatternKnownType)
			if err != nil {
				return
			}
		case ArmorTrimPattern:
			err = proto_base.EncodeVarInt(w, 0)
			if err != nil {
				return
			}
			err = PlayToClientSlotDisplayDataPatternKnownType.Encode(w)
			if err != nil {
				return
			}
		default:
			err = proto_base.BadTypeError
		}
	case "tag":
		PlayToClientSlotDisplayData, ok := ret.Data.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientSlotDisplayData)
		if err != nil {
			return
		}
	case "with_remainder":
		PlayToClientSlotDisplayData, ok := ret.Data.(struct {
			Input     PlayToClientSlotDisplay
			Remainder PlayToClientSlotDisplay
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientSlotDisplayData.Input.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientSlotDisplayData.Remainder.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientSpawnInfo struct {
	Dimension        int32
	Name             string
	HashedSeed       int64
	Gamemode         string
	PreviousGamemode uint8
	IsDebug          bool
	IsFlat           bool
	Death            *GlobalPos
	PortalCooldown   int32
	SeaLevel         int32
}

var PlayToClientSpawnInfoGamemodeMap = map[int8]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"}

func (ret *PlayToClientSpawnInfo) Decode(r io.Reader) (err error) {
	ret.Dimension, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HashedSeed)
	if err != nil {
		return
	}
	var PlayToClientSpawnInfoGamemodeKey int8
	err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoGamemodeKey)
	if err != nil {
		return
	}
	ret.Gamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeMap, PlayToClientSpawnInfoGamemodeKey)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.PreviousGamemode)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFlat)
	if err != nil {
		return
	}
	var PlayToClientSpawnInfoDeathPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoDeathPresent)
	if err != nil {
		return
	}
	if PlayToClientSpawnInfoDeathPresent {
		var PlayToClientSpawnInfoDeathPresentValue GlobalPos
		err = PlayToClientSpawnInfoDeathPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Death = &PlayToClientSpawnInfoDeathPresentValue
	}
	ret.PortalCooldown, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SeaLevel, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}

var PlayToClientSpawnInfoGamemodeReverseMap = map[string]int8{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3}

func (ret *PlayToClientSpawnInfo) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Dimension)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HashedSeed)
	if err != nil {
		return
	}
	var vPlayToClientSpawnInfoGamemode int8
	vPlayToClientSpawnInfoGamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeReverseMap, ret.Gamemode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, vPlayToClientSpawnInfoGamemode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PreviousGamemode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsDebug)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFlat)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Death != nil)
	if err != nil {
		return
	}
	if ret.Death != nil {
		err = (*ret.Death).Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.PortalCooldown)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SeaLevel)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacket struct {
	Name   string
	Params any
}

var PlayToClientPacketNameMap = map[int32]string{0x00: "bundle_delimiter", 0x01: "spawn_entity", 0x02: "animation", 0x03: "statistics", 0x04: "acknowledge_player_digging", 0x05: "block_break_animation", 0x06: "tile_entity_data", 0x07: "block_action", 0x08: "block_change", 0x09: "boss_bar", 0x0a: "difficulty", 0x0b: "chunk_batch_finished", 0x0c: "chunk_batch_start", 0x0d: "chunk_biomes", 0x0e: "clear_titles", 0x0f: "tab_complete", 0x10: "declare_commands", 0x11: "close_window", 0x12: "window_items", 0x13: "craft_progress_bar", 0x14: "set_slot", 0x15: "cookie_request", 0x16: "set_cooldown", 0x17: "chat_suggestions", 0x18: "custom_payload", 0x19: "damage_event", 0x1a: "debug_block_value", 0x1b: "debug_chunk_value", 0x1c: "debug_entity_value", 0x1d: "debug_event", 0x1e: "debug_sample", 0x1f: "hide_message", 0x20: "kick_disconnect", 0x21: "profileless_chat", 0x22: "entity_status", 0x23: "sync_entity_position", 0x24: "explosion", 0x25: "unload_chunk", 0x26: "game_state_change", 0x27: "game_test_highlight_pos", 0x28: "open_horse_window", 0x29: "hurt_animation", 0x2a: "initialize_world_border", 0x2b: "keep_alive", 0x2c: "map_chunk", 0x2d: "world_event", 0x2e: "world_particles", 0x2f: "update_light", 0x30: "login", 0x31: "map", 0x32: "trade_list", 0x33: "rel_entity_move", 0x34: "entity_move_look", 0x35: "move_minecart", 0x36: "entity_look", 0x37: "vehicle_move", 0x38: "open_book", 0x39: "open_window", 0x3a: "open_sign_entity", 0x3b: "ping", 0x3c: "ping_response", 0x3d: "craft_recipe_response", 0x3e: "abilities", 0x3f: "player_chat", 0x40: "end_combat_event", 0x41: "enter_combat_event", 0x42: "death_combat_event", 0x43: "player_remove", 0x44: "player_info", 0x45: "face_player", 0x46: "position", 0x47: "player_rotation", 0x48: "recipe_book_add", 0x49: "recipe_book_remove", 0x4a: "recipe_book_settings", 0x4b: "entity_destroy", 0x4c: "remove_entity_effect", 0x4d: "reset_score", 0x4e: "remove_resource_pack", 0x4f: "add_resource_pack", 0x50: "respawn", 0x51: "entity_head_rotation", 0x52: "multi_block_change", 0x53: "select_advancement_tab", 0x54: "server_data", 0x55: "action_bar", 0x56: "world_border_center", 0x57: "world_border_lerp_size", 0x58: "world_border_size", 0x59: "world_border_warning_delay", 0x5a: "world_border_warning_reach", 0x5b: "camera", 0x5c: "update_view_position", 0x5d: "update_view_distance", 0x5e: "set_cursor_item", 0x5f: "spawn_position", 0x60: "scoreboard_display_objective", 0x61: "entity_metadata", 0x62: "attach_entity", 0x63: "entity_velocity", 0x64: "entity_equipment", 0x65: "experience", 0x66: "update_health", 0x67: "held_item_slot", 0x68: "scoreboard_objective", 0x69: "set_passengers", 0x6a: "set_player_inventory", 0x6b: "teams", 0x6c: "scoreboard_score", 0x6d: "simulation_distance", 0x6e: "set_title_subtitle", 0x6f: "update_time", 0x70: "set_title_text", 0x71: "set_title_time", 0x72: "entity_sound_effect", 0x73: "sound_effect", 0x74: "start_configuration", 0x75: "stop_sound", 0x76: "store_cookie", 0x77: "system_chat", 0x78: "playerlist_header", 0x79: "nbt_query_response", 0x7a: "collect", 0x7b: "entity_teleport", 0x7c: "test_instance_block_status", 0x7d: "set_ticking_state", 0x7e: "step_tick", 0x7f: "transfer", 0x80: "advancements", 0x81: "entity_update_attributes", 0x82: "entity_effect", 0x83: "declare_recipes", 0x84: "tags", 0x85: "set_projectile_power", 0x86: "custom_report_details", 0x87: "server_links", 0x88: "tracked_waypoint", 0x89: "clear_dialog", 0x8a: "show_dialog"}

func (ret *PlayToClientPacket) Decode(r io.Reader) (err error) {
	var PlayToClientPacketNameKey int32
	PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities
		err = PlayToClientPacketParamsAbilitiesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAbilitiesTmp
	case "acknowledge_player_digging":
		var PlayToClientPacketParamsAcknowledgePlayerDiggingTmp PlayToClientPacketAcknowledgePlayerDigging
		err = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp
	case "action_bar":
		var PlayToClientPacketParamsActionBarTmp PlayToClientPacketActionBar
		err = PlayToClientPacketParamsActionBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsActionBarTmp
	case "add_resource_pack":
		var PlayToClientPacketParamsAddResourcePackTmp PlayToClientPacketCommonAddResourcePack
		err = PlayToClientPacketParamsAddResourcePackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAddResourcePackTmp
	case "advancements":
		var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements
		err = PlayToClientPacketParamsAdvancementsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAdvancementsTmp
	case "animation":
		var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation
		err = PlayToClientPacketParamsAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAnimationTmp
	case "attach_entity":
		var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity
		err = PlayToClientPacketParamsAttachEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsAttachEntityTmp
	case "block_action":
		var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction
		err = PlayToClientPacketParamsBlockActionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockActionTmp
	case "block_break_animation":
		var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation
		err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp
	case "block_change":
		var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange
		err = PlayToClientPacketParamsBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBlockChangeTmp
	case "boss_bar":
		var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar
		err = PlayToClientPacketParamsBossBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsBossBarTmp
	case "bundle_delimiter":
		var PlayToClientPacketParamsBundleDelimiterTmp struct {
		}
		ret.Params = PlayToClientPacketParamsBundleDelimiterTmp
	case "camera":
		var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera
		err = PlayToClientPacketParamsCameraTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCameraTmp
	case "chat_suggestions":
		var PlayToClientPacketParamsChatSuggestionsTmp PlayToClientPacketChatSuggestions
		err = PlayToClientPacketParamsChatSuggestionsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChatSuggestionsTmp
	case "chunk_batch_finished":
		var PlayToClientPacketParamsChunkBatchFinishedTmp PlayToClientPacketChunkBatchFinished
		err = PlayToClientPacketParamsChunkBatchFinishedTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChunkBatchFinishedTmp
	case "chunk_batch_start":
		var PlayToClientPacketParamsChunkBatchStartTmp PlayToClientPacketChunkBatchStart
		err = PlayToClientPacketParamsChunkBatchStartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChunkBatchStartTmp
	case "chunk_biomes":
		var PlayToClientPacketParamsChunkBiomesTmp PlayToClientPacketChunkBiomes
		err = PlayToClientPacketParamsChunkBiomesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsChunkBiomesTmp
	case "clear_dialog":
		var PlayToClientPacketParamsClearDialogTmp PlayToClientPacketCommonClearDialog
		err = PlayToClientPacketParamsClearDialogTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsClearDialogTmp
	case "clear_titles":
		var PlayToClientPacketParamsClearTitlesTmp PlayToClientPacketClearTitles
		err = PlayToClientPacketParamsClearTitlesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsClearTitlesTmp
	case "close_window":
		var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow
		err = PlayToClientPacketParamsCloseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCloseWindowTmp
	case "collect":
		var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect
		err = PlayToClientPacketParamsCollectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCollectTmp
	case "cookie_request":
		var PlayToClientPacketParamsCookieRequestTmp PlayToClientPacketCommonCookieRequest
		err = PlayToClientPacketParamsCookieRequestTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCookieRequestTmp
	case "craft_progress_bar":
		var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar
		err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCraftProgressBarTmp
	case "craft_recipe_response":
		var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse
		err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp
	case "custom_payload":
		var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload
		err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCustomPayloadTmp
	case "custom_report_details":
		var PlayToClientPacketParamsCustomReportDetailsTmp PlayToClientPacketCommonCustomReportDetails
		err = PlayToClientPacketParamsCustomReportDetailsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsCustomReportDetailsTmp
	case "damage_event":
		var PlayToClientPacketParamsDamageEventTmp PlayToClientPacketDamageEvent
		err = PlayToClientPacketParamsDamageEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDamageEventTmp
	case "death_combat_event":
		var PlayToClientPacketParamsDeathCombatEventTmp PlayToClientPacketDeathCombatEvent
		err = PlayToClientPacketParamsDeathCombatEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDeathCombatEventTmp
	case "debug_block_value":
		var PlayToClientPacketParamsDebugBlockValueTmp PlayToClientPacketDebugBlockValue
		err = PlayToClientPacketParamsDebugBlockValueTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDebugBlockValueTmp
	case "debug_chunk_value":
		var PlayToClientPacketParamsDebugChunkValueTmp PlayToClientPacketDebugChunkValue
		err = PlayToClientPacketParamsDebugChunkValueTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDebugChunkValueTmp
	case "debug_entity_value":
		var PlayToClientPacketParamsDebugEntityValueTmp PlayToClientPacketDebugEntityValue
		err = PlayToClientPacketParamsDebugEntityValueTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDebugEntityValueTmp
	case "debug_event":
		var PlayToClientPacketParamsDebugEventTmp PlayToClientPacketDebugEvent
		err = PlayToClientPacketParamsDebugEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDebugEventTmp
	case "debug_sample":
		var PlayToClientPacketParamsDebugSampleTmp PlayToClientPacketDebugSample
		err = PlayToClientPacketParamsDebugSampleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDebugSampleTmp
	case "declare_commands":
		var PlayToClientPacketParamsDeclareCommandsTmp PlayToClientPacketDeclareCommands
		err = PlayToClientPacketParamsDeclareCommandsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDeclareCommandsTmp
	case "declare_recipes":
		var PlayToClientPacketParamsDeclareRecipesTmp PlayToClientPacketDeclareRecipes
		err = PlayToClientPacketParamsDeclareRecipesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDeclareRecipesTmp
	case "difficulty":
		var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty
		err = PlayToClientPacketParamsDifficultyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsDifficultyTmp
	case "end_combat_event":
		var PlayToClientPacketParamsEndCombatEventTmp PlayToClientPacketEndCombatEvent
		err = PlayToClientPacketParamsEndCombatEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEndCombatEventTmp
	case "enter_combat_event":
		var PlayToClientPacketParamsEnterCombatEventTmp PlayToClientPacketEnterCombatEvent
		err = PlayToClientPacketParamsEnterCombatEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEnterCombatEventTmp
	case "entity_destroy":
		var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy
		err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityDestroyTmp
	case "entity_effect":
		var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect
		err = PlayToClientPacketParamsEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEffectTmp
	case "entity_equipment":
		var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment
		err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityEquipmentTmp
	case "entity_head_rotation":
		var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation
		err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp
	case "entity_look":
		var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook
		err = PlayToClientPacketParamsEntityLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityLookTmp
	case "entity_metadata":
		var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata
		err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMetadataTmp
	case "entity_move_look":
		var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook
		err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityMoveLookTmp
	case "entity_sound_effect":
		var PlayToClientPacketParamsEntitySoundEffectTmp PlayToClientPacketEntitySoundEffect
		err = PlayToClientPacketParamsEntitySoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntitySoundEffectTmp
	case "entity_status":
		var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus
		err = PlayToClientPacketParamsEntityStatusTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityStatusTmp
	case "entity_teleport":
		var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport
		err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityTeleportTmp
	case "entity_update_attributes":
		var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes
		err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp
	case "entity_velocity":
		var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity
		err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsEntityVelocityTmp
	case "experience":
		var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience
		err = PlayToClientPacketParamsExperienceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExperienceTmp
	case "explosion":
		var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion
		err = PlayToClientPacketParamsExplosionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsExplosionTmp
	case "face_player":
		var PlayToClientPacketParamsFacePlayerTmp PlayToClientPacketFacePlayer
		err = PlayToClientPacketParamsFacePlayerTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsFacePlayerTmp
	case "game_state_change":
		var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange
		err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsGameStateChangeTmp
	case "game_test_highlight_pos":
		var PlayToClientPacketParamsGameTestHighlightPosTmp PlayToClientPacketGameTestHighlightPos
		err = PlayToClientPacketParamsGameTestHighlightPosTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsGameTestHighlightPosTmp
	case "held_item_slot":
		var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot
		err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsHeldItemSlotTmp
	case "hide_message":
		var PlayToClientPacketParamsHideMessageTmp PlayToClientPacketHideMessage
		err = PlayToClientPacketParamsHideMessageTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsHideMessageTmp
	case "hurt_animation":
		var PlayToClientPacketParamsHurtAnimationTmp PlayToClientPacketHurtAnimation
		err = PlayToClientPacketParamsHurtAnimationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsHurtAnimationTmp
	case "initialize_world_border":
		var PlayToClientPacketParamsInitializeWorldBorderTmp PlayToClientPacketInitializeWorldBorder
		err = PlayToClientPacketParamsInitializeWorldBorderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsInitializeWorldBorderTmp
	case "keep_alive":
		var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive
		err = PlayToClientPacketParamsKeepAliveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKeepAliveTmp
	case "kick_disconnect":
		var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect
		err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsKickDisconnectTmp
	case "login":
		var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin
		err = PlayToClientPacketParamsLoginTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsLoginTmp
	case "map":
		var PlayToClientPacketParamsMapTmp PlayToClientPacketMap
		err = PlayToClientPacketParamsMapTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapTmp
	case "map_chunk":
		var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk
		err = PlayToClientPacketParamsMapChunkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMapChunkTmp
	case "move_minecart":
		var PlayToClientPacketParamsMoveMinecartTmp PlayToClientPacketMoveMinecart
		err = PlayToClientPacketParamsMoveMinecartTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMoveMinecartTmp
	case "multi_block_change":
		var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange
		err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp
	case "nbt_query_response":
		var PlayToClientPacketParamsNbtQueryResponseTmp PlayToClientPacketNbtQueryResponse
		err = PlayToClientPacketParamsNbtQueryResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsNbtQueryResponseTmp
	case "open_book":
		var PlayToClientPacketParamsOpenBookTmp PlayToClientPacketOpenBook
		err = PlayToClientPacketParamsOpenBookTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenBookTmp
	case "open_horse_window":
		var PlayToClientPacketParamsOpenHorseWindowTmp PlayToClientPacketOpenHorseWindow
		err = PlayToClientPacketParamsOpenHorseWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenHorseWindowTmp
	case "open_sign_entity":
		var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity
		err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenSignEntityTmp
	case "open_window":
		var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow
		err = PlayToClientPacketParamsOpenWindowTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsOpenWindowTmp
	case "ping":
		var PlayToClientPacketParamsPingTmp PlayToClientPacketPing
		err = PlayToClientPacketParamsPingTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPingTmp
	case "ping_response":
		var PlayToClientPacketParamsPingResponseTmp PlayToClientPacketPingResponse
		err = PlayToClientPacketParamsPingResponseTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPingResponseTmp
	case "player_chat":
		var PlayToClientPacketParamsPlayerChatTmp PlayToClientPacketPlayerChat
		err = PlayToClientPacketParamsPlayerChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerChatTmp
	case "player_info":
		var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo
		err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerInfoTmp
	case "player_remove":
		var PlayToClientPacketParamsPlayerRemoveTmp PlayToClientPacketPlayerRemove
		err = PlayToClientPacketParamsPlayerRemoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerRemoveTmp
	case "player_rotation":
		var PlayToClientPacketParamsPlayerRotationTmp PlayToClientPacketPlayerRotation
		err = PlayToClientPacketParamsPlayerRotationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerRotationTmp
	case "playerlist_header":
		var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader
		err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp
	case "position":
		var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition
		err = PlayToClientPacketParamsPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsPositionTmp
	case "profileless_chat":
		var PlayToClientPacketParamsProfilelessChatTmp PlayToClientPacketProfilelessChat
		err = PlayToClientPacketParamsProfilelessChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsProfilelessChatTmp
	case "recipe_book_add":
		var PlayToClientPacketParamsRecipeBookAddTmp PlayToClientPacketRecipeBookAdd
		err = PlayToClientPacketParamsRecipeBookAddTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRecipeBookAddTmp
	case "recipe_book_remove":
		var PlayToClientPacketParamsRecipeBookRemoveTmp PlayToClientPacketRecipeBookRemove
		err = PlayToClientPacketParamsRecipeBookRemoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRecipeBookRemoveTmp
	case "recipe_book_settings":
		var PlayToClientPacketParamsRecipeBookSettingsTmp PlayToClientPacketRecipeBookSettings
		err = PlayToClientPacketParamsRecipeBookSettingsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRecipeBookSettingsTmp
	case "rel_entity_move":
		var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove
		err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRelEntityMoveTmp
	case "remove_entity_effect":
		var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect
		err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp
	case "remove_resource_pack":
		var PlayToClientPacketParamsRemoveResourcePackTmp PlayToClientPacketCommonRemoveResourcePack
		err = PlayToClientPacketParamsRemoveResourcePackTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRemoveResourcePackTmp
	case "reset_score":
		var PlayToClientPacketParamsResetScoreTmp PlayToClientPacketResetScore
		err = PlayToClientPacketParamsResetScoreTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsResetScoreTmp
	case "respawn":
		var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn
		err = PlayToClientPacketParamsRespawnTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsRespawnTmp
	case "scoreboard_display_objective":
		var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective
		err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp
	case "scoreboard_objective":
		var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective
		err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp
	case "scoreboard_score":
		var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore
		err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsScoreboardScoreTmp
	case "select_advancement_tab":
		var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab
		err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp
	case "server_data":
		var PlayToClientPacketParamsServerDataTmp PlayToClientPacketServerData
		err = PlayToClientPacketParamsServerDataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsServerDataTmp
	case "server_links":
		var PlayToClientPacketParamsServerLinksTmp PlayToClientPacketCommonServerLinks
		err = PlayToClientPacketParamsServerLinksTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsServerLinksTmp
	case "set_cooldown":
		var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown
		err = PlayToClientPacketParamsSetCooldownTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetCooldownTmp
	case "set_cursor_item":
		var PlayToClientPacketParamsSetCursorItemTmp PlayToClientPacketSetCursorItem
		err = PlayToClientPacketParamsSetCursorItemTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetCursorItemTmp
	case "set_passengers":
		var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers
		err = PlayToClientPacketParamsSetPassengersTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetPassengersTmp
	case "set_player_inventory":
		var PlayToClientPacketParamsSetPlayerInventoryTmp PlayToClientPacketSetPlayerInventory
		err = PlayToClientPacketParamsSetPlayerInventoryTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetPlayerInventoryTmp
	case "set_projectile_power":
		var PlayToClientPacketParamsSetProjectilePowerTmp PlayToClientPacketSetProjectilePower
		err = PlayToClientPacketParamsSetProjectilePowerTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetProjectilePowerTmp
	case "set_slot":
		var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot
		err = PlayToClientPacketParamsSetSlotTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetSlotTmp
	case "set_ticking_state":
		var PlayToClientPacketParamsSetTickingStateTmp PlayToClientPacketSetTickingState
		err = PlayToClientPacketParamsSetTickingStateTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetTickingStateTmp
	case "set_title_subtitle":
		var PlayToClientPacketParamsSetTitleSubtitleTmp PlayToClientPacketSetTitleSubtitle
		err = PlayToClientPacketParamsSetTitleSubtitleTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetTitleSubtitleTmp
	case "set_title_text":
		var PlayToClientPacketParamsSetTitleTextTmp PlayToClientPacketSetTitleText
		err = PlayToClientPacketParamsSetTitleTextTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetTitleTextTmp
	case "set_title_time":
		var PlayToClientPacketParamsSetTitleTimeTmp PlayToClientPacketSetTitleTime
		err = PlayToClientPacketParamsSetTitleTimeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSetTitleTimeTmp
	case "show_dialog":
		var PlayToClientPacketParamsShowDialogTmp PlayToClientPacketShowDialog
		err = PlayToClientPacketParamsShowDialogTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsShowDialogTmp
	case "simulation_distance":
		var PlayToClientPacketParamsSimulationDistanceTmp PlayToClientPacketSimulationDistance
		err = PlayToClientPacketParamsSimulationDistanceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSimulationDistanceTmp
	case "sound_effect":
		var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect
		err = PlayToClientPacketParamsSoundEffectTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSoundEffectTmp
	case "spawn_entity":
		var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity
		err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnEntityTmp
	case "spawn_position":
		var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition
		err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSpawnPositionTmp
	case "start_configuration":
		var PlayToClientPacketParamsStartConfigurationTmp PlayToClientPacketStartConfiguration
		err = PlayToClientPacketParamsStartConfigurationTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStartConfigurationTmp
	case "statistics":
		var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics
		err = PlayToClientPacketParamsStatisticsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStatisticsTmp
	case "step_tick":
		var PlayToClientPacketParamsStepTickTmp PlayToClientPacketStepTick
		err = PlayToClientPacketParamsStepTickTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStepTickTmp
	case "stop_sound":
		var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound
		err = PlayToClientPacketParamsStopSoundTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStopSoundTmp
	case "store_cookie":
		var PlayToClientPacketParamsStoreCookieTmp PlayToClientPacketCommonStoreCookie
		err = PlayToClientPacketParamsStoreCookieTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsStoreCookieTmp
	case "sync_entity_position":
		var PlayToClientPacketParamsSyncEntityPositionTmp PlayToClientPacketSyncEntityPosition
		err = PlayToClientPacketParamsSyncEntityPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSyncEntityPositionTmp
	case "system_chat":
		var PlayToClientPacketParamsSystemChatTmp PlayToClientPacketSystemChat
		err = PlayToClientPacketParamsSystemChatTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsSystemChatTmp
	case "tab_complete":
		var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete
		err = PlayToClientPacketParamsTabCompleteTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTabCompleteTmp
	case "tags":
		var PlayToClientPacketParamsTagsTmp PlayToClientPacketTags
		err = PlayToClientPacketParamsTagsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTagsTmp
	case "teams":
		var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams
		err = PlayToClientPacketParamsTeamsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTeamsTmp
	case "test_instance_block_status":
		var PlayToClientPacketParamsTestInstanceBlockStatusTmp PlayToClientPacketTestInstanceBlockStatus
		err = PlayToClientPacketParamsTestInstanceBlockStatusTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTestInstanceBlockStatusTmp
	case "tile_entity_data":
		var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData
		err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTileEntityDataTmp
	case "tracked_waypoint":
		var PlayToClientPacketParamsTrackedWaypointTmp PlayToClientPacketTrackedWaypoint
		err = PlayToClientPacketParamsTrackedWaypointTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTrackedWaypointTmp
	case "trade_list":
		var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList
		err = PlayToClientPacketParamsTradeListTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTradeListTmp
	case "transfer":
		var PlayToClientPacketParamsTransferTmp PlayToClientPacketCommonTransfer
		err = PlayToClientPacketParamsTransferTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsTransferTmp
	case "unload_chunk":
		var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk
		err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUnloadChunkTmp
	case "update_health":
		var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth
		err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateHealthTmp
	case "update_light":
		var PlayToClientPacketParamsUpdateLightTmp PlayToClientPacketUpdateLight
		err = PlayToClientPacketParamsUpdateLightTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateLightTmp
	case "update_time":
		var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime
		err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateTimeTmp
	case "update_view_distance":
		var PlayToClientPacketParamsUpdateViewDistanceTmp PlayToClientPacketUpdateViewDistance
		err = PlayToClientPacketParamsUpdateViewDistanceTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateViewDistanceTmp
	case "update_view_position":
		var PlayToClientPacketParamsUpdateViewPositionTmp PlayToClientPacketUpdateViewPosition
		err = PlayToClientPacketParamsUpdateViewPositionTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsUpdateViewPositionTmp
	case "vehicle_move":
		var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove
		err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsVehicleMoveTmp
	case "window_items":
		var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems
		err = PlayToClientPacketParamsWindowItemsTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWindowItemsTmp
	case "world_border_center":
		var PlayToClientPacketParamsWorldBorderCenterTmp PlayToClientPacketWorldBorderCenter
		err = PlayToClientPacketParamsWorldBorderCenterTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderCenterTmp
	case "world_border_lerp_size":
		var PlayToClientPacketParamsWorldBorderLerpSizeTmp PlayToClientPacketWorldBorderLerpSize
		err = PlayToClientPacketParamsWorldBorderLerpSizeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderLerpSizeTmp
	case "world_border_size":
		var PlayToClientPacketParamsWorldBorderSizeTmp PlayToClientPacketWorldBorderSize
		err = PlayToClientPacketParamsWorldBorderSizeTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderSizeTmp
	case "world_border_warning_delay":
		var PlayToClientPacketParamsWorldBorderWarningDelayTmp PlayToClientPacketWorldBorderWarningDelay
		err = PlayToClientPacketParamsWorldBorderWarningDelayTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderWarningDelayTmp
	case "world_border_warning_reach":
		var PlayToClientPacketParamsWorldBorderWarningReachTmp PlayToClientPacketWorldBorderWarningReach
		err = PlayToClientPacketParamsWorldBorderWarningReachTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldBorderWarningReachTmp
	case "world_event":
		var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent
		err = PlayToClientPacketParamsWorldEventTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldEventTmp
	case "world_particles":
		var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles
		err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Params = PlayToClientPacketParamsWorldParticlesTmp
	}
	return
}

var PlayToClientPacketNameReverseMap = map[string]int32{"bundle_delimiter": 0x00, "spawn_entity": 0x01, "animation": 0x02, "statistics": 0x03, "acknowledge_player_digging": 0x04, "block_break_animation": 0x05, "tile_entity_data": 0x06, "block_action": 0x07, "block_change": 0x08, "boss_bar": 0x09, "difficulty": 0x0a, "chunk_batch_finished": 0x0b, "chunk_batch_start": 0x0c, "chunk_biomes": 0x0d, "clear_titles": 0x0e, "tab_complete": 0x0f, "declare_commands": 0x10, "close_window": 0x11, "window_items": 0x12, "craft_progress_bar": 0x13, "set_slot": 0x14, "cookie_request": 0x15, "set_cooldown": 0x16, "chat_suggestions": 0x17, "custom_payload": 0x18, "damage_event": 0x19, "debug_block_value": 0x1a, "debug_chunk_value": 0x1b, "debug_entity_value": 0x1c, "debug_event": 0x1d, "debug_sample": 0x1e, "hide_message": 0x1f, "kick_disconnect": 0x20, "profileless_chat": 0x21, "entity_status": 0x22, "sync_entity_position": 0x23, "explosion": 0x24, "unload_chunk": 0x25, "game_state_change": 0x26, "game_test_highlight_pos": 0x27, "open_horse_window": 0x28, "hurt_animation": 0x29, "initialize_world_border": 0x2a, "keep_alive": 0x2b, "map_chunk": 0x2c, "world_event": 0x2d, "world_particles": 0x2e, "update_light": 0x2f, "login": 0x30, "map": 0x31, "trade_list": 0x32, "rel_entity_move": 0x33, "entity_move_look": 0x34, "move_minecart": 0x35, "entity_look": 0x36, "vehicle_move": 0x37, "open_book": 0x38, "open_window": 0x39, "open_sign_entity": 0x3a, "ping": 0x3b, "ping_response": 0x3c, "craft_recipe_response": 0x3d, "abilities": 0x3e, "player_chat": 0x3f, "end_combat_event": 0x40, "enter_combat_event": 0x41, "death_combat_event": 0x42, "player_remove": 0x43, "player_info": 0x44, "face_player": 0x45, "position": 0x46, "player_rotation": 0x47, "recipe_book_add": 0x48, "recipe_book_remove": 0x49, "recipe_book_settings": 0x4a, "entity_destroy": 0x4b, "remove_entity_effect": 0x4c, "reset_score": 0x4d, "remove_resource_pack": 0x4e, "add_resource_pack": 0x4f, "respawn": 0x50, "entity_head_rotation": 0x51, "multi_block_change": 0x52, "select_advancement_tab": 0x53, "server_data": 0x54, "action_bar": 0x55, "world_border_center": 0x56, "world_border_lerp_size": 0x57, "world_border_size": 0x58, "world_border_warning_delay": 0x59, "world_border_warning_reach": 0x5a, "camera": 0x5b, "update_view_position": 0x5c, "update_view_distance": 0x5d, "set_cursor_item": 0x5e, "spawn_position": 0x5f, "scoreboard_display_objective": 0x60, "entity_metadata": 0x61, "attach_entity": 0x62, "entity_velocity": 0x63, "entity_equipment": 0x64, "experience": 0x65, "update_health": 0x66, "held_item_slot": 0x67, "scoreboard_objective": 0x68, "set_passengers": 0x69, "set_player_inventory": 0x6a, "teams": 0x6b, "scoreboard_score": 0x6c, "simulation_distance": 0x6d, "set_title_subtitle": 0x6e, "update_time": 0x6f, "set_title_text": 0x70, "set_title_time": 0x71, "entity_sound_effect": 0x72, "sound_effect": 0x73, "start_configuration": 0x74, "stop_sound": 0x75, "store_cookie": 0x76, "system_chat": 0x77, "playerlist_header": 0x78, "nbt_query_response": 0x79, "collect": 0x7a, "entity_teleport": 0x7b, "test_instance_block_status": 0x7c, "set_ticking_state": 0x7d, "step_tick": 0x7e, "transfer": 0x7f, "advancements": 0x80, "entity_update_attributes": 0x81, "entity_effect": 0x82, "declare_recipes": 0x83, "tags": 0x84, "set_projectile_power": 0x85, "custom_report_details": 0x86, "server_links": 0x87, "tracked_waypoint": 0x88, "clear_dialog": 0x89, "show_dialog": 0x8a}

func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketName int32
	vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketName)
	if err != nil {
		return
	}
	switch ret.Name {
	case "abilities":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "acknowledge_player_digging":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "action_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketActionBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "add_resource_pack":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonAddResourcePack)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "advancements":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "attach_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "block_action":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "block_break_animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "boss_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "bundle_delimiter":
		_, ok := ret.Params.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	case "camera":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chat_suggestions":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChatSuggestions)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chunk_batch_finished":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchFinished)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chunk_batch_start":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchStart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "chunk_biomes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBiomes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "clear_dialog":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonClearDialog)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "clear_titles":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketClearTitles)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "close_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "collect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "cookie_request":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCookieRequest)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "craft_progress_bar":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "craft_recipe_response":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_payload":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "custom_report_details":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCustomReportDetails)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "damage_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDamageEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "death_combat_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeathCombatEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_block_value":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugBlockValue)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_chunk_value":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugChunkValue)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_entity_value":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugEntityValue)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "debug_sample":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugSample)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "declare_commands":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "declare_recipes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "difficulty":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "end_combat_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEndCombatEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "enter_combat_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEnterCombatEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_destroy":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_equipment":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_head_rotation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_metadata":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_move_look":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_status":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_teleport":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_update_attributes":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "entity_velocity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "experience":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "explosion":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "face_player":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "game_state_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "game_test_highlight_pos":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameTestHighlightPos)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "held_item_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "hide_message":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHideMessage)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "hurt_animation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHurtAnimation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "initialize_world_border":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketInitializeWorldBorder)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "keep_alive":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "kick_disconnect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "login":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "map":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "map_chunk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "move_minecart":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMoveMinecart)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "multi_block_change":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "nbt_query_response":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "open_book":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "open_horse_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "open_sign_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "open_window":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "ping":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPing)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "ping_response":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPingResponse)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_chat":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_info":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_remove":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRemove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "player_rotation":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRotation)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "playerlist_header":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "profileless_chat":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketProfilelessChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "recipe_book_add":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookAdd)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "recipe_book_remove":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookRemove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "recipe_book_settings":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookSettings)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "rel_entity_move":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "remove_entity_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "remove_resource_pack":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonRemoveResourcePack)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "reset_score":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResetScore)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "respawn":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_display_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_objective":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "scoreboard_score":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "select_advancement_tab":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "server_data":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketServerData)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "server_links":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonServerLinks)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_cooldown":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_cursor_item":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCursorItem)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_passengers":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_player_inventory":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPlayerInventory)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_projectile_power":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetProjectilePower)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_slot":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_ticking_state":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTickingState)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_title_subtitle":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleSubtitle)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_title_text":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleText)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "set_title_time":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleTime)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "show_dialog":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketShowDialog)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "simulation_distance":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSimulationDistance)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "sound_effect":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "spawn_entity":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "spawn_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "start_configuration":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStartConfiguration)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "statistics":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "step_tick":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStepTick)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "stop_sound":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "store_cookie":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonStoreCookie)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "sync_entity_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSyncEntityPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "system_chat":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSystemChat)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tab_complete":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tags":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "teams":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "test_instance_block_status":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTestInstanceBlockStatus)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tile_entity_data":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "tracked_waypoint":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTrackedWaypoint)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "trade_list":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "transfer":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonTransfer)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "unload_chunk":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_health":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_light":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_time":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_view_distance":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "update_view_position":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "vehicle_move":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "window_items":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_border_center":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderCenter)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_border_lerp_size":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderLerpSize)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_border_size":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderSize)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_border_warning_delay":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningDelay)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_border_warning_reach":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningReach)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_event":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	case "world_particles":
		PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketParams.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketAbilities struct {
	Flags        int8
	FlyingSpeed  float32
	WalkingSpeed float32
}

func (ret *PlayToClientPacketAbilities) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAcknowledgePlayerDigging struct {
	SequenceId int32
}

func (ret *PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.Reader) (err error) {
	ret.SequenceId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.SequenceId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketActionBar struct {
	Text nbt.Anon
}

func (ret *PlayToClientPacketActionBar) Decode(r io.Reader) (err error) {
	err = ret.Text.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketActionBar) Encode(w io.Writer) (err error) {
	err = ret.Text.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAdvancements struct {
	Reset              bool
	AdvancementMapping []struct {
		Key   string
		Value struct {
			ParentId    *string
			DisplayData *struct {
				Title       nbt.Anon
				Description nbt.Anon
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			Requirements      [][]string
			SendsTelemtryData bool
		}
	}
	Identifiers     []string
	ProgressMapping []struct {
		Key   string
		Value []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}
	}
	ShowAdvancements bool
}

func (ret *PlayToClientPacketAdvancements) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Reset)
	if err != nil {
		return
	}
	var lPlayToClientPacketAdvancementsAdvancementMapping int32
	lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.AdvancementMapping = []struct {
		Key   string
		Value struct {
			ParentId    *string
			DisplayData *struct {
				Title       nbt.Anon
				Description nbt.Anon
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			Requirements      [][]string
			SendsTelemtryData bool
		}
	}{}
	for range lPlayToClientPacketAdvancementsAdvancementMapping {
		var PlayToClientPacketAdvancementsAdvancementMappingElement struct {
			Key   string
			Value struct {
				ParentId    *string
				DisplayData *struct {
					Title       nbt.Anon
					Description nbt.Anon
					Icon        Slot
					FrameType   int32
					Flags       struct {
						Unused               uint32
						Hidden               bool
						ShowToast            bool
						HasBackgroundTexture bool
					}
					BackgroundTexture any
					XCord             float32
					YCord             float32
				}
				Requirements      [][]string
				SendsTelemtryData bool
			}
		}
		PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string
			PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue
		}
		var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct {
				Title       nbt.Anon
				Description nbt.Anon
				Icon        Slot
				FrameType   int32
				Flags       struct {
					Unused               uint32
					Hidden               bool
					ShowToast            bool
					HasBackgroundTexture bool
				}
				BackgroundTexture any
				XCord             float32
				YCord             float32
			}
			err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title.Decode(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description.Decode(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked uint32
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Unused = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked << 0 >> 3
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.Hidden = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<29>>31 == 1
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.ShowToast = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<30>>31 == 1
			PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataFlagsPacked<<31>>31 == 1
			switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags.HasBackgroundTexture {
			case true:
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp
			default:
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct {
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue
		}
		var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32
		lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{}
		for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements {
			var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string
			var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32
			lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{}
			for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement {
				var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string
				PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement)
			}
			PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement)
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElement.Value.SendsTelemtryData)
		if err != nil {
			return
		}
		ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement)
	}
	var lPlayToClientPacketAdvancementsIdentifiers int32
	lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Identifiers = []string{}
	for range lPlayToClientPacketAdvancementsIdentifiers {
		var PlayToClientPacketAdvancementsIdentifiersElement string
		PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement)
	}
	var lPlayToClientPacketAdvancementsProgressMapping int32
	lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ProgressMapping = []struct {
		Key   string
		Value []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}
	}{}
	for range lPlayToClientPacketAdvancementsProgressMapping {
		var PlayToClientPacketAdvancementsProgressMappingElement struct {
			Key   string
			Value []struct {
				CriterionIdentifier string
				CriterionProgress   *int64
			}
		}
		PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var lPlayToClientPacketAdvancementsProgressMappingElementValue int32
		lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct {
			CriterionIdentifier string
			CriterionProgress   *int64
		}{}
		for range lPlayToClientPacketAdvancementsProgressMappingElementValue {
			var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct {
				CriterionIdentifier string
				CriterionProgress   *int64
			}
			PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent)
			if err != nil {
				return
			}
			if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent {
				var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64
				err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue)
				if err != nil {
					return
				}
				PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue
			}
			PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement)
		}
		ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement)
	}
	err = binary.Read(r, binary.BigEndian, &ret.ShowAdvancements)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Reset)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) {
		err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil)
		if err != nil {
			return
		}
		if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil {
			err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId)
			if err != nil {
				return
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil)
		if err != nil {
			return
		}
		if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil {
			err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title.Encode(w)
			if err != nil {
				return
			}
			err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description.Encode(w)
			if err != nil {
				return
			}
			err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon.Encode(w)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType)
			if err != nil {
				return
			}
			var PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked uint32
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture) & 0x1) << 0x0
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.ShowToast) & 0x1) << 0x1
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (proto_base.Bool2uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Hidden) & 0x1) << 0x2
			PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked |= (uint32((*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.Unused) & 0x1FFFFFFF) << 0x3
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataFlagsPacked)
			if err != nil {
				return
			}
			switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags.HasBackgroundTexture {
			case true:
				PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string)
				if !ok {
					err = proto_base.BadTypeError
					return
				}
				err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture)
				if err != nil {
					return
				}
			default:
				_, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct {
				})
				if !ok {
					err = proto_base.BadTypeError
					return
				}
			}
			err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements)))
		if err != nil {
			return
		}
		for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) {
			err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements])))
			if err != nil {
				return
			}
			for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) {
				err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner])
				if err != nil {
					return
				}
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.SendsTelemtryData)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) {
		err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping)))
	if err != nil {
		return
	}
	for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) {
		err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value)))
		if err != nil {
			return
		}
		for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) {
			err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil)
			if err != nil {
				return
			}
			if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil {
				err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress)
				if err != nil {
					return
				}
			}
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.ShowAdvancements)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAnimation struct {
	EntityId  int32
	Animation uint8
}

func (ret *PlayToClientPacketAnimation) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Animation)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Animation)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketAttachEntity struct {
	EntityId  int32
	VehicleId int32
}

func (ret *PlayToClientPacketAttachEntity) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.VehicleId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.VehicleId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockAction struct {
	Location Position
	Byte1    uint8
	Byte2    uint8
	BlockId  int32
}

func (ret *PlayToClientPacketBlockAction) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Byte1)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Byte2)
	if err != nil {
		return
	}
	ret.BlockId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Byte1)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Byte2)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.BlockId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockBreakAnimation struct {
	EntityId     int32
	Location     Position
	DestroyStage int8
}

func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DestroyStage)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DestroyStage)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBlockChange struct {
	Location Position
	Type     int32
}

func (ret *PlayToClientPacketBlockChange) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketBossBar struct {
	EntityUUID uuid.UUID
	Action     int32
	Title      any
	Health     any
	Color      any
	Dividers   any
	Flags      any
}

func (ret *PlayToClientPacketBossBar) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.EntityUUID[:])
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarTitle0Tmp nbt.Anon
		err = PlayToClientPacketBossBarTitle0Tmp.Decode(r)
		if err != nil {
			return
		}
		ret.Title = PlayToClientPacketBossBarTitle0Tmp
	case 3:
		var PlayToClientPacketBossBarTitle3Tmp nbt.Anon
		err = PlayToClientPacketBossBarTitle3Tmp.Decode(r)
		if err != nil {
			return
		}
		ret.Title = PlayToClientPacketBossBarTitle3Tmp
	default:
		var PlayToClientPacketBossBarTitleTmp struct {
		}
		ret.Title = PlayToClientPacketBossBarTitleTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarHealth0Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp)
		if err != nil {
			return
		}
		ret.Health = PlayToClientPacketBossBarHealth0Tmp
	case 2:
		var PlayToClientPacketBossBarHealth2Tmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp)
		if err != nil {
			return
		}
		ret.Health = PlayToClientPacketBossBarHealth2Tmp
	default:
		var PlayToClientPacketBossBarHealthTmp struct {
		}
		ret.Health = PlayToClientPacketBossBarHealthTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarColor0Tmp int32
		PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketBossBarColor0Tmp
	case 4:
		var PlayToClientPacketBossBarColor4Tmp int32
		PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Color = PlayToClientPacketBossBarColor4Tmp
	default:
		var PlayToClientPacketBossBarColorTmp struct {
		}
		ret.Color = PlayToClientPacketBossBarColorTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarDividers0Tmp int32
		PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Dividers = PlayToClientPacketBossBarDividers0Tmp
	case 4:
		var PlayToClientPacketBossBarDividers4Tmp int32
		PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Dividers = PlayToClientPacketBossBarDividers4Tmp
	default:
		var PlayToClientPacketBossBarDividersTmp struct {
		}
		ret.Dividers = PlayToClientPacketBossBarDividersTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketBossBarFlags0Tmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp)
		if err != nil {
			return
		}
		ret.Flags = PlayToClientPacketBossBarFlags0Tmp
	case 5:
		var PlayToClientPacketBossBarFlags5Tmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp)
		if err != nil {
			return
		}
		ret.Flags = PlayToClientPacketBossBarFlags5Tmp
	default:
		var PlayToClientPacketBossBarFlagsTmp struct {
		}
		ret.Flags = PlayToClientPacketBossBarFlagsTmp
	}
	return
}
func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.EntityUUID[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketBossBarTitle.Encode(w)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketBossBarTitle.Encode(w)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Title.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketBossBarHealth, ok := ret.Health.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Health.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
		if err != nil {
			return
		}
	case 4:
		PlayToClientPacketBossBarColor, ok := ret.Color.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Color.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
		if err != nil {
			return
		}
	case 4:
		PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Dividers.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
		if err != nil {
			return
		}
	case 5:
		PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Flags.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketCamera struct {
	CameraId int32
}

func (ret *PlayToClientPacketCamera) Decode(r io.Reader) (err error) {
	ret.CameraId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.CameraId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketChatSuggestions struct {
	Action  int32
	Entries []string
}

func (ret *PlayToClientPacketChatSuggestions) Decode(r io.Reader) (err error) {
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketChatSuggestionsEntries int32
	lPlayToClientPacketChatSuggestionsEntries, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Entries = []string{}
	for range lPlayToClientPacketChatSuggestionsEntries {
		var PlayToClientPacketChatSuggestionsEntriesElement string
		PlayToClientPacketChatSuggestionsEntriesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Entries = append(ret.Entries, PlayToClientPacketChatSuggestionsEntriesElement)
	}
	return
}
func (ret *PlayToClientPacketChatSuggestions) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
	if err != nil {
		return
	}
	for iPlayToClientPacketChatSuggestionsEntries := range len(ret.Entries) {
		err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketChatSuggestionsEntries])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketChunkBatchFinished struct {
	BatchSize int32
}

func (ret *PlayToClientPacketChunkBatchFinished) Decode(r io.Reader) (err error) {
	ret.BatchSize, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketChunkBatchFinished) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.BatchSize)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketChunkBatchStart struct {
}

func (ret *PlayToClientPacketChunkBatchStart) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToClientPacketChunkBatchStart) Encode(w io.Writer) (err error) {
	return
}

type PlayToClientPacketChunkBiomes struct {
	Biomes []struct {
		Position PackedChunkPos
		Data     ByteArray
	}
}

func (ret *PlayToClientPacketChunkBiomes) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketChunkBiomesBiomes int32
	lPlayToClientPacketChunkBiomesBiomes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Biomes = []struct {
		Position PackedChunkPos
		Data     ByteArray
	}{}
	for range lPlayToClientPacketChunkBiomesBiomes {
		var PlayToClientPacketChunkBiomesBiomesElement struct {
			Position PackedChunkPos
			Data     ByteArray
		}
		err = PlayToClientPacketChunkBiomesBiomesElement.Position.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketChunkBiomesBiomesElement.Data.Decode(r)
		if err != nil {
			return
		}
		ret.Biomes = append(ret.Biomes, PlayToClientPacketChunkBiomesBiomesElement)
	}
	return
}
func (ret *PlayToClientPacketChunkBiomes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Biomes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketChunkBiomesBiomes := range len(ret.Biomes) {
		err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Position.Encode(w)
		if err != nil {
			return
		}
		err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Data.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketClearTitles struct {
	Reset bool
}

func (ret *PlayToClientPacketClearTitles) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Reset)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketClearTitles) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Reset)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCloseWindow struct {
	WindowId ContainerID
}

func (ret *PlayToClientPacketCloseWindow) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCollect struct {
	CollectedEntityId int32
	CollectorEntityId int32
	PickupItemCount   int32
}

func (ret *PlayToClientPacketCollect) Decode(r io.Reader) (err error) {
	ret.CollectedEntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.CollectorEntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PickupItemCount, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.CollectedEntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.CollectorEntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.PickupItemCount)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCommonAddResourcePack struct {
	Uuid          uuid.UUID
	Url           string
	Hash          string
	Forced        bool
	PromptMessage *nbt.Anon
}

func (ret *PlayToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) {
	_, err = io.ReadFull(r, ret.Uuid[:])
	if err != nil {
		return
	}
	ret.Url, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Hash, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Forced)
	if err != nil {
		return
	}
	var PlayToClientPacketCommonAddResourcePackPromptMessagePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonAddResourcePackPromptMessagePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketCommonAddResourcePackPromptMessagePresent {
		var PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon
		err = PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PromptMessage = &PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue
	}
	return
}
func (ret *PlayToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) {
	_, err = w.Write(ret.Uuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Url)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Hash)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Forced)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil)
	if err != nil {
		return
	}
	if ret.PromptMessage != nil {
		err = (*ret.PromptMessage).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonClearDialog struct {
}

func (ret *PlayToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) {
	return
}

type PlayToClientPacketCommonCookieRequest struct {
	Cookie string
}

func (ret *PlayToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) {
	ret.Cookie, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Cookie)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCommonCookieResponse struct {
	Key   string
	Value *ByteArray
}

func (ret *PlayToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToClientPacketCommonCookieResponseValuePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCookieResponseValuePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketCommonCookieResponseValuePresent {
		var PlayToClientPacketCommonCookieResponseValuePresentValue ByteArray
		err = PlayToClientPacketCommonCookieResponseValuePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Value = &PlayToClientPacketCommonCookieResponseValuePresentValue
	}
	return
}
func (ret *PlayToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value != nil)
	if err != nil {
		return
	}
	if ret.Value != nil {
		err = (*ret.Value).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonCustomClickAction struct {
	Id  string
	Nbt *nbt.Anon
}

func (ret *PlayToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToClientPacketCommonCustomClickActionNbtPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCustomClickActionNbtPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketCommonCustomClickActionNbtPresent {
		var PlayToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon
		err = PlayToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Nbt = &PlayToClientPacketCommonCustomClickActionNbtPresentValue
	}
	return
}
func (ret *PlayToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Nbt != nil)
	if err != nil {
		return
	}
	if ret.Nbt != nil {
		err = (*ret.Nbt).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonCustomReportDetails struct {
	Details []struct {
		Key   string
		Value string
	}
}

func (ret *PlayToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketCommonCustomReportDetailsDetails int32
	lPlayToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Details = []struct {
		Key   string
		Value string
	}{}
	for range lPlayToClientPacketCommonCustomReportDetailsDetails {
		var PlayToClientPacketCommonCustomReportDetailsDetailsElement struct {
			Key   string
			Value string
		}
		PlayToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Details = append(ret.Details, PlayToClientPacketCommonCustomReportDetailsDetailsElement)
	}
	return
}
func (ret *PlayToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Details)))
	if err != nil {
		return
	}
	for iPlayToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) {
		err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Value)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonRemoveResourcePack struct {
	Uuid *uuid.UUID
}

func (ret *PlayToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) {
	var PlayToClientPacketCommonRemoveResourcePackUuidPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonRemoveResourcePackUuidPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketCommonRemoveResourcePackUuidPresent {
		var PlayToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID
		_, err = io.ReadFull(r, PlayToClientPacketCommonRemoveResourcePackUuidPresentValue[:])
		if err != nil {
			return
		}
		ret.Uuid = &PlayToClientPacketCommonRemoveResourcePackUuidPresentValue
	}
	return
}
func (ret *PlayToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Uuid != nil)
	if err != nil {
		return
	}
	if ret.Uuid != nil {
		_, err = w.Write((*ret.Uuid)[:])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonSelectKnownPacks struct {
	Packs []struct {
		Namespace string
		Id        string
		Version   string
	}
}

func (ret *PlayToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketCommonSelectKnownPacksPacks int32
	lPlayToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Packs = []struct {
		Namespace string
		Id        string
		Version   string
	}{}
	for range lPlayToClientPacketCommonSelectKnownPacksPacks {
		var PlayToClientPacketCommonSelectKnownPacksPacksElement struct {
			Namespace string
			Id        string
			Version   string
		}
		PlayToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		PlayToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Packs = append(ret.Packs, PlayToClientPacketCommonSelectKnownPacksPacksElement)
	}
	return
}
func (ret *PlayToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Packs)))
	if err != nil {
		return
	}
	for iPlayToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) {
		err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Namespace)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Id)
		if err != nil {
			return
		}
		err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Version)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonServerLinks struct {
	Links []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}
}

func (ret *PlayToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketCommonServerLinksLinks int32
	lPlayToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Links = []struct {
		HasKnownType bool
		KnownType    any
		UnknownType  any
		Link         string
	}{}
	for range lPlayToClientPacketCommonServerLinksLinks {
		var PlayToClientPacketCommonServerLinksLinksElement struct {
			HasKnownType bool
			KnownType    any
			UnknownType  any
			Link         string
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonServerLinksLinksElement.HasKnownType)
		if err != nil {
			return
		}
		switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case true:
			var PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType
			err = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketCommonServerLinksLinksElement.KnownType = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp
		}
		switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType {
		case false:
			var PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon
			err = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketCommonServerLinksLinksElement.UnknownType = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp
		}
		PlayToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Links = append(ret.Links, PlayToClientPacketCommonServerLinksLinksElement)
	}
	return
}
func (ret *PlayToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Links)))
	if err != nil {
		return
	}
	for iPlayToClientPacketCommonServerLinksLinks := range len(ret.Links) {
		err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType)
		if err != nil {
			return
		}
		switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType {
		case true:
			PlayToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w)
			if err != nil {
				return
			}
		}
		switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType {
		case false:
			PlayToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w)
			if err != nil {
				return
			}
		}
		err = proto_base.EncodeString(w, ret.Links[iPlayToClientPacketCommonServerLinksLinks].Link)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketCommonSettings struct {
	Locale              string
	ViewDistance        int8
	ChatFlags           int32
	ChatColors          bool
	SkinParts           uint8
	MainHand            int32
	EnableTextFiltering bool
	EnableServerListing bool
	ParticleStatus      string
}

var PlayToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"}

func (ret *PlayToClientPacketCommonSettings) Decode(r io.Reader) (err error) {
	ret.Locale, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ViewDistance)
	if err != nil {
		return
	}
	ret.ChatFlags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.SkinParts)
	if err != nil {
		return
	}
	ret.MainHand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing)
	if err != nil {
		return
	}
	var PlayToClientPacketCommonSettingsParticleStatusKey int32
	PlayToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusMap, PlayToClientPacketCommonSettingsParticleStatusKey)
	if err != nil {
		return
	}
	return
}

var PlayToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2}

func (ret *PlayToClientPacketCommonSettings) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Locale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChatFlags)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChatColors)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SkinParts)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.MainHand)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableServerListing)
	if err != nil {
		return
	}
	var vPlayToClientPacketCommonSettingsParticleStatus int32
	vPlayToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketCommonSettingsParticleStatus)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCommonStoreCookie struct {
	Key   string
	Value ByteArray
}

func (ret *PlayToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) {
	ret.Key, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Value.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Key)
	if err != nil {
		return
	}
	err = ret.Value.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCommonTransfer struct {
	Host string
	Port int32
}

func (ret *PlayToClientPacketCommonTransfer) Decode(r io.Reader) (err error) {
	ret.Host, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.Port, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCommonTransfer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Host)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Port)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCraftProgressBar struct {
	WindowId ContainerID
	Property int16
	Value    int16
}

func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Property)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Value)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Property)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Value)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCraftRecipeResponse struct {
	WindowId      ContainerID
	RecipeDisplay PlayToClientRecipeDisplay
}

func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	err = ret.RecipeDisplay.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = ret.RecipeDisplay.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketCustomPayload struct {
	Channel string
	Data    proto_base.RestBuffer
}

func (ret *PlayToClientPacketCustomPayload) Decode(r io.Reader) (err error) {
	ret.Channel, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = ret.Data.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Channel)
	if err != nil {
		return
	}
	err = ret.Data.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDamageEvent struct {
	EntityId       int32
	SourceTypeId   int32
	SourceCauseId  int32
	SourceDirectId int32
	SourcePosition *Vec3f64
}

func (ret *PlayToClientPacketDamageEvent) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SourceTypeId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SourceCauseId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SourceDirectId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToClientPacketDamageEventSourcePositionPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDamageEventSourcePositionPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketDamageEventSourcePositionPresent {
		var PlayToClientPacketDamageEventSourcePositionPresentValue Vec3f64
		err = PlayToClientPacketDamageEventSourcePositionPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.SourcePosition = &PlayToClientPacketDamageEventSourcePositionPresentValue
	}
	return
}
func (ret *PlayToClientPacketDamageEvent) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SourceTypeId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SourceCauseId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SourceDirectId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.SourcePosition != nil)
	if err != nil {
		return
	}
	if ret.SourcePosition != nil {
		err = (*ret.SourcePosition).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketDeathCombatEvent struct {
	PlayerId int32
	Message  nbt.Anon
}

func (ret *PlayToClientPacketDeathCombatEvent) Decode(r io.Reader) (err error) {
	ret.PlayerId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Message.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDeathCombatEvent) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.PlayerId)
	if err != nil {
		return
	}
	err = ret.Message.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDebugBlockValue struct {
	BlockPos Position
	Update   DebugSubscriptionUpdate
}

func (ret *PlayToClientPacketDebugBlockValue) Decode(r io.Reader) (err error) {
	err = ret.BlockPos.Decode(r)
	if err != nil {
		return
	}
	err = ret.Update.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDebugBlockValue) Encode(w io.Writer) (err error) {
	err = ret.BlockPos.Encode(w)
	if err != nil {
		return
	}
	err = ret.Update.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDebugChunkValue struct {
	ChunkPos PackedChunkPos
	Update   DebugSubscriptionUpdate
}

func (ret *PlayToClientPacketDebugChunkValue) Decode(r io.Reader) (err error) {
	err = ret.ChunkPos.Decode(r)
	if err != nil {
		return
	}
	err = ret.Update.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDebugChunkValue) Encode(w io.Writer) (err error) {
	err = ret.ChunkPos.Encode(w)
	if err != nil {
		return
	}
	err = ret.Update.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDebugEntityValue struct {
	EntityId int32
	Update   DebugSubscriptionUpdate
}

func (ret *PlayToClientPacketDebugEntityValue) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Update.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDebugEntityValue) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = ret.Update.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDebugEvent struct {
	Event DebugSubscriptionEvent
}

func (ret *PlayToClientPacketDebugEvent) Decode(r io.Reader) (err error) {
	err = ret.Event.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDebugEvent) Encode(w io.Writer) (err error) {
	err = ret.Event.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDebugSample struct {
	Sample []int64
	Type   int32
}

func (ret *PlayToClientPacketDebugSample) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketDebugSampleSample int32
	lPlayToClientPacketDebugSampleSample, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Sample = []int64{}
	for range lPlayToClientPacketDebugSampleSample {
		var PlayToClientPacketDebugSampleSampleElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDebugSampleSampleElement)
		if err != nil {
			return
		}
		ret.Sample = append(ret.Sample, PlayToClientPacketDebugSampleSampleElement)
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDebugSample) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Sample)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDebugSampleSample := range len(ret.Sample) {
		err = binary.Write(w, binary.BigEndian, ret.Sample[iPlayToClientPacketDebugSampleSample])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDeclareCommands struct {
	Nodes     []CommandNode
	RootIndex int32
}

func (ret *PlayToClientPacketDeclareCommands) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketDeclareCommandsNodes int32
	lPlayToClientPacketDeclareCommandsNodes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Nodes = []CommandNode{}
	for range lPlayToClientPacketDeclareCommandsNodes {
		var PlayToClientPacketDeclareCommandsNodesElement CommandNode
		err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r)
		if err != nil {
			return
		}
		ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement)
	}
	ret.RootIndex, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) {
		err = ret.Nodes[iPlayToClientPacketDeclareCommandsNodes].Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.RootIndex)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketDeclareRecipes struct {
	Recipes []struct {
		Name  string
		Items []int32
	}
	StoneCutterRecipes []struct {
		Input       IDSet
		SlotDisplay PlayToClientSlotDisplay
	}
}

func (ret *PlayToClientPacketDeclareRecipes) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketDeclareRecipesRecipes int32
	lPlayToClientPacketDeclareRecipesRecipes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Recipes = []struct {
		Name  string
		Items []int32
	}{}
	for range lPlayToClientPacketDeclareRecipesRecipes {
		var PlayToClientPacketDeclareRecipesRecipesElement struct {
			Name  string
			Items []int32
		}
		PlayToClientPacketDeclareRecipesRecipesElement.Name, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var lPlayToClientPacketDeclareRecipesRecipesElementItems int32
		lPlayToClientPacketDeclareRecipesRecipesElementItems, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketDeclareRecipesRecipesElement.Items = []int32{}
		for range lPlayToClientPacketDeclareRecipesRecipesElementItems {
			var PlayToClientPacketDeclareRecipesRecipesElementItemsElement int32
			PlayToClientPacketDeclareRecipesRecipesElementItemsElement, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketDeclareRecipesRecipesElement.Items = append(PlayToClientPacketDeclareRecipesRecipesElement.Items, PlayToClientPacketDeclareRecipesRecipesElementItemsElement)
		}
		ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement)
	}
	var lPlayToClientPacketDeclareRecipesStoneCutterRecipes int32
	lPlayToClientPacketDeclareRecipesStoneCutterRecipes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.StoneCutterRecipes = []struct {
		Input       IDSet
		SlotDisplay PlayToClientSlotDisplay
	}{}
	for range lPlayToClientPacketDeclareRecipesStoneCutterRecipes {
		var PlayToClientPacketDeclareRecipesStoneCutterRecipesElement struct {
			Input       IDSet
			SlotDisplay PlayToClientSlotDisplay
		}
		err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.Input.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.SlotDisplay.Decode(r)
		if err != nil {
			return
		}
		ret.StoneCutterRecipes = append(ret.StoneCutterRecipes, PlayToClientPacketDeclareRecipesStoneCutterRecipesElement)
	}
	return
}
func (ret *PlayToClientPacketDeclareRecipes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDeclareRecipesRecipes := range len(ret.Recipes) {
		err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Name)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items)))
		if err != nil {
			return
		}
		for iPlayToClientPacketDeclareRecipesRecipesInnerItems := range len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items) {
			err = proto_base.EncodeVarInt(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items[iPlayToClientPacketDeclareRecipesRecipesInnerItems])
			if err != nil {
				return
			}
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.StoneCutterRecipes)))
	if err != nil {
		return
	}
	for iPlayToClientPacketDeclareRecipesStoneCutterRecipes := range len(ret.StoneCutterRecipes) {
		err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].Input.Encode(w)
		if err != nil {
			return
		}
		err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].SlotDisplay.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketDifficulty struct {
	Difficulty       string
	DifficultyLocked bool
}

var PlayToClientPacketDifficultyDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"}

func (ret *PlayToClientPacketDifficulty) Decode(r io.Reader) (err error) {
	var PlayToClientPacketDifficultyDifficultyKey int32
	PlayToClientPacketDifficultyDifficultyKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Difficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyMap, PlayToClientPacketDifficultyDifficultyKey)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DifficultyLocked)
	if err != nil {
		return
	}
	return
}

var PlayToClientPacketDifficultyDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3}

func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketDifficultyDifficulty int32
	vPlayToClientPacketDifficultyDifficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyReverseMap, ret.Difficulty)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketDifficultyDifficulty)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEndCombatEvent struct {
	Duration int32
}

func (ret *PlayToClientPacketEndCombatEvent) Decode(r io.Reader) (err error) {
	ret.Duration, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEndCombatEvent) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Duration)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEnterCombatEvent struct {
}

func (ret *PlayToClientPacketEnterCombatEvent) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToClientPacketEnterCombatEvent) Encode(w io.Writer) (err error) {
	return
}

type PlayToClientPacketEntityDestroy struct {
	EntityIds []int32
}

func (ret *PlayToClientPacketEntityDestroy) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketEntityDestroyEntityIds int32
	lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EntityIds = []int32{}
	for range lPlayToClientPacketEntityDestroyEntityIds {
		var PlayToClientPacketEntityDestroyEntityIdsElement int32
		PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement)
	}
	return
}
func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds)))
	if err != nil {
		return
	}
	for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) {
		err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketEntityEffect struct {
	EntityId  int32
	EffectId  int32
	Amplifier int32
	Duration  int32
	Flags     uint8
}

func (ret *PlayToClientPacketEntityEffect) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EffectId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Amplifier, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Duration, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EffectId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Amplifier)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Duration)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityEquipment struct {
	Val proto_base.ToDo
}

func (ret *PlayToClientPacketEntityEquipment) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type PlayToClientPacketEntityHeadRotation struct {
	EntityId int32
	HeadYaw  int8
}

func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HeadYaw)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HeadYaw)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityLook struct {
	EntityId int32
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityLook) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityMetadata struct {
	EntityId int32
	Metadata EntityMetadata
}

func (ret *PlayToClientPacketEntityMetadata) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Metadata.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = ret.Metadata.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityMoveLook struct {
	EntityId int32
	DX       int16
	DY       int16
	DZ       int16
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntitySoundEffect struct {
	Sound         ItemSoundHolder
	SoundCategory SoundSource
	EntityId      int32
	Volume        float32
	Pitch         float32
	Seed          int64
}

func (ret *PlayToClientPacketEntitySoundEffect) Decode(r io.Reader) (err error) {
	err = ret.Sound.Decode(r)
	if err != nil {
		return
	}
	err = ret.SoundCategory.Decode(r)
	if err != nil {
		return
	}
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Volume)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Seed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntitySoundEffect) Encode(w io.Writer) (err error) {
	err = ret.Sound.Encode(w)
	if err != nil {
		return
	}
	err = ret.SoundCategory.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Volume)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Seed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityStatus struct {
	EntityId     int32
	EntityStatus int8
}

func (ret *PlayToClientPacketEntityStatus) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EntityStatus)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EntityStatus)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityTeleport struct {
	EntityId int32
	X        float64
	Y        float64
	Z        float64
	Yaw      int8
	Pitch    int8
	OnGround bool
}

func (ret *PlayToClientPacketEntityTeleport) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketEntityUpdateAttributes struct {
	EntityId   int32
	Properties []struct {
		Key       string
		Value     float64
		Modifiers []struct {
			Uuid      string
			Amount    float64
			Operation int8
		}
	}
}

var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap = map[int32]string{0: "generic.armor", 1: "generic.armor_toughness", 10: "player.entity_interaction_range", 11: "generic.fall_damage_multiplier", 12: "generic.flying_speed", 13: "generic.follow_range", 14: "generic.gravity", 15: "generic.jump_strength", 16: "generic.knockback_resistance", 17: "generic.luck", 18: "generic.max_absorption", 19: "generic.max_health", 2: "generic.attack_damage", 20: "generic.movement_speed", 21: "generic.safe_fall_distance", 22: "generic.scale", 23: "zombie.spawn_reinforcements", 24: "generic.step_height", 25: "submerged_mining_speed", 26: "sweeping_damage_ratio", 27: "tempt_range", 28: "water_movement_efficiency", 29: "waypoint_transmit_range", 3: "generic.attack_knockback", 30: "waypoint_receive_range", 4: "generic.attack_speed", 5: "player.block_break_speed", 6: "player.block_interaction_range", 7: "burning_time", 8: "camera_distance", 9: "explosion_knockback_resistance"}

func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketEntityUpdateAttributesProperties int32
	lPlayToClientPacketEntityUpdateAttributesProperties, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Properties = []struct {
		Key       string
		Value     float64
		Modifiers []struct {
			Uuid      string
			Amount    float64
			Operation int8
		}
	}{}
	for range lPlayToClientPacketEntityUpdateAttributesProperties {
		var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct {
			Key       string
			Value     float64
			Modifiers []struct {
				Uuid      string
				Amount    float64
				Operation int8
			}
		}
		var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey int32
		PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap, PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElement.Value)
		if err != nil {
			return
		}
		var lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers int32
		lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = []struct {
			Uuid      string
			Amount    float64
			Operation int8
		}{}
		for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers {
			var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct {
				Uuid      string
				Amount    float64
				Operation int8
			}
			PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Amount)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Operation)
			if err != nil {
				return
			}
			PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement)
		}
		ret.Properties = append(ret.Properties, PlayToClientPacketEntityUpdateAttributesPropertiesElement)
	}
	return
}

var PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap = map[string]int32{"generic.armor": 0, "generic.armor_toughness": 1, "player.entity_interaction_range": 10, "generic.fall_damage_multiplier": 11, "generic.flying_speed": 12, "generic.follow_range": 13, "generic.gravity": 14, "generic.jump_strength": 15, "generic.knockback_resistance": 16, "generic.luck": 17, "generic.max_absorption": 18, "generic.max_health": 19, "generic.attack_damage": 2, "generic.movement_speed": 20, "generic.safe_fall_distance": 21, "generic.scale": 22, "zombie.spawn_reinforcements": 23, "generic.step_height": 24, "submerged_mining_speed": 25, "sweeping_damage_ratio": 26, "tempt_range": 27, "water_movement_efficiency": 28, "waypoint_transmit_range": 29, "generic.attack_knockback": 3, "waypoint_receive_range": 30, "generic.attack_speed": 4, "player.block_break_speed": 5, "player.block_interaction_range": 6, "burning_time": 7, "camera_distance": 8, "explosion_knockback_resistance": 9}

func (ret *PlayToClientPacketEntityUpdateAttributes) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Properties)))
	if err != nil {
		return
	}
	for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) {
		var vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey int32
		vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers) {
			err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Uuid)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Amount)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Operation)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketEntityVelocity struct {
	EntityId int32
	Velocity proto_base.LpVec3d
}

func (ret *PlayToClientPacketEntityVelocity) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Velocity.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = ret.Velocity.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketExperience struct {
	ExperienceBar   float32
	Level           int32
	TotalExperience int32
}

func (ret *PlayToClientPacketExperience) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar)
	if err != nil {
		return
	}
	ret.Level, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.TotalExperience, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ExperienceBar)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Level)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.TotalExperience)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketExplosion struct {
	Center            Vec3f64
	Radius            float32
	BlockCount        int32
	PlayerKnockback   *Vec3f64
	ExplosionParticle Particle
	Sound             ItemSoundHolder
	BlockParticles    []PlayToClientExplosionParticleEntry
}

func (ret *PlayToClientPacketExplosion) Decode(r io.Reader) (err error) {
	err = ret.Center.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Radius)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.BlockCount)
	if err != nil {
		return
	}
	var PlayToClientPacketExplosionPlayerKnockbackPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionPlayerKnockbackPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketExplosionPlayerKnockbackPresent {
		var PlayToClientPacketExplosionPlayerKnockbackPresentValue Vec3f64
		err = PlayToClientPacketExplosionPlayerKnockbackPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.PlayerKnockback = &PlayToClientPacketExplosionPlayerKnockbackPresentValue
	}
	err = ret.ExplosionParticle.Decode(r)
	if err != nil {
		return
	}
	err = ret.Sound.Decode(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketExplosionBlockParticles int32
	lPlayToClientPacketExplosionBlockParticles, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockParticles = []PlayToClientExplosionParticleEntry{}
	for range lPlayToClientPacketExplosionBlockParticles {
		var PlayToClientPacketExplosionBlockParticlesElement PlayToClientExplosionParticleEntry
		err = PlayToClientPacketExplosionBlockParticlesElement.Decode(r)
		if err != nil {
			return
		}
		ret.BlockParticles = append(ret.BlockParticles, PlayToClientPacketExplosionBlockParticlesElement)
	}
	return
}
func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) {
	err = ret.Center.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Radius)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.BlockCount)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.PlayerKnockback != nil)
	if err != nil {
		return
	}
	if ret.PlayerKnockback != nil {
		err = (*ret.PlayerKnockback).Encode(w)
		if err != nil {
			return
		}
	}
	err = ret.ExplosionParticle.Encode(w)
	if err != nil {
		return
	}
	err = ret.Sound.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockParticles)))
	if err != nil {
		return
	}
	for iPlayToClientPacketExplosionBlockParticles := range len(ret.BlockParticles) {
		err = ret.BlockParticles[iPlayToClientPacketExplosionBlockParticles].Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketFacePlayer struct {
	FeetEyes       int32
	X              float64
	Y              float64
	Z              float64
	IsEntity       bool
	EntityId       any
	EntityFeetEyes any
}

func (ret *PlayToClientPacketFacePlayer) Decode(r io.Reader) (err error) {
	ret.FeetEyes, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsEntity)
	if err != nil {
		return
	}
	switch ret.IsEntity {
	case true:
		var PlayToClientPacketFacePlayerEntityIdTrueTmp int32
		PlayToClientPacketFacePlayerEntityIdTrueTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.EntityId = PlayToClientPacketFacePlayerEntityIdTrueTmp
	default:
		var PlayToClientPacketFacePlayerEntityIdTmp struct {
		}
		ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp
	}
	switch ret.IsEntity {
	case true:
		var PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp int32
		PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp
	default:
		var PlayToClientPacketFacePlayerEntityFeetEyesTmp struct {
		}
		ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp
	}
	return
}
func (ret *PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.FeetEyes)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsEntity)
	if err != nil {
		return
	}
	switch ret.IsEntity {
	case true:
		PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityId)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityId.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.IsEntity {
	case true:
		PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityFeetEyes)
		if err != nil {
			return
		}
	default:
		_, ok := ret.EntityFeetEyes.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketGameStateChange struct {
	Reason   string
	GameMode float32
}

var PlayToClientPacketGameStateChangeReasonMap = map[uint8]string{0: "no_respawn_block_available", 1: "start_raining", 10: "guardian_elder_effect", 11: "immediate_respawn", 12: "limited_crafting", 13: "level_chunks_load_start", 2: "stop_raining", 3: "change_game_mode", 4: "win_game", 5: "demo_event", 6: "play_arrow_hit_sound", 7: "rain_level_change", 8: "thunder_level_change", 9: "puffer_fish_sting"}

func (ret *PlayToClientPacketGameStateChange) Decode(r io.Reader) (err error) {
	var PlayToClientPacketGameStateChangeReasonKey uint8
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketGameStateChangeReasonKey)
	if err != nil {
		return
	}
	ret.Reason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonMap, PlayToClientPacketGameStateChangeReasonKey)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.GameMode)
	if err != nil {
		return
	}
	return
}

var PlayToClientPacketGameStateChangeReasonReverseMap = map[string]uint8{"no_respawn_block_available": 0, "start_raining": 1, "guardian_elder_effect": 10, "immediate_respawn": 11, "limited_crafting": 12, "level_chunks_load_start": 13, "stop_raining": 2, "change_game_mode": 3, "win_game": 4, "demo_event": 5, "play_arrow_hit_sound": 6, "rain_level_change": 7, "thunder_level_change": 8, "puffer_fish_sting": 9}

func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketGameStateChangeReason uint8
	vPlayToClientPacketGameStateChangeReason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonReverseMap, ret.Reason)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, vPlayToClientPacketGameStateChangeReason)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.GameMode)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketGameTestHighlightPos struct {
	AbsolutePos Position
	RelativePos Position
}

func (ret *PlayToClientPacketGameTestHighlightPos) Decode(r io.Reader) (err error) {
	err = ret.AbsolutePos.Decode(r)
	if err != nil {
		return
	}
	err = ret.RelativePos.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketGameTestHighlightPos) Encode(w io.Writer) (err error) {
	err = ret.AbsolutePos.Encode(w)
	if err != nil {
		return
	}
	err = ret.RelativePos.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketHeldItemSlot struct {
	Slot int32
}

func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.Reader) (err error) {
	ret.Slot, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Slot)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketHideMessage struct {
	Id        int32
	Signature any
}

func (ret *PlayToClientPacketHideMessage) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.Id {
	case 0:
		var PlayToClientPacketHideMessageSignature0Tmp [256]byte
		_, err = r.Read(PlayToClientPacketHideMessageSignature0Tmp[:])
		if err != nil {
			return
		}
		ret.Signature = PlayToClientPacketHideMessageSignature0Tmp
	default:
		var PlayToClientPacketHideMessageSignatureTmp struct {
		}
		ret.Signature = PlayToClientPacketHideMessageSignatureTmp
	}
	return
}
func (ret *PlayToClientPacketHideMessage) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Id)
	if err != nil {
		return
	}
	switch ret.Id {
	case 0:
		PlayToClientPacketHideMessageSignature, ok := ret.Signature.([256]byte)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		arr := PlayToClientPacketHideMessageSignature
		_, err = w.Write(arr[:])
		if err != nil {
			return
		}
	default:
		_, ok := ret.Signature.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketHurtAnimation struct {
	EntityId int32
	Yaw      float32
}

func (ret *PlayToClientPacketHurtAnimation) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketHurtAnimation) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketInitializeWorldBorder struct {
	X                      float64
	Z                      float64
	OldDiameter            float64
	NewDiameter            float64
	Speed                  int32
	PortalTeleportBoundary int32
	WarningBlocks          int32
	WarningTime            int32
}

func (ret *PlayToClientPacketInitializeWorldBorder) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OldDiameter)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.NewDiameter)
	if err != nil {
		return
	}
	ret.Speed, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.PortalTeleportBoundary, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.WarningBlocks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.WarningTime, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketInitializeWorldBorder) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OldDiameter)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.NewDiameter)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Speed)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.PortalTeleportBoundary)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.WarningBlocks)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.WarningTime)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketKeepAlive struct {
	KeepAliveId int64
}

func (ret *PlayToClientPacketKeepAlive) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.KeepAliveId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketKickDisconnect struct {
	Reason nbt.Anon
}

func (ret *PlayToClientPacketKickDisconnect) Decode(r io.Reader) (err error) {
	err = ret.Reason.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) {
	err = ret.Reason.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketLogin struct {
	EntityId            int32
	IsHardcore          bool
	WorldNames          []string
	MaxPlayers          int32
	ViewDistance        int32
	SimulationDistance  int32
	ReducedDebugInfo    bool
	EnableRespawnScreen bool
	DoLimitedCrafting   bool
	WorldState          PlayToClientSpawnInfo
	EnforcesSecureChat  bool
}

func (ret *PlayToClientPacketLogin) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsHardcore)
	if err != nil {
		return
	}
	var lPlayToClientPacketLoginWorldNames int32
	lPlayToClientPacketLoginWorldNames, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.WorldNames = []string{}
	for range lPlayToClientPacketLoginWorldNames {
		var PlayToClientPacketLoginWorldNamesElement string
		PlayToClientPacketLoginWorldNamesElement, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.WorldNames = append(ret.WorldNames, PlayToClientPacketLoginWorldNamesElement)
	}
	ret.MaxPlayers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ViewDistance, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SimulationDistance, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnableRespawnScreen)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DoLimitedCrafting)
	if err != nil {
		return
	}
	err = ret.WorldState.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EnforcesSecureChat)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketLogin) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsHardcore)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.WorldNames)))
	if err != nil {
		return
	}
	for iPlayToClientPacketLoginWorldNames := range len(ret.WorldNames) {
		err = proto_base.EncodeString(w, ret.WorldNames[iPlayToClientPacketLoginWorldNames])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.MaxPlayers)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ViewDistance)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.SimulationDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnableRespawnScreen)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DoLimitedCrafting)
	if err != nil {
		return
	}
	err = ret.WorldState.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EnforcesSecureChat)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketMap struct {
	ItemDamage int32
	Scale      int8
	Locked     bool
	Icons      *[]struct {
		Type        int32
		X           int8
		Z           int8
		Direction   uint8
		DisplayName *nbt.Anon
	}
	Columns uint8
	Rows    any
	X       any
	Y       any
	Data    any
}

func (ret *PlayToClientPacketMap) Decode(r io.Reader) (err error) {
	ret.ItemDamage, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Scale)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Locked)
	if err != nil {
		return
	}
	var PlayToClientPacketMapIconsPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketMapIconsPresent {
		var PlayToClientPacketMapIconsPresentValue []struct {
			Type        int32
			X           int8
			Z           int8
			Direction   uint8
			DisplayName *nbt.Anon
		}
		var lPlayToClientPacketMapIcons int32
		lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapIconsPresentValue = []struct {
			Type        int32
			X           int8
			Z           int8
			Direction   uint8
			DisplayName *nbt.Anon
		}{}
		for range lPlayToClientPacketMapIcons {
			var PlayToClientPacketMapIconsElement struct {
				Type        int32
				X           int8
				Z           int8
				Direction   uint8
				DisplayName *nbt.Anon
			}
			PlayToClientPacketMapIconsElement.Type, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.X)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Z)
			if err != nil {
				return
			}
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Direction)
			if err != nil {
				return
			}
			var PlayToClientPacketMapIconsElementDisplayNamePresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElementDisplayNamePresent)
			if err != nil {
				return
			}
			if PlayToClientPacketMapIconsElementDisplayNamePresent {
				var PlayToClientPacketMapIconsElementDisplayNamePresentValue nbt.Anon
				err = PlayToClientPacketMapIconsElementDisplayNamePresentValue.Decode(r)
				if err != nil {
					return
				}
				PlayToClientPacketMapIconsElement.DisplayName = &PlayToClientPacketMapIconsElementDisplayNamePresentValue
			}
			PlayToClientPacketMapIconsPresentValue = append(PlayToClientPacketMapIconsPresentValue, PlayToClientPacketMapIconsElement)
		}
		ret.Icons = &PlayToClientPacketMapIconsPresentValue
	}
	err = binary.Read(r, binary.BigEndian, &ret.Columns)
	if err != nil {
		return
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapRows0Tmp struct {
		}
		ret.Rows = PlayToClientPacketMapRows0Tmp
	default:
		var PlayToClientPacketMapRowsTmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp)
		if err != nil {
			return
		}
		ret.Rows = PlayToClientPacketMapRowsTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapX0Tmp struct {
		}
		ret.X = PlayToClientPacketMapX0Tmp
	default:
		var PlayToClientPacketMapXTmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp)
		if err != nil {
			return
		}
		ret.X = PlayToClientPacketMapXTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapY0Tmp struct {
		}
		ret.Y = PlayToClientPacketMapY0Tmp
	default:
		var PlayToClientPacketMapYTmp uint8
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp)
		if err != nil {
			return
		}
		ret.Y = PlayToClientPacketMapYTmp
	}
	switch ret.Columns {
	case 0:
		var PlayToClientPacketMapData0Tmp struct {
		}
		ret.Data = PlayToClientPacketMapData0Tmp
	default:
		var PlayToClientPacketMapDataTmp []byte
		var lPlayToClientPacketMapData int32
		lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData)))
		if err != nil {
			return
		}
		ret.Data = PlayToClientPacketMapDataTmp
	}
	return
}
func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ItemDamage)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Scale)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Locked)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Icons != nil)
	if err != nil {
		return
	}
	if ret.Icons != nil {
		err = proto_base.EncodeVarInt(w, int32(len(*ret.Icons)))
		if err != nil {
			return
		}
		for iPlayToClientPacketMapIcons := range len(*ret.Icons) {
			err = proto_base.EncodeVarInt(w, (*ret.Icons)[iPlayToClientPacketMapIcons].Type)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].X)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Z)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Direction)
			if err != nil {
				return
			}
			err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil)
			if err != nil {
				return
			}
			if (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil {
				err = (*(*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName).Encode(w)
				if err != nil {
					return
				}
			}
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Columns)
	if err != nil {
		return
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Rows.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Rows.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Rows.(uint8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.X.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.X.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.X.(uint8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Y.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Y.(uint8)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Y.(uint8))
		if err != nil {
			return
		}
	}
	switch ret.Columns {
	case 0:
		_, ok := ret.Data.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	default:
		_, ok := ret.Data.([]byte)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte))))
		if err != nil {
			return
		}
		_, err = w.Write(ret.Data.([]byte))
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketMapChunk struct {
	X          int32
	Z          int32
	Heightmaps []struct {
		Type string
		Data []int64
	}
	ChunkData           ByteArray
	BlockEntities       []ChunkBlockEntity
	SkyLightMask        []int64
	BlockLightMask      []int64
	EmptySkyLightMask   []int64
	EmptyBlockLightMask []int64
	SkyLight            [][]uint8
	BlockLight          [][]uint8
}

var PlayToClientPacketMapChunkHeightmapsElementTypeMap = map[int32]string{0: "world_surface_wg", 1: "world_surface", 2: "ocean_floor_wg", 3: "ocean_floor", 4: "motion_blocking", 5: "motion_blocking_no_leaves"}

func (ret *PlayToClientPacketMapChunk) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	var lPlayToClientPacketMapChunkHeightmaps int32
	lPlayToClientPacketMapChunkHeightmaps, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Heightmaps = []struct {
		Type string
		Data []int64
	}{}
	for range lPlayToClientPacketMapChunkHeightmaps {
		var PlayToClientPacketMapChunkHeightmapsElement struct {
			Type string
			Data []int64
		}
		var PlayToClientPacketMapChunkHeightmapsElementTypeKey int32
		PlayToClientPacketMapChunkHeightmapsElementTypeKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapChunkHeightmapsElement.Type, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsElementTypeMap, PlayToClientPacketMapChunkHeightmapsElementTypeKey)
		if err != nil {
			return
		}
		var lPlayToClientPacketMapChunkHeightmapsElementData int32
		lPlayToClientPacketMapChunkHeightmapsElementData, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapChunkHeightmapsElement.Data = []int64{}
		for range lPlayToClientPacketMapChunkHeightmapsElementData {
			var PlayToClientPacketMapChunkHeightmapsElementDataElement int64
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkHeightmapsElementDataElement)
			if err != nil {
				return
			}
			PlayToClientPacketMapChunkHeightmapsElement.Data = append(PlayToClientPacketMapChunkHeightmapsElement.Data, PlayToClientPacketMapChunkHeightmapsElementDataElement)
		}
		ret.Heightmaps = append(ret.Heightmaps, PlayToClientPacketMapChunkHeightmapsElement)
	}
	err = ret.ChunkData.Decode(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketMapChunkBlockEntities int32
	lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockEntities = []ChunkBlockEntity{}
	for range lPlayToClientPacketMapChunkBlockEntities {
		var PlayToClientPacketMapChunkBlockEntitiesElement ChunkBlockEntity
		err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r)
		if err != nil {
			return
		}
		ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement)
	}
	var lPlayToClientPacketMapChunkSkyLightMask int32
	lPlayToClientPacketMapChunkSkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SkyLightMask = []int64{}
	for range lPlayToClientPacketMapChunkSkyLightMask {
		var PlayToClientPacketMapChunkSkyLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightMaskElement)
		if err != nil {
			return
		}
		ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketMapChunkSkyLightMaskElement)
	}
	var lPlayToClientPacketMapChunkBlockLightMask int32
	lPlayToClientPacketMapChunkBlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockLightMask = []int64{}
	for range lPlayToClientPacketMapChunkBlockLightMask {
		var PlayToClientPacketMapChunkBlockLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightMaskElement)
		if err != nil {
			return
		}
		ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketMapChunkBlockLightMaskElement)
	}
	var lPlayToClientPacketMapChunkEmptySkyLightMask int32
	lPlayToClientPacketMapChunkEmptySkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptySkyLightMask = []int64{}
	for range lPlayToClientPacketMapChunkEmptySkyLightMask {
		var PlayToClientPacketMapChunkEmptySkyLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptySkyLightMaskElement)
		if err != nil {
			return
		}
		ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketMapChunkEmptySkyLightMaskElement)
	}
	var lPlayToClientPacketMapChunkEmptyBlockLightMask int32
	lPlayToClientPacketMapChunkEmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptyBlockLightMask = []int64{}
	for range lPlayToClientPacketMapChunkEmptyBlockLightMask {
		var PlayToClientPacketMapChunkEmptyBlockLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptyBlockLightMaskElement)
		if err != nil {
			return
		}
		ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketMapChunkEmptyBlockLightMaskElement)
	}
	var lPlayToClientPacketMapChunkSkyLight int32
	lPlayToClientPacketMapChunkSkyLight, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SkyLight = [][]uint8{}
	for range lPlayToClientPacketMapChunkSkyLight {
		var PlayToClientPacketMapChunkSkyLightElement []uint8
		var lPlayToClientPacketMapChunkSkyLightElement int32
		lPlayToClientPacketMapChunkSkyLightElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapChunkSkyLightElement = []uint8{}
		for range lPlayToClientPacketMapChunkSkyLightElement {
			var PlayToClientPacketMapChunkSkyLightElementElement uint8
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightElementElement)
			if err != nil {
				return
			}
			PlayToClientPacketMapChunkSkyLightElement = append(PlayToClientPacketMapChunkSkyLightElement, PlayToClientPacketMapChunkSkyLightElementElement)
		}
		ret.SkyLight = append(ret.SkyLight, PlayToClientPacketMapChunkSkyLightElement)
	}
	var lPlayToClientPacketMapChunkBlockLight int32
	lPlayToClientPacketMapChunkBlockLight, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockLight = [][]uint8{}
	for range lPlayToClientPacketMapChunkBlockLight {
		var PlayToClientPacketMapChunkBlockLightElement []uint8
		var lPlayToClientPacketMapChunkBlockLightElement int32
		lPlayToClientPacketMapChunkBlockLightElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketMapChunkBlockLightElement = []uint8{}
		for range lPlayToClientPacketMapChunkBlockLightElement {
			var PlayToClientPacketMapChunkBlockLightElementElement uint8
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightElementElement)
			if err != nil {
				return
			}
			PlayToClientPacketMapChunkBlockLightElement = append(PlayToClientPacketMapChunkBlockLightElement, PlayToClientPacketMapChunkBlockLightElementElement)
		}
		ret.BlockLight = append(ret.BlockLight, PlayToClientPacketMapChunkBlockLightElement)
	}
	return
}

var PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap = map[string]int32{"world_surface_wg": 0, "world_surface": 1, "ocean_floor_wg": 2, "ocean_floor": 3, "motion_blocking": 4, "motion_blocking_no_leaves": 5}

func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkHeightmaps := range len(ret.Heightmaps) {
		var vPlayToClientPacketMapChunkHeightmapsInnerType int32
		vPlayToClientPacketMapChunkHeightmapsInnerType, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Type)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketMapChunkHeightmapsInnerType)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data)))
		if err != nil {
			return
		}
		for iPlayToClientPacketMapChunkHeightmapsInnerData := range len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data) {
			err = binary.Write(w, binary.BigEndian, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data[iPlayToClientPacketMapChunkHeightmapsInnerData])
			if err != nil {
				return
			}
		}
	}
	err = ret.ChunkData.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) {
		err = ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities].Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkSkyLightMask := range len(ret.SkyLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketMapChunkSkyLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkBlockLightMask := range len(ret.BlockLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketMapChunkBlockLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkEmptySkyLightMask := range len(ret.EmptySkyLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketMapChunkEmptySkyLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketMapChunkEmptyBlockLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkSkyLight := range len(ret.SkyLight) {
		err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight])))
		if err != nil {
			return
		}
		for iPlayToClientPacketMapChunkSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]) {
			err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketMapChunkSkyLight][iPlayToClientPacketMapChunkSkyLightInner])
			if err != nil {
				return
			}
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMapChunkBlockLight := range len(ret.BlockLight) {
		err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight])))
		if err != nil {
			return
		}
		for iPlayToClientPacketMapChunkBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]) {
			err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketMapChunkBlockLight][iPlayToClientPacketMapChunkBlockLightInner])
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketMoveMinecart struct {
	EntityId int32
	Steps    []struct {
		Position Vec3f
		Velocity Vec3f
		Yaw      float32
		Pitch    float32
		Weight   float32
	}
}

func (ret *PlayToClientPacketMoveMinecart) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketMoveMinecartSteps int32
	lPlayToClientPacketMoveMinecartSteps, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Steps = []struct {
		Position Vec3f
		Velocity Vec3f
		Yaw      float32
		Pitch    float32
		Weight   float32
	}{}
	for range lPlayToClientPacketMoveMinecartSteps {
		var PlayToClientPacketMoveMinecartStepsElement struct {
			Position Vec3f
			Velocity Vec3f
			Yaw      float32
			Pitch    float32
			Weight   float32
		}
		err = PlayToClientPacketMoveMinecartStepsElement.Position.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketMoveMinecartStepsElement.Velocity.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Yaw)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Pitch)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Weight)
		if err != nil {
			return
		}
		ret.Steps = append(ret.Steps, PlayToClientPacketMoveMinecartStepsElement)
	}
	return
}
func (ret *PlayToClientPacketMoveMinecart) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Steps)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMoveMinecartSteps := range len(ret.Steps) {
		err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Position.Encode(w)
		if err != nil {
			return
		}
		err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Velocity.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Yaw)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Pitch)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Weight)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketMultiBlockChange struct {
	ChunkCoordinates struct {
		X int32
		Z int32
		Y int32
	}
	Records []int32
}

func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.Reader) (err error) {
	var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
	if err != nil {
		return
	}
	ret.ChunkCoordinates.X = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked << 0 >> 42)
	if ret.ChunkCoordinates.X >= 1<<21 {
		ret.ChunkCoordinates.X -= 1 << 22
	}
	ret.ChunkCoordinates.Z = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked << 22 >> 42)
	if ret.ChunkCoordinates.Z >= 1<<21 {
		ret.ChunkCoordinates.Z -= 1 << 22
	}
	ret.ChunkCoordinates.Y = int32(PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked << 44 >> 44)
	if ret.ChunkCoordinates.Y >= 1<<19 {
		ret.ChunkCoordinates.Y -= 1 << 20
	}
	var lPlayToClientPacketMultiBlockChangeRecords int32
	lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Records = []int32{}
	for range lPlayToClientPacketMultiBlockChangeRecords {
		var PlayToClientPacketMultiBlockChangeRecordsElement int32
		PlayToClientPacketMultiBlockChangeRecordsElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement)
	}
	return
}
func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) {
	var PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked uint64
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Y) & 0xFFFFF) << 0x0
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.Z) & 0x3FFFFF) << 0x14
	PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked |= (uint64(ret.ChunkCoordinates.X) & 0x3FFFFF) << 0x2A
	err = binary.Write(w, binary.BigEndian, PlayToClientPacketMultiBlockChangeChunkCoordinatesPacked)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Records)))
	if err != nil {
		return
	}
	for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) {
		err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketNbtQueryResponse struct {
	TransactionId int32
	Nbt           nbt.Anon
}

func (ret *PlayToClientPacketNbtQueryResponse) Decode(r io.Reader) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Nbt.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = ret.Nbt.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenBook struct {
	Hand int32
}

func (ret *PlayToClientPacketOpenBook) Decode(r io.Reader) (err error) {
	ret.Hand, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketOpenBook) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Hand)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenHorseWindow struct {
	WindowId ContainerID
	NbSlots  int32
	EntityId int32
}

func (ret *PlayToClientPacketOpenHorseWindow) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	ret.NbSlots, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.EntityId)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketOpenHorseWindow) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.NbSlots)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.EntityId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenSignEntity struct {
	Location    Position
	IsFrontText bool
}

func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFrontText)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketOpenSignEntity) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFrontText)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketOpenWindow struct {
	WindowId      int32
	InventoryType int32
	WindowTitle   nbt.Anon
}

func (ret *PlayToClientPacketOpenWindow) Decode(r io.Reader) (err error) {
	ret.WindowId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.InventoryType, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.WindowTitle.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.WindowId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.InventoryType)
	if err != nil {
		return
	}
	err = ret.WindowTitle.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPing struct {
	Id int32
}

func (ret *PlayToClientPacketPing) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPing) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPingResponse struct {
	Id int64
}

func (ret *PlayToClientPacketPingResponse) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Id)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPingResponse) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPlayerChat struct {
	GlobalIndex         int32
	SenderUuid          uuid.UUID
	Index               int32
	Signature           *[256]byte
	PlainMessage        string
	Timestamp           int64
	Salt                int64
	PreviousMessages    PreviousMessages
	UnsignedChatContent *nbt.Anon
	FilterType          int32
	FilterTypeMask      any
	Type                PlayToClientChatTypesHolder
	NetworkName         nbt.Anon
	NetworkTargetName   *nbt.Anon
}

func (ret *PlayToClientPacketPlayerChat) Decode(r io.Reader) (err error) {
	ret.GlobalIndex, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = io.ReadFull(r, ret.SenderUuid[:])
	if err != nil {
		return
	}
	ret.Index, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var PlayToClientPacketPlayerChatSignaturePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatSignaturePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketPlayerChatSignaturePresent {
		var PlayToClientPacketPlayerChatSignaturePresentValue [256]byte
		_, err = r.Read(PlayToClientPacketPlayerChatSignaturePresentValue[:])
		if err != nil {
			return
		}
		ret.Signature = &PlayToClientPacketPlayerChatSignaturePresentValue
	}
	ret.PlainMessage, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Salt)
	if err != nil {
		return
	}
	err = ret.PreviousMessages.Decode(r)
	if err != nil {
		return
	}
	var PlayToClientPacketPlayerChatUnsignedChatContentPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatUnsignedChatContentPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketPlayerChatUnsignedChatContentPresent {
		var PlayToClientPacketPlayerChatUnsignedChatContentPresentValue nbt.Anon
		err = PlayToClientPacketPlayerChatUnsignedChatContentPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.UnsignedChatContent = &PlayToClientPacketPlayerChatUnsignedChatContentPresentValue
	}
	ret.FilterType, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	switch ret.FilterType {
	case 2:
		var PlayToClientPacketPlayerChatFilterTypeMask2Tmp []int64
		var lPlayToClientPacketPlayerChatFilterTypeMask int32
		lPlayToClientPacketPlayerChatFilterTypeMask, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketPlayerChatFilterTypeMask2Tmp = []int64{}
		for range lPlayToClientPacketPlayerChatFilterTypeMask {
			var PlayToClientPacketPlayerChatFilterTypeMaskElement int64
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatFilterTypeMaskElement)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerChatFilterTypeMask2Tmp = append(PlayToClientPacketPlayerChatFilterTypeMask2Tmp, PlayToClientPacketPlayerChatFilterTypeMaskElement)
		}
		ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMask2Tmp
	default:
		var PlayToClientPacketPlayerChatFilterTypeMaskTmp struct {
		}
		ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp
	}
	err = ret.Type.Decode(r)
	if err != nil {
		return
	}
	err = ret.NetworkName.Decode(r)
	if err != nil {
		return
	}
	var PlayToClientPacketPlayerChatNetworkTargetNamePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatNetworkTargetNamePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketPlayerChatNetworkTargetNamePresent {
		var PlayToClientPacketPlayerChatNetworkTargetNamePresentValue nbt.Anon
		err = PlayToClientPacketPlayerChatNetworkTargetNamePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.NetworkTargetName = &PlayToClientPacketPlayerChatNetworkTargetNamePresentValue
	}
	return
}
func (ret *PlayToClientPacketPlayerChat) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.GlobalIndex)
	if err != nil {
		return
	}
	_, err = w.Write(ret.SenderUuid[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Index)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Signature != nil)
	if err != nil {
		return
	}
	if ret.Signature != nil {
		arr := *ret.Signature
		_, err = w.Write(arr[:])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeString(w, ret.PlainMessage)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Timestamp)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Salt)
	if err != nil {
		return
	}
	err = ret.PreviousMessages.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.UnsignedChatContent != nil)
	if err != nil {
		return
	}
	if ret.UnsignedChatContent != nil {
		err = (*ret.UnsignedChatContent).Encode(w)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.FilterType)
	if err != nil {
		return
	}
	switch ret.FilterType {
	case 2:
		PlayToClientPacketPlayerChatFilterTypeMask, ok := ret.FilterTypeMask.([]int64)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerChatFilterTypeMask)))
		if err != nil {
			return
		}
		for iPlayToClientPacketPlayerChatFilterTypeMask := range len(PlayToClientPacketPlayerChatFilterTypeMask) {
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerChatFilterTypeMask[iPlayToClientPacketPlayerChatFilterTypeMask])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.FilterTypeMask.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	err = ret.Type.Encode(w)
	if err != nil {
		return
	}
	err = ret.NetworkName.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.NetworkTargetName != nil)
	if err != nil {
		return
	}
	if ret.NetworkTargetName != nil {
		err = (*ret.NetworkTargetName).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketPlayerInfo struct {
	Action uint8
	Data   []struct {
		Uuid         uuid.UUID
		Player       any
		ChatSession  any
		Gamemode     any
		Listed       any
		Latency      any
		DisplayName  any
		ListPriority any
		ShowHat      any
	}
}

func (ret *PlayToClientPacketPlayerInfo) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	var lPlayToClientPacketPlayerInfoData int32
	lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Data = []struct {
		Uuid         uuid.UUID
		Player       any
		ChatSession  any
		Gamemode     any
		Listed       any
		Latency      any
		DisplayName  any
		ListPriority any
		ShowHat      any
	}{}
	for range lPlayToClientPacketPlayerInfoData {
		var PlayToClientPacketPlayerInfoDataElement struct {
			Uuid         uuid.UUID
			Player       any
			ChatSession  any
			Gamemode     any
			Listed       any
			Latency      any
			DisplayName  any
			ListPriority any
			ShowHat      any
		}
		_, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:])
		if err != nil {
			return
		}
		switch ret.Action&0x1 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp GameProfileNameProp
			err = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementPlayerTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp
		}
		switch ret.Action&0x2 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp ChatSession
			err = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementChatSessionTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp
		}
		switch ret.Action&0x4 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp int32
			PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementGamemodeTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp
		}
		switch ret.Action&0x8 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementListedTrueTmp int32
			PlayToClientPacketPlayerInfoDataElementListedTrueTmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementListedTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp
		}
		switch ret.Action&0x10 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp int32
			PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementLatencyTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp
		}
		switch ret.Action&0x20 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp *nbt.Anon
			var PlayToClientPacketPlayerInfoDataElementDisplayNamePresent bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementDisplayNamePresent)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataElementDisplayNamePresent {
				var PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue nbt.Anon
				err = PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue.Decode(r)
				if err != nil {
					return
				}
				PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp = &PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue
			}
			PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp
		}
		switch ret.Action&0x80 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp int32
			PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementListPriorityTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTmp
		}
		switch ret.Action&0x40 != 0 {
		case true:
			var PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp bool
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp)
			if err != nil {
				return
			}
			PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp
		default:
			var PlayToClientPacketPlayerInfoDataElementShowHatTmp struct {
			}
			PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTmp
		}
		ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement)
	}
	return
}
func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Data)))
	if err != nil {
		return
	}
	for iPlayToClientPacketPlayerInfoData := range len(ret.Data) {
		_, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:])
		if err != nil {
			return
		}
		switch ret.Action&0x1 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerPlayer, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(GameProfileNameProp)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketPlayerInfoDataInnerPlayer.Encode(w)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x2 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerChatSession, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(ChatSession)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketPlayerInfoDataInnerChatSession.Encode(w)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x4 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerGamemode, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerGamemode)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x8 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerListed, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListed)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x10 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerLatency, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerLatency)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x20 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerDisplayName, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(*nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerDisplayName != nil)
			if err != nil {
				return
			}
			if PlayToClientPacketPlayerInfoDataInnerDisplayName != nil {
				err = (*PlayToClientPacketPlayerInfoDataInnerDisplayName).Encode(w)
				if err != nil {
					return
				}
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x80 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerListPriority, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(int32)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListPriority)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
		switch ret.Action&0x40 != 0 {
		case true:
			PlayToClientPacketPlayerInfoDataInnerShowHat, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(bool)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerShowHat)
			if err != nil {
				return
			}
		default:
			_, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
	}
	return
}

type PlayToClientPacketPlayerRemove struct {
	Players []uuid.UUID
}

func (ret *PlayToClientPacketPlayerRemove) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketPlayerRemovePlayers int32
	lPlayToClientPacketPlayerRemovePlayers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Players = []uuid.UUID{}
	for range lPlayToClientPacketPlayerRemovePlayers {
		var PlayToClientPacketPlayerRemovePlayersElement uuid.UUID
		_, err = io.ReadFull(r, PlayToClientPacketPlayerRemovePlayersElement[:])
		if err != nil {
			return
		}
		ret.Players = append(ret.Players, PlayToClientPacketPlayerRemovePlayersElement)
	}
	return
}
func (ret *PlayToClientPacketPlayerRemove) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Players)))
	if err != nil {
		return
	}
	for iPlayToClientPacketPlayerRemovePlayers := range len(ret.Players) {
		_, err = w.Write(ret.Players[iPlayToClientPacketPlayerRemovePlayers][:])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketPlayerRotation struct {
	Yaw           float32
	RelativeYaw   bool
	Pitch         float32
	RelativePitch bool
}

func (ret *PlayToClientPacketPlayerRotation) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.RelativeYaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.RelativePitch)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPlayerRotation) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.RelativeYaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.RelativePitch)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPlayerlistHeader struct {
	Header nbt.Anon
	Footer nbt.Anon
}

func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.Reader) (err error) {
	err = ret.Header.Decode(r)
	if err != nil {
		return
	}
	err = ret.Footer.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) {
	err = ret.Header.Encode(w)
	if err != nil {
		return
	}
	err = ret.Footer.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketPosition struct {
	TeleportId int32
	X          float64
	Y          float64
	Z          float64
	Dx         float64
	Dy         float64
	Dz         float64
	Yaw        float32
	Pitch      float32
	Flags      PlayToClientPositionUpdateRelatives
}

func (ret *PlayToClientPacketPosition) Decode(r io.Reader) (err error) {
	ret.TeleportId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dx)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dy)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dz)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TeleportId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dx)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dy)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dz)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = ret.Flags.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketProfilelessChat struct {
	Message nbt.Anon
	Type    PlayToClientChatTypesHolder
	Name    nbt.Anon
	Target  *nbt.Anon
}

func (ret *PlayToClientPacketProfilelessChat) Decode(r io.Reader) (err error) {
	err = ret.Message.Decode(r)
	if err != nil {
		return
	}
	err = ret.Type.Decode(r)
	if err != nil {
		return
	}
	err = ret.Name.Decode(r)
	if err != nil {
		return
	}
	var PlayToClientPacketProfilelessChatTargetPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketProfilelessChatTargetPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketProfilelessChatTargetPresent {
		var PlayToClientPacketProfilelessChatTargetPresentValue nbt.Anon
		err = PlayToClientPacketProfilelessChatTargetPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Target = &PlayToClientPacketProfilelessChatTargetPresentValue
	}
	return
}
func (ret *PlayToClientPacketProfilelessChat) Encode(w io.Writer) (err error) {
	err = ret.Message.Encode(w)
	if err != nil {
		return
	}
	err = ret.Type.Encode(w)
	if err != nil {
		return
	}
	err = ret.Name.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Target != nil)
	if err != nil {
		return
	}
	if ret.Target != nil {
		err = (*ret.Target).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketRecipeBookAdd struct {
	Entries []struct {
		Recipe struct {
			DisplayId            int32
			Display              PlayToClientRecipeDisplay
			Group                Optvarint
			Category             string
			CraftingRequirements *[]IDSet
		}
		Flags uint8
	}
	Replace bool
}

var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap = map[int32]string{0: "crafting_building_blocks", 1: "crafting_redstone", 10: "stonecutter", 11: "smithing", 12: "campfire", 2: "crafting_equipment", 3: "crafting_misc", 4: "furnace_food", 5: "furnace_blocks", 6: "furnace_misc", 7: "blast_furnace_blocks", 8: "blast_furnace_misc", 9: "smoker_food"}

func (ret *PlayToClientPacketRecipeBookAdd) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketRecipeBookAddEntries int32
	lPlayToClientPacketRecipeBookAddEntries, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Entries = []struct {
		Recipe struct {
			DisplayId            int32
			Display              PlayToClientRecipeDisplay
			Group                Optvarint
			Category             string
			CraftingRequirements *[]IDSet
		}
		Flags uint8
	}{}
	for range lPlayToClientPacketRecipeBookAddEntries {
		var PlayToClientPacketRecipeBookAddEntriesElement struct {
			Recipe struct {
				DisplayId            int32
				Display              PlayToClientRecipeDisplay
				Group                Optvarint
				Category             string
				CraftingRequirements *[]IDSet
			}
			Flags uint8
		}
		PlayToClientPacketRecipeBookAddEntriesElement.Recipe.DisplayId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Display.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Group.Decode(r)
		if err != nil {
			return
		}
		var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey int32
		PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Category, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap, PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey)
		if err != nil {
			return
		}
		var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent {
			var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue []IDSet
			var lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements int32
			lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = []IDSet{}
			for range lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements {
				var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement IDSet
				err = PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement.Decode(r)
				if err != nil {
					return
				}
				PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = append(PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue, PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement)
			}
			PlayToClientPacketRecipeBookAddEntriesElement.Recipe.CraftingRequirements = &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElement.Flags)
		if err != nil {
			return
		}
		ret.Entries = append(ret.Entries, PlayToClientPacketRecipeBookAddEntriesElement)
	}
	err = binary.Read(r, binary.BigEndian, &ret.Replace)
	if err != nil {
		return
	}
	return
}

var PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap = map[string]int32{"crafting_building_blocks": 0, "crafting_redstone": 1, "stonecutter": 10, "smithing": 11, "campfire": 12, "crafting_equipment": 2, "crafting_misc": 3, "furnace_food": 4, "furnace_blocks": 5, "furnace_misc": 6, "blast_furnace_blocks": 7, "blast_furnace_misc": 8, "smoker_food": 9}

func (ret *PlayToClientPacketRecipeBookAdd) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
	if err != nil {
		return
	}
	for iPlayToClientPacketRecipeBookAddEntries := range len(ret.Entries) {
		err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.DisplayId)
		if err != nil {
			return
		}
		err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Display.Encode(w)
		if err != nil {
			return
		}
		err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Group.Encode(w)
		if err != nil {
			return
		}
		var vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory int32
		vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Category)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil)
		if err != nil {
			return
		}
		if ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil {
			err = proto_base.EncodeVarInt(w, int32(len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)))
			if err != nil {
				return
			}
			for iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements := range len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements) {
				err = (*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)[iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements].Encode(w)
				if err != nil {
					return
				}
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Flags)
		if err != nil {
			return
		}
	}
	err = binary.Write(w, binary.BigEndian, ret.Replace)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRecipeBookRemove struct {
	RecipeIds []int32
}

func (ret *PlayToClientPacketRecipeBookRemove) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketRecipeBookRemoveRecipeIds int32
	lPlayToClientPacketRecipeBookRemoveRecipeIds, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.RecipeIds = []int32{}
	for range lPlayToClientPacketRecipeBookRemoveRecipeIds {
		var PlayToClientPacketRecipeBookRemoveRecipeIdsElement int32
		PlayToClientPacketRecipeBookRemoveRecipeIdsElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.RecipeIds = append(ret.RecipeIds, PlayToClientPacketRecipeBookRemoveRecipeIdsElement)
	}
	return
}
func (ret *PlayToClientPacketRecipeBookRemove) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.RecipeIds)))
	if err != nil {
		return
	}
	for iPlayToClientPacketRecipeBookRemoveRecipeIds := range len(ret.RecipeIds) {
		err = proto_base.EncodeVarInt(w, ret.RecipeIds[iPlayToClientPacketRecipeBookRemoveRecipeIds])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketRecipeBookSettings struct {
	Crafting PlayToClientRecipeBookSetting
	Furnace  PlayToClientRecipeBookSetting
	Blast    PlayToClientRecipeBookSetting
	Smoker   PlayToClientRecipeBookSetting
}

func (ret *PlayToClientPacketRecipeBookSettings) Decode(r io.Reader) (err error) {
	err = ret.Crafting.Decode(r)
	if err != nil {
		return
	}
	err = ret.Furnace.Decode(r)
	if err != nil {
		return
	}
	err = ret.Blast.Decode(r)
	if err != nil {
		return
	}
	err = ret.Smoker.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRecipeBookSettings) Encode(w io.Writer) (err error) {
	err = ret.Crafting.Encode(w)
	if err != nil {
		return
	}
	err = ret.Furnace.Encode(w)
	if err != nil {
		return
	}
	err = ret.Blast.Encode(w)
	if err != nil {
		return
	}
	err = ret.Smoker.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRelEntityMove struct {
	EntityId int32
	DX       int16
	DY       int16
	DZ       int16
	OnGround bool
}

func (ret *PlayToClientPacketRelEntityMove) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.DZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.DZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketRemoveEntityEffect struct {
	EntityId int32
	EffectId int32
}

func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EffectId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.EffectId)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketResetScore struct {
	EntityName    string
	ObjectiveName *string
}

func (ret *PlayToClientPacketResetScore) Decode(r io.Reader) (err error) {
	ret.EntityName, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToClientPacketResetScoreObjectiveNamePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketResetScoreObjectiveNamePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketResetScoreObjectiveNamePresent {
		var PlayToClientPacketResetScoreObjectiveNamePresentValue string
		PlayToClientPacketResetScoreObjectiveNamePresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.ObjectiveName = &PlayToClientPacketResetScoreObjectiveNamePresentValue
	}
	return
}
func (ret *PlayToClientPacketResetScore) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.EntityName)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ObjectiveName != nil)
	if err != nil {
		return
	}
	if ret.ObjectiveName != nil {
		err = proto_base.EncodeString(w, *ret.ObjectiveName)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketRespawn struct {
	WorldState   PlayToClientSpawnInfo
	CopyMetadata uint8
}

func (ret *PlayToClientPacketRespawn) Decode(r io.Reader) (err error) {
	err = ret.WorldState.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CopyMetadata)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) {
	err = ret.WorldState.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CopyMetadata)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketScoreboardDisplayObjective struct {
	Position int32
	Name     string
}

func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.Reader) (err error) {
	ret.Position, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketScoreboardDisplayObjective) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Position)
	if err != nil {
		return
	}
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketScoreboardObjective struct {
	Name         string
	Action       int8
	DisplayText  any
	Type         any
	NumberFormat any
	Styling      any
}

func (ret *PlayToClientPacketScoreboardObjective) Decode(r io.Reader) (err error) {
	ret.Name, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveDisplayText0Tmp nbt.Anon
		err = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp.Decode(r)
		if err != nil {
			return
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp nbt.Anon
		err = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp.Decode(r)
		if err != nil {
			return
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveDisplayTextTmp struct {
		}
		ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveType0Tmp int32
		PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveType2Tmp int32
		PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveType2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveTypeTmp struct {
		}
		ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp *int32
		var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketScoreboardObjectiveNumberFormatPresent {
			var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue int32
			PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue
		}
		ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp *int32
		var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketScoreboardObjectiveNumberFormatPresent {
			var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue int32
			PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue
		}
		ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveNumberFormatTmp struct {
		}
		ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp
	}
	switch ret.Action {
	case 0:
		var PlayToClientPacketScoreboardObjectiveStyling0Tmp any
		switch ret.NumberFormat {
		case 1:
			var PlayToClientPacketScoreboardObjectiveStyling1Tmp nbt.Anon
			err = PlayToClientPacketScoreboardObjectiveStyling1Tmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling1Tmp
		case 2:
			var PlayToClientPacketScoreboardObjectiveStyling2Tmp nbt.Anon
			err = PlayToClientPacketScoreboardObjectiveStyling2Tmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp
		default:
			var PlayToClientPacketScoreboardObjectiveStylingTmp struct {
			}
			PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStylingTmp
		}
		ret.Styling = PlayToClientPacketScoreboardObjectiveStyling0Tmp
	case 2:
		var PlayToClientPacketScoreboardObjectiveStyling2Tmp any
		switch ret.NumberFormat {
		case 1:
			var PlayToClientPacketScoreboardObjectiveStyling1Tmp nbt.Anon
			err = PlayToClientPacketScoreboardObjectiveStyling1Tmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling1Tmp
		case 2:
			var PlayToClientPacketScoreboardObjectiveStyling2Tmp nbt.Anon
			err = PlayToClientPacketScoreboardObjectiveStyling2Tmp.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp
		default:
			var PlayToClientPacketScoreboardObjectiveStylingTmp struct {
			}
			PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStylingTmp
		}
		ret.Styling = PlayToClientPacketScoreboardObjectiveStyling2Tmp
	default:
		var PlayToClientPacketScoreboardObjectiveStylingTmp struct {
		}
		ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp
	}
	return
}
func (ret *PlayToClientPacketScoreboardObjective) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Name)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Action)
	if err != nil {
		return
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w)
		if err != nil {
			return
		}
	default:
		_, ok := ret.DisplayText.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
		if err != nil {
			return
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Type.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
		if err != nil {
			return
		}
		if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
			err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat)
			if err != nil {
				return
			}
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil)
		if err != nil {
			return
		}
		if PlayToClientPacketScoreboardObjectiveNumberFormat != nil {
			err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat)
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.NumberFormat.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Action {
	case 0:
		PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		switch ret.NumberFormat {
		case 1:
			PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
			if err != nil {
				return
			}
		case 2:
			PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
			if err != nil {
				return
			}
		default:
			_, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
	case 2:
		PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		switch ret.NumberFormat {
		case 1:
			PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
			if err != nil {
				return
			}
		case 2:
			PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon)
			if !ok {
				err = proto_base.BadTypeError
				return
			}
			err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w)
			if err != nil {
				return
			}
		default:
			_, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct {
			})
			if !ok {
				err = proto_base.BadTypeError
				return
			}
		}
	default:
		_, ok := ret.Styling.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketScoreboardScore struct {
	ItemName     string
	ScoreName    string
	Value        int32
	DisplayName  *nbt.Anon
	NumberFormat *int32
	Styling      any
}

func (ret *PlayToClientPacketScoreboardScore) Decode(r io.Reader) (err error) {
	err = proto_base.ToDoError
	return
}
func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) {
	err = proto_base.ToDoError
	return
}

type PlayToClientPacketSelectAdvancementTab struct {
	Id *string
}

func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.Reader) (err error) {
	var PlayToClientPacketSelectAdvancementTabIdPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketSelectAdvancementTabIdPresent {
		var PlayToClientPacketSelectAdvancementTabIdPresentValue string
		PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue
	}
	return
}
func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Id != nil)
	if err != nil {
		return
	}
	if ret.Id != nil {
		err = proto_base.EncodeString(w, *ret.Id)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketServerData struct {
	Motd      nbt.Anon
	IconBytes *ByteArray
}

func (ret *PlayToClientPacketServerData) Decode(r io.Reader) (err error) {
	err = ret.Motd.Decode(r)
	if err != nil {
		return
	}
	var PlayToClientPacketServerDataIconBytesPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketServerDataIconBytesPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketServerDataIconBytesPresent {
		var PlayToClientPacketServerDataIconBytesPresentValue ByteArray
		err = PlayToClientPacketServerDataIconBytesPresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.IconBytes = &PlayToClientPacketServerDataIconBytesPresentValue
	}
	return
}
func (ret *PlayToClientPacketServerData) Encode(w io.Writer) (err error) {
	err = ret.Motd.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IconBytes != nil)
	if err != nil {
		return
	}
	if ret.IconBytes != nil {
		err = (*ret.IconBytes).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketSetCooldown struct {
	CooldownGroup string
	CooldownTicks int32
}

func (ret *PlayToClientPacketSetCooldown) Decode(r io.Reader) (err error) {
	ret.CooldownGroup, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	ret.CooldownTicks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetCooldown) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.CooldownGroup)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.CooldownTicks)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetCursorItem struct {
	Contents Slot
}

func (ret *PlayToClientPacketSetCursorItem) Decode(r io.Reader) (err error) {
	err = ret.Contents.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetCursorItem) Encode(w io.Writer) (err error) {
	err = ret.Contents.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetPassengers struct {
	EntityId   int32
	Passengers []int32
}

func (ret *PlayToClientPacketSetPassengers) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketSetPassengersPassengers int32
	lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Passengers = []int32{}
	for range lPlayToClientPacketSetPassengersPassengers {
		var PlayToClientPacketSetPassengersPassengersElement int32
		PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement)
	}
	return
}
func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers)))
	if err != nil {
		return
	}
	for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) {
		err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers])
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketSetPlayerInventory struct {
	SlotId   int32
	Contents Slot
}

func (ret *PlayToClientPacketSetPlayerInventory) Decode(r io.Reader) (err error) {
	ret.SlotId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.Contents.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetPlayerInventory) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.SlotId)
	if err != nil {
		return
	}
	err = ret.Contents.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetProjectilePower struct {
	Id                int32
	AccelerationPower float64
}

func (ret *PlayToClientPacketSetProjectilePower) Decode(r io.Reader) (err error) {
	ret.Id, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.AccelerationPower)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetProjectilePower) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Id)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.AccelerationPower)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetSlot struct {
	WindowId ContainerID
	StateId  int32
	Slot     int16
	Item     Slot
}

func (ret *PlayToClientPacketSetSlot) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	ret.StateId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.StateId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Slot)
	if err != nil {
		return
	}
	err = ret.Item.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetTickingState struct {
	TickRate float32
	IsFrozen bool
}

func (ret *PlayToClientPacketSetTickingState) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.TickRate)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsFrozen)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetTickingState) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.TickRate)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsFrozen)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetTitleSubtitle struct {
	Text nbt.Anon
}

func (ret *PlayToClientPacketSetTitleSubtitle) Decode(r io.Reader) (err error) {
	err = ret.Text.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetTitleSubtitle) Encode(w io.Writer) (err error) {
	err = ret.Text.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetTitleText struct {
	Text nbt.Anon
}

func (ret *PlayToClientPacketSetTitleText) Decode(r io.Reader) (err error) {
	err = ret.Text.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetTitleText) Encode(w io.Writer) (err error) {
	err = ret.Text.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSetTitleTime struct {
	FadeIn  int32
	Stay    int32
	FadeOut int32
}

func (ret *PlayToClientPacketSetTitleTime) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.FadeIn)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Stay)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FadeOut)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSetTitleTime) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.FadeIn)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Stay)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FadeOut)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketShowDialog struct {
	Dialog any
}

func (ret *PlayToClientPacketShowDialog) Decode(r io.Reader) (err error) {
	var PlayToClientPacketShowDialogDialogId int32
	PlayToClientPacketShowDialogDialogId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	if PlayToClientPacketShowDialogDialogId != 0 {
		ret.Dialog = PlayToClientPacketShowDialogDialogId
	} else {
		var PlayToClientPacketShowDialogDialogResult nbt.Anon
		err = PlayToClientPacketShowDialogDialogResult.Decode(r)
		if err != nil {
			return
		}
		ret.Dialog = PlayToClientPacketShowDialogDialogResult
	}
	return
}
func (ret *PlayToClientPacketShowDialog) Encode(w io.Writer) (err error) {
	switch PlayToClientPacketShowDialogDialogKnownType := ret.Dialog.(type) {
	case int32:
		err = proto_base.EncodeVarInt(w, PlayToClientPacketShowDialogDialogKnownType)
		if err != nil {
			return
		}
	case nbt.Anon:
		err = proto_base.EncodeVarInt(w, 0)
		if err != nil {
			return
		}
		err = PlayToClientPacketShowDialogDialogKnownType.Encode(w)
		if err != nil {
			return
		}
	default:
		err = proto_base.BadTypeError
	}
	return
}

type PlayToClientPacketSimulationDistance struct {
	Distance int32
}

func (ret *PlayToClientPacketSimulationDistance) Decode(r io.Reader) (err error) {
	ret.Distance, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSimulationDistance) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.Distance)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSoundEffect struct {
	Sound         ItemSoundHolder
	SoundCategory SoundSource
	X             int32
	Y             int32
	Z             int32
	Volume        float32
	Pitch         float32
	Seed          int64
}

func (ret *PlayToClientPacketSoundEffect) Decode(r io.Reader) (err error) {
	err = ret.Sound.Decode(r)
	if err != nil {
		return
	}
	err = ret.SoundCategory.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Volume)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Seed)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) {
	err = ret.Sound.Encode(w)
	if err != nil {
		return
	}
	err = ret.SoundCategory.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Volume)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Seed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnEntity struct {
	EntityId   int32
	ObjectUUID uuid.UUID
	Type       int32
	X          float64
	Y          float64
	Z          float64
	Velocity   proto_base.LpVec3d
	Pitch      int8
	Yaw        int8
	HeadPitch  int8
	ObjectData int32
}

func (ret *PlayToClientPacketSpawnEntity) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	_, err = io.ReadFull(r, ret.ObjectUUID[:])
	if err != nil {
		return
	}
	ret.Type, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = ret.Velocity.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.HeadPitch)
	if err != nil {
		return
	}
	ret.ObjectData, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	_, err = w.Write(ret.ObjectUUID[:])
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Type)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = ret.Velocity.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.HeadPitch)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ObjectData)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSpawnPosition struct {
	Val RespawnData
}

func (ret *PlayToClientPacketSpawnPosition) Decode(r io.Reader) (err error) {
	err = ret.Val.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) {
	err = ret.Val.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketStartConfiguration struct {
}

func (ret *PlayToClientPacketStartConfiguration) Decode(r io.Reader) (err error) {
	return
}
func (ret *PlayToClientPacketStartConfiguration) Encode(w io.Writer) (err error) {
	return
}

type PlayToClientPacketStatistics struct {
	Entries []struct {
		CategoryId  int32
		StatisticId int32
		Value       int32
	}
}

func (ret *PlayToClientPacketStatistics) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketStatisticsEntries int32
	lPlayToClientPacketStatisticsEntries, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Entries = []struct {
		CategoryId  int32
		StatisticId int32
		Value       int32
	}{}
	for range lPlayToClientPacketStatisticsEntries {
		var PlayToClientPacketStatisticsEntriesElement struct {
			CategoryId  int32
			StatisticId int32
			Value       int32
		}
		PlayToClientPacketStatisticsEntriesElement.CategoryId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketStatisticsEntriesElement.StatisticId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketStatisticsEntriesElement.Value, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement)
	}
	return
}
func (ret *PlayToClientPacketStatistics) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Entries)))
	if err != nil {
		return
	}
	for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) {
		err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].CategoryId)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].StatisticId)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketStepTick struct {
	TickSteps int32
}

func (ret *PlayToClientPacketStepTick) Decode(r io.Reader) (err error) {
	ret.TickSteps, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketStepTick) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TickSteps)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketStopSound struct {
	Flags  int8
	Source any
	Sound  any
}

func (ret *PlayToClientPacketStopSound) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Flags)
	if err != nil {
		return
	}
	switch ret.Flags {
	case 1:
		var PlayToClientPacketStopSoundSource1Tmp int32
		PlayToClientPacketStopSoundSource1Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Source = PlayToClientPacketStopSoundSource1Tmp
	case 3:
		var PlayToClientPacketStopSoundSource3Tmp int32
		PlayToClientPacketStopSoundSource3Tmp, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Source = PlayToClientPacketStopSoundSource3Tmp
	default:
		var PlayToClientPacketStopSoundSourceTmp struct {
		}
		ret.Source = PlayToClientPacketStopSoundSourceTmp
	}
	switch ret.Flags {
	case 2:
		var PlayToClientPacketStopSoundSound2Tmp string
		PlayToClientPacketStopSoundSound2Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Sound = PlayToClientPacketStopSoundSound2Tmp
	case 3:
		var PlayToClientPacketStopSoundSound3Tmp string
		PlayToClientPacketStopSoundSound3Tmp, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Sound = PlayToClientPacketStopSoundSound3Tmp
	default:
		var PlayToClientPacketStopSoundSoundTmp struct {
		}
		ret.Sound = PlayToClientPacketStopSoundSoundTmp
	}
	return
}
func (ret *PlayToClientPacketStopSound) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Flags)
	if err != nil {
		return
	}
	switch ret.Flags {
	case 1:
		PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketStopSoundSource, ok := ret.Source.(int32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Source.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Flags {
	case 2:
		PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
		if err != nil {
			return
		}
	case 3:
		PlayToClientPacketStopSoundSound, ok := ret.Sound.(string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Sound.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketSyncEntityPosition struct {
	EntityId int32
	X        float64
	Y        float64
	Z        float64
	Dx       float64
	Dy       float64
	Dz       float64
	Yaw      float32
	Pitch    float32
	OnGround bool
}

func (ret *PlayToClientPacketSyncEntityPosition) Decode(r io.Reader) (err error) {
	ret.EntityId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dx)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dy)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Dz)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OnGround)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSyncEntityPosition) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.EntityId)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dx)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dy)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Dz)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OnGround)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketSystemChat struct {
	Content     nbt.Anon
	IsActionBar bool
}

func (ret *PlayToClientPacketSystemChat) Decode(r io.Reader) (err error) {
	err = ret.Content.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsActionBar)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketSystemChat) Encode(w io.Writer) (err error) {
	err = ret.Content.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsActionBar)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketTabComplete struct {
	TransactionId int32
	Start         int32
	Length        int32
	Matches       []struct {
		Match   string
		Tooltip *nbt.Anon
	}
}

func (ret *PlayToClientPacketTabComplete) Decode(r io.Reader) (err error) {
	ret.TransactionId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Start, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Length, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketTabCompleteMatches int32
	lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Matches = []struct {
		Match   string
		Tooltip *nbt.Anon
	}{}
	for range lPlayToClientPacketTabCompleteMatches {
		var PlayToClientPacketTabCompleteMatchesElement struct {
			Match   string
			Tooltip *nbt.Anon
		}
		PlayToClientPacketTabCompleteMatchesElement.Match, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		var PlayToClientPacketTabCompleteMatchesElementTooltipPresent bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTabCompleteMatchesElementTooltipPresent)
		if err != nil {
			return
		}
		if PlayToClientPacketTabCompleteMatchesElementTooltipPresent {
			var PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue nbt.Anon
			err = PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketTabCompleteMatchesElement.Tooltip = &PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue
		}
		ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement)
	}
	return
}
func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.TransactionId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Start)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Length)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Matches)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) {
		err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches].Match)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil)
		if err != nil {
			return
		}
		if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil {
			err = (*ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip).Encode(w)
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketTags struct {
	Tags []struct {
		TagType string
		Tags    Tags
	}
}

func (ret *PlayToClientPacketTags) Decode(r io.Reader) (err error) {
	var lPlayToClientPacketTagsTags int32
	lPlayToClientPacketTagsTags, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Tags = []struct {
		TagType string
		Tags    Tags
	}{}
	for range lPlayToClientPacketTagsTags {
		var PlayToClientPacketTagsTagsElement struct {
			TagType string
			Tags    Tags
		}
		PlayToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTagsTagsElement.Tags.Decode(r)
		if err != nil {
			return
		}
		ret.Tags = append(ret.Tags, PlayToClientPacketTagsTagsElement)
	}
	return
}
func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, int32(len(ret.Tags)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTagsTags := range len(ret.Tags) {
		err = proto_base.EncodeString(w, ret.Tags[iPlayToClientPacketTagsTags].TagType)
		if err != nil {
			return
		}
		err = ret.Tags[iPlayToClientPacketTagsTags].Tags.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketTeams struct {
	Team    string
	Mode    string
	Anon    any
	Players any
}

var PlayToClientPacketTeamsModeMap = map[int8]string{0: "add", 1: "remove", 2: "change", 3: "join", 4: "leave"}
var PlayToClientPacketTeamsAnonNameTagVisibilityMap = map[int32]string{0: "always", 1: "never", 2: "hide_for_other_teams", 3: "hide_for_own_team"}
var PlayToClientPacketTeamsAnonCollisionRuleMap = map[int32]string{0: "always", 1: "never", 2: "push_other_teams", 3: "push_own_team"}

func (ret *PlayToClientPacketTeams) Decode(r io.Reader) (err error) {
	ret.Team, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToClientPacketTeamsModeKey int8
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsModeKey)
	if err != nil {
		return
	}
	ret.Mode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeMap, PlayToClientPacketTeamsModeKey)
	if err != nil {
		return
	}
	switch ret.Mode {
	case "add":
		var PlayToClientPacketTeamsAnonAddTmp struct {
			Name              nbt.Anon
			Flags             uint8
			NameTagVisibility string
			CollisionRule     string
			Formatting        int32
			Prefix            nbt.Anon
			Suffix            nbt.Anon
		}
		err = PlayToClientPacketTeamsAnonAddTmp.Name.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonAddTmp.Flags)
		if err != nil {
			return
		}
		var PlayToClientPacketTeamsAnonNameTagVisibilityKey int32
		PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonAddTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey)
		if err != nil {
			return
		}
		var PlayToClientPacketTeamsAnonCollisionRuleKey int32
		PlayToClientPacketTeamsAnonCollisionRuleKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonAddTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonAddTmp.Formatting, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnonAddTmp.Prefix.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnonAddTmp.Suffix.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = PlayToClientPacketTeamsAnonAddTmp
	case "change":
		var PlayToClientPacketTeamsAnonChangeTmp struct {
			Name              nbt.Anon
			Flags             uint8
			NameTagVisibility string
			CollisionRule     string
			Formatting        int32
			Prefix            nbt.Anon
			Suffix            nbt.Anon
		}
		err = PlayToClientPacketTeamsAnonChangeTmp.Name.Decode(r)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonChangeTmp.Flags)
		if err != nil {
			return
		}
		var PlayToClientPacketTeamsAnonNameTagVisibilityKey int32
		PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonChangeTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey)
		if err != nil {
			return
		}
		var PlayToClientPacketTeamsAnonCollisionRuleKey int32
		PlayToClientPacketTeamsAnonCollisionRuleKey, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonChangeTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsAnonChangeTmp.Formatting, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnonChangeTmp.Prefix.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnonChangeTmp.Suffix.Decode(r)
		if err != nil {
			return
		}
		ret.Anon = PlayToClientPacketTeamsAnonChangeTmp
	default:
		var PlayToClientPacketTeamsAnonTmp struct {
		}
		ret.Anon = PlayToClientPacketTeamsAnonTmp
	}
	switch ret.Mode {
	case "add":
		var PlayToClientPacketTeamsPlayersAddTmp []string
		var lPlayToClientPacketTeamsPlayers int32
		lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayersAddTmp = []string{}
		for range lPlayToClientPacketTeamsPlayers {
			var PlayToClientPacketTeamsPlayersElement string
			PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayersAddTmp = append(PlayToClientPacketTeamsPlayersAddTmp, PlayToClientPacketTeamsPlayersElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayersAddTmp
	case "join":
		var PlayToClientPacketTeamsPlayersJoinTmp []string
		var lPlayToClientPacketTeamsPlayers int32
		lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayersJoinTmp = []string{}
		for range lPlayToClientPacketTeamsPlayers {
			var PlayToClientPacketTeamsPlayersElement string
			PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayersJoinTmp = append(PlayToClientPacketTeamsPlayersJoinTmp, PlayToClientPacketTeamsPlayersElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayersJoinTmp
	case "leave":
		var PlayToClientPacketTeamsPlayersLeaveTmp []string
		var lPlayToClientPacketTeamsPlayers int32
		lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTeamsPlayersLeaveTmp = []string{}
		for range lPlayToClientPacketTeamsPlayers {
			var PlayToClientPacketTeamsPlayersElement string
			PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r)
			if err != nil {
				return
			}
			PlayToClientPacketTeamsPlayersLeaveTmp = append(PlayToClientPacketTeamsPlayersLeaveTmp, PlayToClientPacketTeamsPlayersElement)
		}
		ret.Players = PlayToClientPacketTeamsPlayersLeaveTmp
	default:
		var PlayToClientPacketTeamsPlayersTmp struct {
		}
		ret.Players = PlayToClientPacketTeamsPlayersTmp
	}
	return
}

var PlayToClientPacketTeamsModeReverseMap = map[string]int8{"add": 0, "remove": 1, "change": 2, "join": 3, "leave": 4}
var PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap = map[string]int32{"always": 0, "never": 1, "hide_for_other_teams": 2, "hide_for_own_team": 3}
var PlayToClientPacketTeamsAnonCollisionRuleReverseMap = map[string]int32{"always": 0, "never": 1, "push_other_teams": 2, "push_own_team": 3}

func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeString(w, ret.Team)
	if err != nil {
		return
	}
	var vPlayToClientPacketTeamsMode int8
	vPlayToClientPacketTeamsMode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeReverseMap, ret.Mode)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, vPlayToClientPacketTeamsMode)
	if err != nil {
		return
	}
	switch ret.Mode {
	case "add":
		PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct {
			Name              nbt.Anon
			Flags             uint8
			NameTagVisibility string
			CollisionRule     string
			Formatting        int32
			Prefix            nbt.Anon
			Suffix            nbt.Anon
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketTeamsAnon.Name.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags)
		if err != nil {
			return
		}
		var vPlayToClientPacketTeamsAnonNameTagVisibility int32
		vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility)
		if err != nil {
			return
		}
		var vPlayToClientPacketTeamsAnonCollisionRule int32
		vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnon.Prefix.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnon.Suffix.Encode(w)
		if err != nil {
			return
		}
	case "change":
		PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct {
			Name              nbt.Anon
			Flags             uint8
			NameTagVisibility string
			CollisionRule     string
			Formatting        int32
			Prefix            nbt.Anon
			Suffix            nbt.Anon
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketTeamsAnon.Name.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags)
		if err != nil {
			return
		}
		var vPlayToClientPacketTeamsAnonNameTagVisibility int32
		vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility)
		if err != nil {
			return
		}
		var vPlayToClientPacketTeamsAnonCollisionRule int32
		vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnon.Prefix.Encode(w)
		if err != nil {
			return
		}
		err = PlayToClientPacketTeamsAnon.Suffix.Encode(w)
		if err != nil {
			return
		}
	default:
		_, ok := ret.Anon.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	switch ret.Mode {
	case "add":
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	case "join":
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	case "leave":
		PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers)))
		if err != nil {
			return
		}
		for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) {
			err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers])
			if err != nil {
				return
			}
		}
	default:
		_, ok := ret.Players.(struct {
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
	}
	return
}

type PlayToClientPacketTestInstanceBlockStatus struct {
	Status nbt.Anon
	Size   *Vec3i
}

func (ret *PlayToClientPacketTestInstanceBlockStatus) Decode(r io.Reader) (err error) {
	err = ret.Status.Decode(r)
	if err != nil {
		return
	}
	var PlayToClientPacketTestInstanceBlockStatusSizePresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTestInstanceBlockStatusSizePresent)
	if err != nil {
		return
	}
	if PlayToClientPacketTestInstanceBlockStatusSizePresent {
		var PlayToClientPacketTestInstanceBlockStatusSizePresentValue Vec3i
		err = PlayToClientPacketTestInstanceBlockStatusSizePresentValue.Decode(r)
		if err != nil {
			return
		}
		ret.Size = &PlayToClientPacketTestInstanceBlockStatusSizePresentValue
	}
	return
}
func (ret *PlayToClientPacketTestInstanceBlockStatus) Encode(w io.Writer) (err error) {
	err = ret.Status.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Size != nil)
	if err != nil {
		return
	}
	if ret.Size != nil {
		err = (*ret.Size).Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketTileEntityData struct {
	Location Position
	Action   int32
	NbtData  nbt.Anon
}

func (ret *PlayToClientPacketTileEntityData) Decode(r io.Reader) (err error) {
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	ret.Action, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = ret.NbtData.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) {
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Action)
	if err != nil {
		return
	}
	err = ret.NbtData.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketTrackedWaypoint struct {
	Operation string
	Waypoint  struct {
		HasUUID bool
		Anon    any
		Icon    struct {
			Style string
			Color *struct {
				Red   uint8
				Green uint8
				Blue  uint8
			}
		}
		Type string
		Data any
	}
}

var PlayToClientPacketTrackedWaypointOperationMap = map[int32]string{0: "track", 1: "untrack", 2: "update"}
var PlayToClientPacketTrackedWaypointWaypointTypeMap = map[int32]string{0: "empty", 1: "vec3i", 2: "chunk", 3: "azimuth"}

func (ret *PlayToClientPacketTrackedWaypoint) Decode(r io.Reader) (err error) {
	var PlayToClientPacketTrackedWaypointOperationKey int32
	PlayToClientPacketTrackedWaypointOperationKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Operation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationMap, PlayToClientPacketTrackedWaypointOperationKey)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Waypoint.HasUUID)
	if err != nil {
		return
	}
	switch ret.Waypoint.HasUUID {
	case false:
		var PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp struct {
			Id string
		}
		PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp.Id, err = proto_base.DecodeString(r)
		if err != nil {
			return
		}
		ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp
	case true:
		var PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp struct {
			Uuid uuid.UUID
		}
		_, err = io.ReadFull(r, PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp.Uuid[:])
		if err != nil {
			return
		}
		ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp
	}
	ret.Waypoint.Icon.Style, err = proto_base.DecodeString(r)
	if err != nil {
		return
	}
	var PlayToClientPacketTrackedWaypointWaypointIconColorPresent bool
	err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresent)
	if err != nil {
		return
	}
	if PlayToClientPacketTrackedWaypointWaypointIconColorPresent {
		var PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue struct {
			Red   uint8
			Green uint8
			Blue  uint8
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Red)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Green)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue.Blue)
		if err != nil {
			return
		}
		ret.Waypoint.Icon.Color = &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue
	}
	var PlayToClientPacketTrackedWaypointWaypointTypeKey int32
	PlayToClientPacketTrackedWaypointWaypointTypeKey, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Waypoint.Type, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeMap, PlayToClientPacketTrackedWaypointWaypointTypeKey)
	if err != nil {
		return
	}
	switch ret.Waypoint.Type {
	case "azimuth":
		var PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp float32
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp)
		if err != nil {
			return
		}
		ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp
	case "chunk":
		var PlayToClientPacketTrackedWaypointWaypointDataChunkTmp struct {
			ChunkX int32
			ChunkZ int32
		}
		PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkX, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkZ, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataChunkTmp
	case "vec3i":
		var PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp Vec3i
		err = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp.Decode(r)
		if err != nil {
			return
		}
		ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp
	}
	return
}

var PlayToClientPacketTrackedWaypointOperationReverseMap = map[string]int32{"track": 0, "untrack": 1, "update": 2}
var PlayToClientPacketTrackedWaypointWaypointTypeReverseMap = map[string]int32{"empty": 0, "vec3i": 1, "chunk": 2, "azimuth": 3}

func (ret *PlayToClientPacketTrackedWaypoint) Encode(w io.Writer) (err error) {
	var vPlayToClientPacketTrackedWaypointOperation int32
	vPlayToClientPacketTrackedWaypointOperation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationReverseMap, ret.Operation)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointOperation)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Waypoint.HasUUID)
	if err != nil {
		return
	}
	switch ret.Waypoint.HasUUID {
	case false:
		PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct {
			Id string
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeString(w, PlayToClientPacketTrackedWaypointWaypointAnon.Id)
		if err != nil {
			return
		}
	case true:
		PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct {
			Uuid uuid.UUID
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		_, err = w.Write(PlayToClientPacketTrackedWaypointWaypointAnon.Uuid[:])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeString(w, ret.Waypoint.Icon.Style)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Waypoint.Icon.Color != nil)
	if err != nil {
		return
	}
	if ret.Waypoint.Icon.Color != nil {
		err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Red)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Green)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, (*ret.Waypoint.Icon.Color).Blue)
		if err != nil {
			return
		}
	}
	var vPlayToClientPacketTrackedWaypointWaypointType int32
	vPlayToClientPacketTrackedWaypointWaypointType, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeReverseMap, ret.Waypoint.Type)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointWaypointType)
	if err != nil {
		return
	}
	switch ret.Waypoint.Type {
	case "azimuth":
		PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(float32)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = binary.Write(w, binary.BigEndian, PlayToClientPacketTrackedWaypointWaypointData)
		if err != nil {
			return
		}
	case "chunk":
		PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(struct {
			ChunkX int32
			ChunkZ int32
		})
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkX)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkZ)
		if err != nil {
			return
		}
	case "vec3i":
		PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(Vec3i)
		if !ok {
			err = proto_base.BadTypeError
			return
		}
		err = PlayToClientPacketTrackedWaypointWaypointData.Encode(w)
		if err != nil {
			return
		}
	}
	return
}

type PlayToClientPacketTradeList struct {
	WindowId ContainerID
	Trades   []struct {
		InputItem1 struct {
			ItemId     int32
			ItemCount  int32
			Components ExactComponentMatcher
		}
		OutputItem Slot
		InputItem2 *struct {
			ItemId     int32
			ItemCount  int32
			Components ExactComponentMatcher
		}
		TradeDisabled      bool
		NbTradeUses        int32
		MaximumNbTradeUses int32
		Xp                 int32
		SpecialPrice       int32
		PriceMultiplier    float32
		Demand             int32
	}
	VillagerLevel     int32
	Experience        int32
	IsRegularVillager bool
	CanRestock        bool
}

func (ret *PlayToClientPacketTradeList) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketTradeListTrades int32
	lPlayToClientPacketTradeListTrades, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Trades = []struct {
		InputItem1 struct {
			ItemId     int32
			ItemCount  int32
			Components ExactComponentMatcher
		}
		OutputItem Slot
		InputItem2 *struct {
			ItemId     int32
			ItemCount  int32
			Components ExactComponentMatcher
		}
		TradeDisabled      bool
		NbTradeUses        int32
		MaximumNbTradeUses int32
		Xp                 int32
		SpecialPrice       int32
		PriceMultiplier    float32
		Demand             int32
	}{}
	for range lPlayToClientPacketTradeListTrades {
		var PlayToClientPacketTradeListTradesElement struct {
			InputItem1 struct {
				ItemId     int32
				ItemCount  int32
				Components ExactComponentMatcher
			}
			OutputItem Slot
			InputItem2 *struct {
				ItemId     int32
				ItemCount  int32
				Components ExactComponentMatcher
			}
			TradeDisabled      bool
			NbTradeUses        int32
			MaximumNbTradeUses int32
			Xp                 int32
			SpecialPrice       int32
			PriceMultiplier    float32
			Demand             int32
		}
		PlayToClientPacketTradeListTradesElement.InputItem1.ItemId, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTradeListTradesElement.InputItem1.Components.Decode(r)
		if err != nil {
			return
		}
		err = PlayToClientPacketTradeListTradesElement.OutputItem.Decode(r)
		if err != nil {
			return
		}
		var PlayToClientPacketTradeListTradesElementInputItem2Present bool
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElementInputItem2Present)
		if err != nil {
			return
		}
		if PlayToClientPacketTradeListTradesElementInputItem2Present {
			var PlayToClientPacketTradeListTradesElementInputItem2PresentValue struct {
				ItemId     int32
				ItemCount  int32
				Components ExactComponentMatcher
			}
			PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount, err = proto_base.DecodeVarInt(r)
			if err != nil {
				return
			}
			err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components.Decode(r)
			if err != nil {
				return
			}
			PlayToClientPacketTradeListTradesElement.InputItem2 = &PlayToClientPacketTradeListTradesElementInputItem2PresentValue
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.TradeDisabled)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.NbTradeUses)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.MaximumNbTradeUses)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Xp)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.SpecialPrice)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.PriceMultiplier)
		if err != nil {
			return
		}
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Demand)
		if err != nil {
			return
		}
		ret.Trades = append(ret.Trades, PlayToClientPacketTradeListTradesElement)
	}
	ret.VillagerLevel, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Experience, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.CanRestock)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketTradeList) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Trades)))
	if err != nil {
		return
	}
	for iPlayToClientPacketTradeListTrades := range len(ret.Trades) {
		err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemId)
		if err != nil {
			return
		}
		err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemCount)
		if err != nil {
			return
		}
		err = ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components.Encode(w)
		if err != nil {
			return
		}
		err = ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem.Encode(w)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil)
		if err != nil {
			return
		}
		if ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil {
			err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemId)
			if err != nil {
				return
			}
			err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemCount)
			if err != nil {
				return
			}
			err = (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components.Encode(w)
			if err != nil {
				return
			}
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].TradeDisabled)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].NbTradeUses)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].MaximumNbTradeUses)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Xp)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].SpecialPrice)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].PriceMultiplier)
		if err != nil {
			return
		}
		err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Demand)
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, ret.VillagerLevel)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Experience)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.IsRegularVillager)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.CanRestock)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUnloadChunk struct {
	ChunkZ int32
	ChunkX int32
}

func (ret *PlayToClientPacketUnloadChunk) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.ChunkZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.ChunkX)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.ChunkZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.ChunkX)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateHealth struct {
	Health         float32
	Food           int32
	FoodSaturation float32
}

func (ret *PlayToClientPacketUpdateHealth) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Health)
	if err != nil {
		return
	}
	ret.Food, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Health)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Food)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.FoodSaturation)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateLight struct {
	ChunkX              int32
	ChunkZ              int32
	SkyLightMask        []int64
	BlockLightMask      []int64
	EmptySkyLightMask   []int64
	EmptyBlockLightMask []int64
	SkyLight            [][]uint8
	BlockLight          [][]uint8
}

func (ret *PlayToClientPacketUpdateLight) Decode(r io.Reader) (err error) {
	ret.ChunkX, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChunkZ, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketUpdateLightSkyLightMask int32
	lPlayToClientPacketUpdateLightSkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SkyLightMask = []int64{}
	for range lPlayToClientPacketUpdateLightSkyLightMask {
		var PlayToClientPacketUpdateLightSkyLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightMaskElement)
		if err != nil {
			return
		}
		ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketUpdateLightSkyLightMaskElement)
	}
	var lPlayToClientPacketUpdateLightBlockLightMask int32
	lPlayToClientPacketUpdateLightBlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockLightMask = []int64{}
	for range lPlayToClientPacketUpdateLightBlockLightMask {
		var PlayToClientPacketUpdateLightBlockLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightMaskElement)
		if err != nil {
			return
		}
		ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketUpdateLightBlockLightMaskElement)
	}
	var lPlayToClientPacketUpdateLightEmptySkyLightMask int32
	lPlayToClientPacketUpdateLightEmptySkyLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptySkyLightMask = []int64{}
	for range lPlayToClientPacketUpdateLightEmptySkyLightMask {
		var PlayToClientPacketUpdateLightEmptySkyLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptySkyLightMaskElement)
		if err != nil {
			return
		}
		ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketUpdateLightEmptySkyLightMaskElement)
	}
	var lPlayToClientPacketUpdateLightEmptyBlockLightMask int32
	lPlayToClientPacketUpdateLightEmptyBlockLightMask, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.EmptyBlockLightMask = []int64{}
	for range lPlayToClientPacketUpdateLightEmptyBlockLightMask {
		var PlayToClientPacketUpdateLightEmptyBlockLightMaskElement int64
		err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptyBlockLightMaskElement)
		if err != nil {
			return
		}
		ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketUpdateLightEmptyBlockLightMaskElement)
	}
	var lPlayToClientPacketUpdateLightSkyLight int32
	lPlayToClientPacketUpdateLightSkyLight, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.SkyLight = [][]uint8{}
	for range lPlayToClientPacketUpdateLightSkyLight {
		var PlayToClientPacketUpdateLightSkyLightElement []uint8
		var lPlayToClientPacketUpdateLightSkyLightElement int32
		lPlayToClientPacketUpdateLightSkyLightElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketUpdateLightSkyLightElement = []uint8{}
		for range lPlayToClientPacketUpdateLightSkyLightElement {
			var PlayToClientPacketUpdateLightSkyLightElementElement uint8
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightElementElement)
			if err != nil {
				return
			}
			PlayToClientPacketUpdateLightSkyLightElement = append(PlayToClientPacketUpdateLightSkyLightElement, PlayToClientPacketUpdateLightSkyLightElementElement)
		}
		ret.SkyLight = append(ret.SkyLight, PlayToClientPacketUpdateLightSkyLightElement)
	}
	var lPlayToClientPacketUpdateLightBlockLight int32
	lPlayToClientPacketUpdateLightBlockLight, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.BlockLight = [][]uint8{}
	for range lPlayToClientPacketUpdateLightBlockLight {
		var PlayToClientPacketUpdateLightBlockLightElement []uint8
		var lPlayToClientPacketUpdateLightBlockLightElement int32
		lPlayToClientPacketUpdateLightBlockLightElement, err = proto_base.DecodeVarInt(r)
		if err != nil {
			return
		}
		PlayToClientPacketUpdateLightBlockLightElement = []uint8{}
		for range lPlayToClientPacketUpdateLightBlockLightElement {
			var PlayToClientPacketUpdateLightBlockLightElementElement uint8
			err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightElementElement)
			if err != nil {
				return
			}
			PlayToClientPacketUpdateLightBlockLightElement = append(PlayToClientPacketUpdateLightBlockLightElement, PlayToClientPacketUpdateLightBlockLightElementElement)
		}
		ret.BlockLight = append(ret.BlockLight, PlayToClientPacketUpdateLightBlockLightElement)
	}
	return
}
func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ChunkX)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChunkZ)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightSkyLightMask := range len(ret.SkyLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketUpdateLightSkyLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightBlockLightMask := range len(ret.BlockLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketUpdateLightBlockLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightEmptySkyLightMask := range len(ret.EmptySkyLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketUpdateLightEmptySkyLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) {
		err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketUpdateLightEmptyBlockLightMask])
		if err != nil {
			return
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightSkyLight := range len(ret.SkyLight) {
		err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight])))
		if err != nil {
			return
		}
		for iPlayToClientPacketUpdateLightSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]) {
			err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight][iPlayToClientPacketUpdateLightSkyLightInner])
			if err != nil {
				return
			}
		}
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight)))
	if err != nil {
		return
	}
	for iPlayToClientPacketUpdateLightBlockLight := range len(ret.BlockLight) {
		err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight])))
		if err != nil {
			return
		}
		for iPlayToClientPacketUpdateLightBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]) {
			err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight][iPlayToClientPacketUpdateLightBlockLightInner])
			if err != nil {
				return
			}
		}
	}
	return
}

type PlayToClientPacketUpdateTime struct {
	Age         int64
	Time        int64
	TickDayTime bool
}

func (ret *PlayToClientPacketUpdateTime) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Age)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Time)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.TickDayTime)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateTime) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Age)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Time)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.TickDayTime)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateViewDistance struct {
	ViewDistance int32
}

func (ret *PlayToClientPacketUpdateViewDistance) Decode(r io.Reader) (err error) {
	ret.ViewDistance, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateViewDistance) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ViewDistance)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketUpdateViewPosition struct {
	ChunkX int32
	ChunkZ int32
}

func (ret *PlayToClientPacketUpdateViewPosition) Decode(r io.Reader) (err error) {
	ret.ChunkX, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.ChunkZ, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketUpdateViewPosition) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.ChunkX)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.ChunkZ)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketVehicleMove struct {
	X     float64
	Y     float64
	Z     float64
	Yaw   float32
	Pitch float32
}

func (ret *PlayToClientPacketVehicleMove) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Pitch)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketVehicleMove) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Yaw)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Pitch)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWindowItems struct {
	WindowId    ContainerID
	StateId     int32
	Items       []Slot
	CarriedItem Slot
}

func (ret *PlayToClientPacketWindowItems) Decode(r io.Reader) (err error) {
	err = ret.WindowId.Decode(r)
	if err != nil {
		return
	}
	ret.StateId, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	var lPlayToClientPacketWindowItemsItems int32
	lPlayToClientPacketWindowItemsItems, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	ret.Items = []Slot{}
	for range lPlayToClientPacketWindowItemsItems {
		var PlayToClientPacketWindowItemsItemsElement Slot
		err = PlayToClientPacketWindowItemsItemsElement.Decode(r)
		if err != nil {
			return
		}
		ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement)
	}
	err = ret.CarriedItem.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) {
	err = ret.WindowId.Encode(w)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.StateId)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, int32(len(ret.Items)))
	if err != nil {
		return
	}
	for iPlayToClientPacketWindowItemsItems := range len(ret.Items) {
		err = ret.Items[iPlayToClientPacketWindowItemsItems].Encode(w)
		if err != nil {
			return
		}
	}
	err = ret.CarriedItem.Encode(w)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldBorderCenter struct {
	X float64
	Z float64
}

func (ret *PlayToClientPacketWorldBorderCenter) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldBorderCenter) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldBorderLerpSize struct {
	OldDiameter float64
	NewDiameter float64
	Speed       int32
}

func (ret *PlayToClientPacketWorldBorderLerpSize) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.OldDiameter)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.NewDiameter)
	if err != nil {
		return
	}
	ret.Speed, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldBorderLerpSize) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.OldDiameter)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.NewDiameter)
	if err != nil {
		return
	}
	err = proto_base.EncodeVarInt(w, ret.Speed)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldBorderSize struct {
	Diameter float64
}

func (ret *PlayToClientPacketWorldBorderSize) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.Diameter)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldBorderSize) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.Diameter)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldBorderWarningDelay struct {
	WarningTime int32
}

func (ret *PlayToClientPacketWorldBorderWarningDelay) Decode(r io.Reader) (err error) {
	ret.WarningTime, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldBorderWarningDelay) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.WarningTime)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldBorderWarningReach struct {
	WarningBlocks int32
}

func (ret *PlayToClientPacketWorldBorderWarningReach) Decode(r io.Reader) (err error) {
	ret.WarningBlocks, err = proto_base.DecodeVarInt(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldBorderWarningReach) Encode(w io.Writer) (err error) {
	err = proto_base.EncodeVarInt(w, ret.WarningBlocks)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldEvent struct {
	EffectId int32
	Location Position
	Data     int32
	Global   bool
}

func (ret *PlayToClientPacketWorldEvent) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.EffectId)
	if err != nil {
		return
	}
	err = ret.Location.Decode(r)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Data)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Global)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.EffectId)
	if err != nil {
		return
	}
	err = ret.Location.Encode(w)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Data)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Global)
	if err != nil {
		return
	}
	return
}

type PlayToClientPacketWorldParticles struct {
	LongDistance   bool
	AlwaysShow     bool
	X              float64
	Y              float64
	Z              float64
	OffsetX        float32
	OffsetY        float32
	OffsetZ        float32
	VelocityOffset float32
	Amount         int32
	Particle       Particle
}

func (ret *PlayToClientPacketWorldParticles) Decode(r io.Reader) (err error) {
	err = binary.Read(r, binary.BigEndian, &ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.AlwaysShow)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.X)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Y)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Z)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.VelocityOffset)
	if err != nil {
		return
	}
	err = binary.Read(r, binary.BigEndian, &ret.Amount)
	if err != nil {
		return
	}
	err = ret.Particle.Decode(r)
	if err != nil {
		return
	}
	return
}
func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) {
	err = binary.Write(w, binary.BigEndian, ret.LongDistance)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.AlwaysShow)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.X)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Y)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Z)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetX)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetY)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.OffsetZ)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.VelocityOffset)
	if err != nil {
		return
	}
	err = binary.Write(w, binary.BigEndian, ret.Amount)
	if err != nil {
		return
	}
	err = ret.Particle.Encode(w)
	if err != nil {
		return
	}
	return
}