/*
 * This file has been automatically generated by Soupply and released under the MIT license.
 * Generated from data/bedrock201.xml
 */
module soupply.bedrock201.protocol.play;

static import std.conv;
import std.typetuple : TypeTuple;
import xpacket;

import soupply.util;
import soupply.bedrock201.metadata : Metadata;
import soupply.bedrock201.packet : Bedrock201Packet;

static import soupply.bedrock201.types;

alias Packets = TypeTuple!(Login, PlayStatus, ServerToClientHandshake, ClientToServerHandshake, Disconnect, ResourcePacksInfo, ResourcePacksStackPacket, ResourcePackClientResponse, Text, SetTime, StartGame, AddPlayer, AddEntity, RemoveEntity, AddItemEntity, AddHangingEntity, TakeItemEntity, MoveEntity, MovePlayer, RiderJump, UpdateBlock, AddPainting, Explode, LevelSoundEvent, LevelEvent, BlockEvent, EntityEvent, MobEffect, UpdateAttributes, InventoryTransaction, MobEquipment, MobArmorEquipment, Interact, BlockPickRequest, EntityPickRequest, PlayerAction, EntityFall, HurtArmor, SetEntityData, SetEntityMotion, SetEntityLink, SetHealth, SetSpawnPosition, Animate, Respawn, ContainerOpen, ContainerClose, PlayerHotbar, InventoryContent, InventorySlot, ContainerSetData, CraftingData, CraftingEvent, GuiDataPickItem, AdventureSettings, BlockEntityData, PlayerInput, FullChunkData, SetCommandsEnabled, SetDifficulty, ChangeDimension, SetPlayerGameType, PlayerList, SimpleEvent, TelemetryEvent, SpawnExperienceOrb, ClientboundMapItemData, MapInfoRequest, RequestChunkRadius, ChunkRadiusUpdated, ItemFrameDropItem, GameRulesChanged, Camera, BossEvent, ShowCredits, AvailableCommands, CommandRequest, CommandBlockUpdate, UpdateTrade, UpdateEquip, ResourcePackDataInfo, ResourcePackChunkData, ResourcePackChunkRequest, Transfer, PlaySound, StopSound, SetTitle, AddBehaviorTree, StructureBlockUpdate, ShowStoreOffer, PurchaseReceipt, PlayerSkin, SubClientLogin, InitiateWebSocketConnection, SetLastHurtBy, BookEdit, NpcRequest, PhotoTransfer, ModalFormRequest, ModalFormResponse, ServerSettingsRequest, ServerSettingsResponse, ShowProfile, SetDefaultGameType);

class Login : Bedrock201Packet
{

    enum uint ID = 1;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["protocol", "body_"];

    @BigEndian uint protocol = 201;
    soupply.bedrock201.types.LoginBody body_;

    this() pure nothrow @safe @nogc {}

    this(uint protocol, soupply.bedrock201.types.LoginBody body_=soupply.bedrock201.types.LoginBody.init) pure nothrow @safe @nogc
    {
        this.protocol = protocol;
        this.body_ = body_;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Login ret = new Login();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Login(protocol: " ~ std.conv.to!string(this.protocol) ~ ", body_: " ~ std.conv.to!string(this.body_) ~ ")";
    }

}

class PlayStatus : Bedrock201Packet
{

    enum uint ID = 2;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // status
    enum uint OK = 0;
    enum uint OUTDATED_CLIENT = 1;
    enum uint OUTDATED_SERVER = 2;
    enum uint SPAWNED = 3;
    enum uint INVALID_TENANT = 4;
    enum uint EDITION_MISMATCH_EDU_TO_VANILLA = 5;
    enum uint EDITION_MISMATCH_VANILLA_TO_EDU = 6;

    enum string[] __fields = ["status"];

    @BigEndian uint status;

    this() pure nothrow @safe @nogc {}

    this(uint status) pure nothrow @safe @nogc
    {
        this.status = status;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayStatus ret = new PlayStatus();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayStatus(status: " ~ std.conv.to!string(this.status) ~ ")";
    }

}

class ServerToClientHandshake : Bedrock201Packet
{

    enum uint ID = 3;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["serverPublicKey", "token"];

    string serverPublicKey;
    ubyte[] token;

    this() pure nothrow @safe @nogc {}

    this(string serverPublicKey, ubyte[] token=(ubyte[]).init) pure nothrow @safe @nogc
    {
        this.serverPublicKey = serverPublicKey;
        this.token = token;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ServerToClientHandshake ret = new ServerToClientHandshake();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ServerToClientHandshake(serverPublicKey: " ~ std.conv.to!string(this.serverPublicKey) ~ ", token: " ~ std.conv.to!string(this.token) ~ ")";
    }

}

class ClientToServerHandshake : Bedrock201Packet
{

    enum uint ID = 4;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ClientToServerHandshake ret = new ClientToServerHandshake();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ClientToServerHandshake()";
    }

}

class Disconnect : Bedrock201Packet
{

    enum uint ID = 5;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["hideDisconnectionScreen", "message"];

    bool hideDisconnectionScreen;
    @Condition("hideDisconnectionScreen==false") string message;

    this() pure nothrow @safe @nogc {}

    this(bool hideDisconnectionScreen, string message=string.init) pure nothrow @safe @nogc
    {
        this.hideDisconnectionScreen = hideDisconnectionScreen;
        this.message = message;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Disconnect ret = new Disconnect();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Disconnect(hideDisconnectionScreen: " ~ std.conv.to!string(this.hideDisconnectionScreen) ~ ", message: " ~ std.conv.to!string(this.message) ~ ")";
    }

}

class ResourcePacksInfo : Bedrock201Packet
{

    enum uint ID = 6;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["mustAccept", "behaviourPacks", "resourcePacks"];

    bool mustAccept;
    @Length!ushort soupply.bedrock201.types.PackWithSize[] behaviourPacks;
    @Length!ushort soupply.bedrock201.types.PackWithSize[] resourcePacks;

    this() pure nothrow @safe @nogc {}

    this(bool mustAccept, soupply.bedrock201.types.PackWithSize[] behaviourPacks=(soupply.bedrock201.types.PackWithSize[]).init, soupply.bedrock201.types.PackWithSize[] resourcePacks=(soupply.bedrock201.types.PackWithSize[]).init) pure nothrow @safe @nogc
    {
        this.mustAccept = mustAccept;
        this.behaviourPacks = behaviourPacks;
        this.resourcePacks = resourcePacks;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePacksInfo ret = new ResourcePacksInfo();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePacksInfo(mustAccept: " ~ std.conv.to!string(this.mustAccept) ~ ", behaviourPacks: " ~ std.conv.to!string(this.behaviourPacks) ~ ", resourcePacks: " ~ std.conv.to!string(this.resourcePacks) ~ ")";
    }

}

class ResourcePacksStackPacket : Bedrock201Packet
{

    enum uint ID = 7;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["mustAccept", "behaviourPacks", "resourcePacks"];

    bool mustAccept;
    soupply.bedrock201.types.Pack[] behaviourPacks;
    soupply.bedrock201.types.Pack[] resourcePacks;

    this() pure nothrow @safe @nogc {}

    this(bool mustAccept, soupply.bedrock201.types.Pack[] behaviourPacks=(soupply.bedrock201.types.Pack[]).init, soupply.bedrock201.types.Pack[] resourcePacks=(soupply.bedrock201.types.Pack[]).init) pure nothrow @safe @nogc
    {
        this.mustAccept = mustAccept;
        this.behaviourPacks = behaviourPacks;
        this.resourcePacks = resourcePacks;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePacksStackPacket ret = new ResourcePacksStackPacket();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePacksStackPacket(mustAccept: " ~ std.conv.to!string(this.mustAccept) ~ ", behaviourPacks: " ~ std.conv.to!string(this.behaviourPacks) ~ ", resourcePacks: " ~ std.conv.to!string(this.resourcePacks) ~ ")";
    }

}

class ResourcePackClientResponse : Bedrock201Packet
{

    enum uint ID = 8;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    // status
    enum ubyte REFUSED = 1;
    enum ubyte SEND_PACKS = 2;
    enum ubyte HAVE_ALL_PACKS = 3;
    enum ubyte COMPLETED = 4;

    enum string[] __fields = ["status", "packIds"];

    ubyte status;
    @Length!ushort string[] packIds;

    this() pure nothrow @safe @nogc {}

    this(ubyte status, string[] packIds=(string[]).init) pure nothrow @safe @nogc
    {
        this.status = status;
        this.packIds = packIds;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePackClientResponse ret = new ResourcePackClientResponse();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePackClientResponse(status: " ~ std.conv.to!string(this.status) ~ ", packIds: " ~ std.conv.to!string(this.packIds) ~ ")";
    }

}

class Text : Bedrock201Packet
{

    enum uint ID = 9;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["type", "unknown1"];

    ubyte type;
    bool unknown1;

    this() pure nothrow @safe @nogc {}

    this(ubyte type, bool unknown1=bool.init) pure nothrow @safe @nogc
    {
        this.type = type;
        this.unknown1 = unknown1;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Text ret = new Text();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Text(type: " ~ std.conv.to!string(this.type) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ")";
    }

    enum string variantField = "type";

    alias Variants = TypeTuple!(Raw, Chat, Translation, Popup, JukeboxPopup, Tip, System, Whisper, Announcement);

    class Raw : Bedrock201Packet
    {

        enum typeof(type) TYPE = 0;

        enum string[] __fields = ["message", "xuid"];

        string message;
        string xuid;

        this() pure nothrow @safe @nogc {}

        this(string message, string xuid=string.init) pure nothrow @safe @nogc
        {
            this.message = message;
            this.xuid = xuid;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Raw(message: " ~ std.conv.to!string(this.message) ~ ", xuid: " ~ std.conv.to!string(this.xuid) ~ ")";
        }

    }

    class Chat : Bedrock201Packet
    {

        enum typeof(type) TYPE = 1;

        enum string[] __fields = ["sender", "message", "xuid"];

        string sender;
        string message;
        string xuid;

        this() pure nothrow @safe @nogc {}

        this(string sender, string message=string.init, string xuid=string.init) pure nothrow @safe @nogc
        {
            this.sender = sender;
            this.message = message;
            this.xuid = xuid;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Chat(sender: " ~ std.conv.to!string(this.sender) ~ ", message: " ~ std.conv.to!string(this.message) ~ ", xuid: " ~ std.conv.to!string(this.xuid) ~ ")";
        }

    }

    class Translation : Bedrock201Packet
    {

        enum typeof(type) TYPE = 2;

        enum string[] __fields = ["message", "parameters"];

        string message;
        string[] parameters;

        this() pure nothrow @safe @nogc {}

        this(string message, string[] parameters=(string[]).init) pure nothrow @safe @nogc
        {
            this.message = message;
            this.parameters = parameters;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Translation(message: " ~ std.conv.to!string(this.message) ~ ", parameters: " ~ std.conv.to!string(this.parameters) ~ ")";
        }

    }

    class Popup : Bedrock201Packet
    {

        enum typeof(type) TYPE = 3;

        enum string[] __fields = ["title", "subtitle"];

        string title;
        string subtitle;

        this() pure nothrow @safe @nogc {}

        this(string title, string subtitle=string.init) pure nothrow @safe @nogc
        {
            this.title = title;
            this.subtitle = subtitle;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Popup(title: " ~ std.conv.to!string(this.title) ~ ", subtitle: " ~ std.conv.to!string(this.subtitle) ~ ")";
        }

    }

    class JukeboxPopup : Bedrock201Packet
    {

        enum typeof(type) TYPE = 4;

        enum string[] __fields = ["message", "parameters"];

        string message;
        string[] parameters;

        this() pure nothrow @safe @nogc {}

        this(string message, string[] parameters=(string[]).init) pure nothrow @safe @nogc
        {
            this.message = message;
            this.parameters = parameters;
        }

        mixin Make;

        override string toString()
        {
            return "Text.JukeboxPopup(message: " ~ std.conv.to!string(this.message) ~ ", parameters: " ~ std.conv.to!string(this.parameters) ~ ")";
        }

    }

    class Tip : Bedrock201Packet
    {

        enum typeof(type) TYPE = 5;

        enum string[] __fields = ["message"];

        string message;

        this() pure nothrow @safe @nogc {}

        this(string message) pure nothrow @safe @nogc
        {
            this.message = message;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Tip(message: " ~ std.conv.to!string(this.message) ~ ")";
        }

    }

    class System : Bedrock201Packet
    {

        enum typeof(type) TYPE = 6;

        enum string[] __fields = ["message"];

        string message;

        this() pure nothrow @safe @nogc {}

        this(string message) pure nothrow @safe @nogc
        {
            this.message = message;
        }

        mixin Make;

        override string toString()
        {
            return "Text.System(message: " ~ std.conv.to!string(this.message) ~ ")";
        }

    }

    class Whisper : Bedrock201Packet
    {

        enum typeof(type) TYPE = 7;

        enum string[] __fields = ["sender", "message"];

        string sender;
        string message;

        this() pure nothrow @safe @nogc {}

        this(string sender, string message=string.init) pure nothrow @safe @nogc
        {
            this.sender = sender;
            this.message = message;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Whisper(sender: " ~ std.conv.to!string(this.sender) ~ ", message: " ~ std.conv.to!string(this.message) ~ ")";
        }

    }

    class Announcement : Bedrock201Packet
    {

        enum typeof(type) TYPE = 8;

        enum string[] __fields = ["announcer", "message"];

        string announcer;
        string message;

        this() pure nothrow @safe @nogc {}

        this(string announcer, string message=string.init) pure nothrow @safe @nogc
        {
            this.announcer = announcer;
            this.message = message;
        }

        mixin Make;

        override string toString()
        {
            return "Text.Announcement(announcer: " ~ std.conv.to!string(this.announcer) ~ ", message: " ~ std.conv.to!string(this.message) ~ ")";
        }

    }

}

class SetTime : Bedrock201Packet
{

    enum uint ID = 10;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["time"];

    @Var int time;

    this() pure nothrow @safe @nogc {}

    this(int time) pure nothrow @safe @nogc
    {
        this.time = time;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetTime ret = new SetTime();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetTime(time: " ~ std.conv.to!string(this.time) ~ ")";
    }

}

class StartGame : Bedrock201Packet
{

    enum uint ID = 11;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // gamemode
    enum int SURVIVAL = 0;
    enum int CREATIVE = 1;
    enum int ADVENTURE = 2;

    // dimension
    enum int OVERWORLD = 0;
    enum int NETHER = 1;
    enum int END = 2;

    // generator
    enum int OLD = 0;
    enum int INFINITE = 1;
    enum int FLAT = 2;

    // difficulty
    enum int PEACEFUL = 0;
    enum int EASY = 1;
    enum int NORMAL = 2;
    enum int HARD = 3;

    // version
    enum ubyte VANILLA = 0;
    enum ubyte EDUCATION = 1;

    enum string[] __fields = ["entityId", "runtimeId", "gamemode", "position", "yaw", "pitch", "seed", "dimension", "generator", "worldGamemode", "difficulty", "spawnPosition", "loadedInCreative", "time", "version_", "rainLevel", "lightningLevel", "multiplayerGame", "broadcastToLan", "broadcastToXbl", "commandsEnabled", "textureRequired", "gameRules", "bonusChestEnabled", "startWithMapEnabled", "trustPlayersEnabled", "defaultPermissionLevel", "xboxLiveBroadcastMode", "serverChunkTickRadius", "levelId", "worldName", "premiumWorldTemplate", "unknown32", "worldTicks", "enchantmentSeed"];

    @Var long entityId;
    @Var ulong runtimeId;
    @Var int gamemode;
    Vector!(float, "xyz") position;
    float yaw;
    float pitch;
    @Var int seed;
    @Var int dimension = 0;
    @Var int generator = 1;
    @Var int worldGamemode;
    @Var int difficulty;
    @Var Vector!(int, "xyz") spawnPosition;
    bool loadedInCreative;
    @Var int time;
    ubyte version_;
    float rainLevel;
    float lightningLevel;
    bool multiplayerGame = true;
    bool broadcastToLan;
    bool broadcastToXbl;
    bool commandsEnabled;
    bool textureRequired;
    soupply.bedrock201.types.Rule[] gameRules;
    bool bonusChestEnabled;
    bool startWithMapEnabled;
    bool trustPlayersEnabled;
    @Var int defaultPermissionLevel;
    @Var int xboxLiveBroadcastMode;
    uint serverChunkTickRadius;
    string levelId;
    string worldName;
    string premiumWorldTemplate;
    bool unknown32;
    ulong worldTicks;
    @Var int enchantmentSeed;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ulong runtimeId=ulong.init, int gamemode=int.init, Vector!(float, "xyz") position=Vector!(float, "xyz").init, float yaw=float.init, float pitch=float.init, int seed=int.init, int dimension=0, int generator=1, int worldGamemode=int.init, int difficulty=int.init, Vector!(int, "xyz") spawnPosition=Vector!(int, "xyz").init, bool loadedInCreative=bool.init, int time=int.init, ubyte version_=ubyte.init, float rainLevel=float.init, float lightningLevel=float.init, bool multiplayerGame=true, bool broadcastToLan=bool.init, bool broadcastToXbl=bool.init, bool commandsEnabled=bool.init, bool textureRequired=bool.init, soupply.bedrock201.types.Rule[] gameRules=(soupply.bedrock201.types.Rule[]).init, bool bonusChestEnabled=bool.init, bool startWithMapEnabled=bool.init, bool trustPlayersEnabled=bool.init, int defaultPermissionLevel=int.init, int xboxLiveBroadcastMode=int.init, uint serverChunkTickRadius=uint.init, string levelId=string.init, string worldName=string.init, string premiumWorldTemplate=string.init, bool unknown32=bool.init, ulong worldTicks=ulong.init, int enchantmentSeed=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.gamemode = gamemode;
        this.position = position;
        this.yaw = yaw;
        this.pitch = pitch;
        this.seed = seed;
        this.dimension = dimension;
        this.generator = generator;
        this.worldGamemode = worldGamemode;
        this.difficulty = difficulty;
        this.spawnPosition = spawnPosition;
        this.loadedInCreative = loadedInCreative;
        this.time = time;
        this.version_ = version_;
        this.rainLevel = rainLevel;
        this.lightningLevel = lightningLevel;
        this.multiplayerGame = multiplayerGame;
        this.broadcastToLan = broadcastToLan;
        this.broadcastToXbl = broadcastToXbl;
        this.commandsEnabled = commandsEnabled;
        this.textureRequired = textureRequired;
        this.gameRules = gameRules;
        this.bonusChestEnabled = bonusChestEnabled;
        this.startWithMapEnabled = startWithMapEnabled;
        this.trustPlayersEnabled = trustPlayersEnabled;
        this.defaultPermissionLevel = defaultPermissionLevel;
        this.xboxLiveBroadcastMode = xboxLiveBroadcastMode;
        this.serverChunkTickRadius = serverChunkTickRadius;
        this.levelId = levelId;
        this.worldName = worldName;
        this.premiumWorldTemplate = premiumWorldTemplate;
        this.unknown32 = unknown32;
        this.worldTicks = worldTicks;
        this.enchantmentSeed = enchantmentSeed;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        StartGame ret = new StartGame();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "StartGame(entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", gamemode: " ~ std.conv.to!string(this.gamemode) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", yaw: " ~ std.conv.to!string(this.yaw) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", seed: " ~ std.conv.to!string(this.seed) ~ ", dimension: " ~ std.conv.to!string(this.dimension) ~ ", generator: " ~ std.conv.to!string(this.generator) ~ ", worldGamemode: " ~ std.conv.to!string(this.worldGamemode) ~ ", difficulty: " ~ std.conv.to!string(this.difficulty) ~ ", spawnPosition: " ~ std.conv.to!string(this.spawnPosition) ~ ", loadedInCreative: " ~ std.conv.to!string(this.loadedInCreative) ~ ", time: " ~ std.conv.to!string(this.time) ~ ", version_: " ~ std.conv.to!string(this.version_) ~ ", rainLevel: " ~ std.conv.to!string(this.rainLevel) ~ ", lightningLevel: " ~ std.conv.to!string(this.lightningLevel) ~ ", multiplayerGame: " ~ std.conv.to!string(this.multiplayerGame) ~ ", broadcastToLan: " ~ std.conv.to!string(this.broadcastToLan) ~ ", broadcastToXbl: " ~ std.conv.to!string(this.broadcastToXbl) ~ ", commandsEnabled: " ~ std.conv.to!string(this.commandsEnabled) ~ ", textureRequired: " ~ std.conv.to!string(this.textureRequired) ~ ", gameRules: " ~ std.conv.to!string(this.gameRules) ~ ", bonusChestEnabled: " ~ std.conv.to!string(this.bonusChestEnabled) ~ ", startWithMapEnabled: " ~ std.conv.to!string(this.startWithMapEnabled) ~ ", trustPlayersEnabled: " ~ std.conv.to!string(this.trustPlayersEnabled) ~ ", defaultPermissionLevel: " ~ std.conv.to!string(this.defaultPermissionLevel) ~ ", xboxLiveBroadcastMode: " ~ std.conv.to!string(this.xboxLiveBroadcastMode) ~ ", serverChunkTickRadius: " ~ std.conv.to!string(this.serverChunkTickRadius) ~ ", levelId: " ~ std.conv.to!string(this.levelId) ~ ", worldName: " ~ std.conv.to!string(this.worldName) ~ ", premiumWorldTemplate: " ~ std.conv.to!string(this.premiumWorldTemplate) ~ ", unknown32: " ~ std.conv.to!string(this.unknown32) ~ ", worldTicks: " ~ std.conv.to!string(this.worldTicks) ~ ", enchantmentSeed: " ~ std.conv.to!string(this.enchantmentSeed) ~ ")";
    }

}

class AddPlayer : Bedrock201Packet
{

    enum uint ID = 12;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["uuid", "username", "entityId", "runtimeId", "position", "motion", "pitch", "headYaw", "yaw", "heldItem", "metadata", "unknown11", "unknown12", "unknown13", "unknown14", "unknown15", "unknown16", "links"];

    soupply.bedrock201.types.McpeUuid uuid;
    string username;
    @Var long entityId;
    @Var ulong runtimeId;
    Vector!(float, "xyz") position;
    Vector!(float, "xyz") motion;
    float pitch;
    float headYaw;
    float yaw;
    soupply.bedrock201.types.Slot heldItem;
    Metadata metadata;
    @Var uint unknown11;
    @Var uint unknown12;
    @Var uint unknown13;
    @Var uint unknown14;
    @Var uint unknown15;
    long unknown16;
    soupply.bedrock201.types.Link[] links;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.McpeUuid uuid, string username=string.init, long entityId=long.init, ulong runtimeId=ulong.init, Vector!(float, "xyz") position=Vector!(float, "xyz").init, Vector!(float, "xyz") motion=Vector!(float, "xyz").init, float pitch=float.init, float headYaw=float.init, float yaw=float.init, soupply.bedrock201.types.Slot heldItem=soupply.bedrock201.types.Slot.init, Metadata metadata=Metadata.init, uint unknown11=uint.init, uint unknown12=uint.init, uint unknown13=uint.init, uint unknown14=uint.init, uint unknown15=uint.init, long unknown16=long.init, soupply.bedrock201.types.Link[] links=(soupply.bedrock201.types.Link[]).init) pure nothrow @safe @nogc
    {
        this.uuid = uuid;
        this.username = username;
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.position = position;
        this.motion = motion;
        this.pitch = pitch;
        this.headYaw = headYaw;
        this.yaw = yaw;
        this.heldItem = heldItem;
        this.metadata = metadata;
        this.unknown11 = unknown11;
        this.unknown12 = unknown12;
        this.unknown13 = unknown13;
        this.unknown14 = unknown14;
        this.unknown15 = unknown15;
        this.unknown16 = unknown16;
        this.links = links;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddPlayer ret = new AddPlayer();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddPlayer(uuid: " ~ std.conv.to!string(this.uuid) ~ ", username: " ~ std.conv.to!string(this.username) ~ ", entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", motion: " ~ std.conv.to!string(this.motion) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", headYaw: " ~ std.conv.to!string(this.headYaw) ~ ", yaw: " ~ std.conv.to!string(this.yaw) ~ ", heldItem: " ~ std.conv.to!string(this.heldItem) ~ ", metadata: " ~ std.conv.to!string(this.metadata) ~ ", unknown11: " ~ std.conv.to!string(this.unknown11) ~ ", unknown12: " ~ std.conv.to!string(this.unknown12) ~ ", unknown13: " ~ std.conv.to!string(this.unknown13) ~ ", unknown14: " ~ std.conv.to!string(this.unknown14) ~ ", unknown15: " ~ std.conv.to!string(this.unknown15) ~ ", unknown16: " ~ std.conv.to!string(this.unknown16) ~ ", links: " ~ std.conv.to!string(this.links) ~ ")";
    }

}

class AddEntity : Bedrock201Packet
{

    enum uint ID = 13;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "runtimeId", "type", "position", "motion", "pitch", "yaw", "attributes", "metadata", "links"];

    @Var long entityId;
    @Var ulong runtimeId;
    @Var uint type;
    Vector!(float, "xyz") position;
    Vector!(float, "xyz") motion;
    float pitch;
    float yaw;
    soupply.bedrock201.types.Attribute[] attributes;
    Metadata metadata;
    soupply.bedrock201.types.Link[] links;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ulong runtimeId=ulong.init, uint type=uint.init, Vector!(float, "xyz") position=Vector!(float, "xyz").init, Vector!(float, "xyz") motion=Vector!(float, "xyz").init, float pitch=float.init, float yaw=float.init, soupply.bedrock201.types.Attribute[] attributes=(soupply.bedrock201.types.Attribute[]).init, Metadata metadata=Metadata.init, soupply.bedrock201.types.Link[] links=(soupply.bedrock201.types.Link[]).init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.type = type;
        this.position = position;
        this.motion = motion;
        this.pitch = pitch;
        this.yaw = yaw;
        this.attributes = attributes;
        this.metadata = metadata;
        this.links = links;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddEntity ret = new AddEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", type: " ~ std.conv.to!string(this.type) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", motion: " ~ std.conv.to!string(this.motion) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", yaw: " ~ std.conv.to!string(this.yaw) ~ ", attributes: " ~ std.conv.to!string(this.attributes) ~ ", metadata: " ~ std.conv.to!string(this.metadata) ~ ", links: " ~ std.conv.to!string(this.links) ~ ")";
    }

}

class RemoveEntity : Bedrock201Packet
{

    enum uint ID = 14;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId"];

    @Var long entityId;

    this() pure nothrow @safe @nogc {}

    this(long entityId) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        RemoveEntity ret = new RemoveEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "RemoveEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ")";
    }

}

class AddItemEntity : Bedrock201Packet
{

    enum uint ID = 15;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "runtimeId", "item", "position", "motion", "metadata"];

    @Var long entityId;
    @Var ulong runtimeId;
    soupply.bedrock201.types.Slot item;
    Vector!(float, "xyz") position;
    Vector!(float, "xyz") motion;
    Metadata metadata;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ulong runtimeId=ulong.init, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init, Vector!(float, "xyz") position=Vector!(float, "xyz").init, Vector!(float, "xyz") motion=Vector!(float, "xyz").init, Metadata metadata=Metadata.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.item = item;
        this.position = position;
        this.motion = motion;
        this.metadata = metadata;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddItemEntity ret = new AddItemEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddItemEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", item: " ~ std.conv.to!string(this.item) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", motion: " ~ std.conv.to!string(this.motion) ~ ", metadata: " ~ std.conv.to!string(this.metadata) ~ ")";
    }

}

class AddHangingEntity : Bedrock201Packet
{

    enum uint ID = 16;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "runtimeId", "position", "unknown3"];

    @Var long entityId;
    @Var ulong runtimeId;
    soupply.bedrock201.types.BlockPosition position;
    @Var int unknown3;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ulong runtimeId=ulong.init, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, int unknown3=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.position = position;
        this.unknown3 = unknown3;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddHangingEntity ret = new AddHangingEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddHangingEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", unknown3: " ~ std.conv.to!string(this.unknown3) ~ ")";
    }

}

class TakeItemEntity : Bedrock201Packet
{

    enum uint ID = 17;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["collected", "collector"];

    @Var long collected;
    @Var long collector;

    this() pure nothrow @safe @nogc {}

    this(long collected, long collector=long.init) pure nothrow @safe @nogc
    {
        this.collected = collected;
        this.collector = collector;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        TakeItemEntity ret = new TakeItemEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "TakeItemEntity(collected: " ~ std.conv.to!string(this.collected) ~ ", collector: " ~ std.conv.to!string(this.collector) ~ ")";
    }

}

class MoveEntity : Bedrock201Packet
{

    enum uint ID = 18;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "position", "pitch", "headYaw", "yaw", "onGround", "teleported"];

    @Var long entityId;
    Vector!(float, "xyz") position;
    ubyte pitch;
    ubyte headYaw;
    ubyte yaw;
    bool onGround;
    bool teleported;

    this() pure nothrow @safe @nogc {}

    this(long entityId, Vector!(float, "xyz") position=Vector!(float, "xyz").init, ubyte pitch=ubyte.init, ubyte headYaw=ubyte.init, ubyte yaw=ubyte.init, bool onGround=bool.init, bool teleported=bool.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.position = position;
        this.pitch = pitch;
        this.headYaw = headYaw;
        this.yaw = yaw;
        this.onGround = onGround;
        this.teleported = teleported;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MoveEntity ret = new MoveEntity();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MoveEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", headYaw: " ~ std.conv.to!string(this.headYaw) ~ ", yaw: " ~ std.conv.to!string(this.yaw) ~ ", onGround: " ~ std.conv.to!string(this.onGround) ~ ", teleported: " ~ std.conv.to!string(this.teleported) ~ ")";
    }

}

class MovePlayer : Bedrock201Packet
{

    enum uint ID = 19;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // animation
    enum ubyte FULL = 0;
    enum ubyte NONE = 1;
    enum ubyte TELEPORT = 2;
    enum ubyte PITCH = 3;

    enum string[] __fields = ["entityId", "position", "pitch", "headYaw", "yaw", "animation", "onGround", "unknown7", "unknown8", "unknown9"];

    @Var long entityId;
    Vector!(float, "xyz") position;
    float pitch;
    float headYaw;
    float yaw;
    ubyte animation;
    bool onGround;
    @Var long unknown7;
    @Condition("animation==3") int unknown8;
    @Condition("animation==3") int unknown9;

    this() pure nothrow @safe @nogc {}

    this(long entityId, Vector!(float, "xyz") position=Vector!(float, "xyz").init, float pitch=float.init, float headYaw=float.init, float yaw=float.init, ubyte animation=ubyte.init, bool onGround=bool.init, long unknown7=long.init, int unknown8=int.init, int unknown9=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.position = position;
        this.pitch = pitch;
        this.headYaw = headYaw;
        this.yaw = yaw;
        this.animation = animation;
        this.onGround = onGround;
        this.unknown7 = unknown7;
        this.unknown8 = unknown8;
        this.unknown9 = unknown9;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MovePlayer ret = new MovePlayer();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MovePlayer(entityId: " ~ std.conv.to!string(this.entityId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", headYaw: " ~ std.conv.to!string(this.headYaw) ~ ", yaw: " ~ std.conv.to!string(this.yaw) ~ ", animation: " ~ std.conv.to!string(this.animation) ~ ", onGround: " ~ std.conv.to!string(this.onGround) ~ ", unknown7: " ~ std.conv.to!string(this.unknown7) ~ ", unknown8: " ~ std.conv.to!string(this.unknown8) ~ ", unknown9: " ~ std.conv.to!string(this.unknown9) ~ ")";
    }

}

class RiderJump : Bedrock201Packet
{

    enum uint ID = 20;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["rider"];

    @Var long rider;

    this() pure nothrow @safe @nogc {}

    this(long rider) pure nothrow @safe @nogc
    {
        this.rider = rider;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        RiderJump ret = new RiderJump();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "RiderJump(rider: " ~ std.conv.to!string(this.rider) ~ ")";
    }

}

class UpdateBlock : Bedrock201Packet
{

    enum uint ID = 21;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // flags and meta
    enum uint NEIGHBORS = 1;
    enum uint NETWORK = 2;
    enum uint NO_GRAPHIC = 4;
    enum uint PRIORITY = 8;

    enum string[] __fields = ["position", "block", "flagsAndMeta"];

    soupply.bedrock201.types.BlockPosition position;
    @Var uint block;
    @Var uint flagsAndMeta;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.BlockPosition position, uint block=uint.init, uint flagsAndMeta=uint.init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.block = block;
        this.flagsAndMeta = flagsAndMeta;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        UpdateBlock ret = new UpdateBlock();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "UpdateBlock(position: " ~ std.conv.to!string(this.position) ~ ", block: " ~ std.conv.to!string(this.block) ~ ", flagsAndMeta: " ~ std.conv.to!string(this.flagsAndMeta) ~ ")";
    }

}

class AddPainting : Bedrock201Packet
{

    enum uint ID = 22;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "runtimeId", "position", "direction", "title"];

    @Var long entityId;
    @Var ulong runtimeId;
    soupply.bedrock201.types.BlockPosition position;
    @Var int direction;
    string title;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ulong runtimeId=ulong.init, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, int direction=int.init, string title=string.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.runtimeId = runtimeId;
        this.position = position;
        this.direction = direction;
        this.title = title;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddPainting ret = new AddPainting();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddPainting(entityId: " ~ std.conv.to!string(this.entityId) ~ ", runtimeId: " ~ std.conv.to!string(this.runtimeId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", direction: " ~ std.conv.to!string(this.direction) ~ ", title: " ~ std.conv.to!string(this.title) ~ ")";
    }

}

class Explode : Bedrock201Packet
{

    enum uint ID = 23;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position", "radius", "destroyedBlocks"];

    Vector!(float, "xyz") position;
    float radius;
    soupply.bedrock201.types.BlockPosition[] destroyedBlocks;

    this() pure nothrow @safe @nogc {}

    this(Vector!(float, "xyz") position, float radius=float.init, soupply.bedrock201.types.BlockPosition[] destroyedBlocks=(soupply.bedrock201.types.BlockPosition[]).init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.radius = radius;
        this.destroyedBlocks = destroyedBlocks;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Explode ret = new Explode();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Explode(position: " ~ std.conv.to!string(this.position) ~ ", radius: " ~ std.conv.to!string(this.radius) ~ ", destroyedBlocks: " ~ std.conv.to!string(this.destroyedBlocks) ~ ")";
    }

}

class LevelSoundEvent : Bedrock201Packet
{

    enum uint ID = 24;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // sound
    enum ubyte ITEM_USE_ON = 0;
    enum ubyte HIT = 1;
    enum ubyte STEP = 2;
    enum ubyte FLY = 3;
    enum ubyte JUMP = 4;
    enum ubyte BREAK = 5;
    enum ubyte PLACE = 6;
    enum ubyte HEAVY_STEP = 7;
    enum ubyte GALLOP = 8;
    enum ubyte FALL = 9;
    enum ubyte AMBIENT = 10;
    enum ubyte AMBIENT_BABY = 11;
    enum ubyte AMBIENT_IN_WATER = 12;
    enum ubyte BREATHE = 13;
    enum ubyte DEATH = 14;
    enum ubyte DEATH_IN_WATER = 15;
    enum ubyte DEATH_TO_ZOMBIE = 16;
    enum ubyte HURT = 17;
    enum ubyte HURT_IN_WATER = 18;
    enum ubyte MAD = 19;
    enum ubyte BOOST = 20;
    enum ubyte BOW = 21;
    enum ubyte SQUISH_BIG = 22;
    enum ubyte SQUISH_SMALL = 23;
    enum ubyte FALL_BIG = 24;
    enum ubyte FALL_SMALL = 25;
    enum ubyte SPLASH = 26;
    enum ubyte FIZZ = 27;
    enum ubyte FLAP = 28;
    enum ubyte SWIM = 29;
    enum ubyte DRINK = 30;
    enum ubyte EAT = 31;
    enum ubyte TAKEOFF = 32;
    enum ubyte SHAKE = 33;
    enum ubyte PLOP = 34;
    enum ubyte LAND = 35;
    enum ubyte SADDLE = 36;
    enum ubyte ARMOR = 37;
    enum ubyte ADD_CHEST = 38;
    enum ubyte THROW = 39;
    enum ubyte ATTACK = 40;
    enum ubyte ATTACK_NODAMAGE = 41;
    enum ubyte ATTACK_STRONG = 42;
    enum ubyte WARN = 43;
    enum ubyte SHEAR = 44;
    enum ubyte MILK = 45;
    enum ubyte THUNDER = 46;
    enum ubyte EXPLODE = 47;
    enum ubyte FIRE = 48;
    enum ubyte IGNITE = 49;
    enum ubyte FUSE = 50;
    enum ubyte STARE = 51;
    enum ubyte SPAWN = 52;
    enum ubyte SHOOT = 53;
    enum ubyte BREAK_BLOCK = 54;
    enum ubyte LAUNCH = 55;
    enum ubyte BLAST = 56;
    enum ubyte LARGE_BLAST = 57;
    enum ubyte TWINKLE = 58;
    enum ubyte REMEDY = 59;
    enum ubyte UNFECT = 60;
    enum ubyte LEVELUP = 61;
    enum ubyte BOW_HIT = 62;
    enum ubyte BULLET_HIT = 63;
    enum ubyte EXTINGUISH_FIRE = 64;
    enum ubyte ITEM_FIZZ = 65;
    enum ubyte CHEST_OPEN = 66;
    enum ubyte CHEST_CLOSED = 67;
    enum ubyte SHULKER_BOX_OPEN = 68;
    enum ubyte SHULKER_BOX_CLOSE = 69;
    enum ubyte POWER_ON = 70;
    enum ubyte POWER_OFF = 71;
    enum ubyte ATTACH = 72;
    enum ubyte DETACH = 73;
    enum ubyte DENY = 74;
    enum ubyte TRIPOD = 75;
    enum ubyte POP = 76;
    enum ubyte DROP_SLOT = 77;
    enum ubyte NOTE = 78;
    enum ubyte THORNS = 79;
    enum ubyte PISTON_IN = 80;
    enum ubyte PISTON_OUT = 81;
    enum ubyte PORTAL = 82;
    enum ubyte WATER = 83;
    enum ubyte LAVA_POP = 84;
    enum ubyte LAVA = 85;
    enum ubyte BURP = 86;
    enum ubyte BUCKET_FILL_WATER = 87;
    enum ubyte BUCKET_FILL_LAVA = 88;
    enum ubyte BUCKET_EMPTY_WATER = 89;
    enum ubyte BUCKET_EMPTY_LAVA = 90;
    enum ubyte RECORD_13 = 91;
    enum ubyte RECORD_CAT = 92;
    enum ubyte RECORD_BLOCKS = 93;
    enum ubyte RECORD_CHIRP = 94;
    enum ubyte RECORD_FAR = 95;
    enum ubyte RECORD_MALL = 96;
    enum ubyte RECORD_MELLOHI = 97;
    enum ubyte RECORD_STAL = 98;
    enum ubyte RECORD_STRAD = 99;
    enum ubyte RECORD_WARD = 100;
    enum ubyte RECORD_11 = 101;
    enum ubyte RECORD_WAIT = 102;
    enum ubyte GUARDIAN_FLOP = 104;
    enum ubyte ELDERGUARDIAN_CURSE = 105;
    enum ubyte MOB_WARNING = 106;
    enum ubyte MOB_WARNING_BABY = 107;
    enum ubyte TELEPORT = 108;
    enum ubyte SHULKER_OPEN = 109;
    enum ubyte SHULKER_CLOSE = 110;
    enum ubyte HAGGLE = 111;
    enum ubyte HAGGLE_YES = 112;
    enum ubyte HAGGLE_NO = 113;
    enum ubyte HAGGLE_IDLE = 114;
    enum ubyte CHORUS_GROW = 115;
    enum ubyte CHORUS_DEATH = 116;
    enum ubyte GLASS = 117;
    enum ubyte CAST_SPELL = 118;
    enum ubyte PREPARE_ATTACK = 119;
    enum ubyte PREPARE_SUMMON = 120;
    enum ubyte PREPARE_WOLOLO = 121;
    enum ubyte FANG = 122;
    enum ubyte CHARGE = 123;
    enum ubyte CAMERA_TAKE_PICTURE = 124;
    enum ubyte LEASHKNOT_PLACE = 125;
    enum ubyte LEASHKNOT_BREAK = 126;
    enum ubyte GROWL = 127;
    enum ubyte WHINE = 128;
    enum ubyte PANT = 129;
    enum ubyte PURR = 130;
    enum ubyte PURREOW = 131;
    enum ubyte DEATH_MIN_VOLUME = 132;
    enum ubyte DEATH_MID_VOLUME = 133;
    enum ubyte INITIATE_BLAZE = 134;
    enum ubyte INITIATE_CAVE_SPIDER = 135;
    enum ubyte INITIATE_CREEPER = 136;
    enum ubyte INITIATE_ELDER_GUARDIAN = 137;
    enum ubyte INITIATE_ENDER_DRAGON = 138;
    enum ubyte INITIATE_ENDERMAN = 139;
    enum ubyte INITIATE_EVOCATION_ILLAGER = 141;
    enum ubyte INITIATE_GHAST = 142;
    enum ubyte INITIATE_HUSK = 143;
    enum ubyte INITIATE_ILLUSION_ILLAGER = 144;
    enum ubyte INITIATE_MAGMA_CUBE = 145;
    enum ubyte INITIATE_POLAR_BEAR = 146;
    enum ubyte INITIATE_SHULKER = 147;
    enum ubyte INITIATE_SILVERFISH = 148;
    enum ubyte INITIATE_SKELETON = 149;
    enum ubyte INITIATE_SLIME = 150;
    enum ubyte INITIATE_SPIDER = 151;
    enum ubyte INITIATE_STRAY = 152;
    enum ubyte INITIATE_VEX = 153;
    enum ubyte INITIATE_VINDICATION_ILLAGER = 154;
    enum ubyte INITIATE_WITCH = 155;
    enum ubyte INITIATE_WITHER = 156;
    enum ubyte INITIATE_WITHER_SKELETON = 157;
    enum ubyte INITIATE_WOLF = 158;
    enum ubyte INITIATE_ZOMBIE = 159;
    enum ubyte INITIATE_ZOMBIE_PIGMAN = 160;
    enum ubyte INITIATE_ZOMBIE_VILLAGER = 161;
    enum ubyte BLOCK_END_PORTAL_FRAME_FILL = 162;
    enum ubyte BLOCK_END_PORTAL_SPAWN = 163;
    enum ubyte RANDOM_ANVIL_USE = 164;
    enum ubyte BOTTLE_DRAGONBREATH = 165;
    enum ubyte DEFAULT = 166;
    enum ubyte UNDEFINED = 167;

    enum string[] __fields = ["sound", "position", "volume", "pitch", "unknown4", "disableRelativeVolume"];

    ubyte sound;
    Vector!(float, "xyz") position;
    @Var uint volume;
    @Var int pitch;
    bool unknown4;
    bool disableRelativeVolume;

    this() pure nothrow @safe @nogc {}

    this(ubyte sound, Vector!(float, "xyz") position=Vector!(float, "xyz").init, uint volume=uint.init, int pitch=int.init, bool unknown4=bool.init, bool disableRelativeVolume=bool.init) pure nothrow @safe @nogc
    {
        this.sound = sound;
        this.position = position;
        this.volume = volume;
        this.pitch = pitch;
        this.unknown4 = unknown4;
        this.disableRelativeVolume = disableRelativeVolume;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        LevelSoundEvent ret = new LevelSoundEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "LevelSoundEvent(sound: " ~ std.conv.to!string(this.sound) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", volume: " ~ std.conv.to!string(this.volume) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ", unknown4: " ~ std.conv.to!string(this.unknown4) ~ ", disableRelativeVolume: " ~ std.conv.to!string(this.disableRelativeVolume) ~ ")";
    }

}

class LevelEvent : Bedrock201Packet
{

    enum uint ID = 25;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // event id
    enum int START_RAIN = 3001;
    enum int START_THUNDER = 3002;
    enum int STOP_RAIN = 3003;
    enum int STOP_THUNDER = 3004;
    enum int START_BLOCK_BREAK = 3600;
    enum int STOP_BLOCK_BREAK = 3601;
    enum int SET_DATA = 4000;
    enum int PLAYERS_SLEEPING = 9800;
    enum int PARTICLE_BUBBLE = 16385;
    enum int PARTICLE_CRITICAL = 16386;
    enum int PARTICLE_BLOCK_FORCE_FIELD = 16387;
    enum int PARTICLE_SMOKE = 16388;
    enum int PARTICLE_EXPLODE = 16389;
    enum int PARTICLE_EVAPORATION = 16390;
    enum int PARTICLE_FLAME = 16391;
    enum int PARTICLE_LAVA = 16392;
    enum int PARTICLE_LARGE_SMOKE = 16393;
    enum int PARTICLE_REDSTONE = 16394;
    enum int PARTICLE_RISING_RED_DUST = 16395;
    enum int PARTICLE_ITEM_BREAK = 16396;
    enum int PARTICLE_SNOWBALL_POOF = 16397;
    enum int PARTICLE_HUGE_EXPLODE = 16398;
    enum int PARTICLE_HUGE_EXPLODE_SEED = 16399;
    enum int PARTICLE_MOB_FLAME = 16400;
    enum int PARTICLE_HEART = 16401;
    enum int PARTICLE_TERRAIN = 16402;
    enum int PARTICLE_TOWN_AURA = 16403;
    enum int PARTICLE_PORTAL = 16404;
    enum int PARTICLE_WATER_SPLASH = 16405;
    enum int PARTICLE_WATER_WAKE = 16406;
    enum int PARTICLE_DRIP_WATER = 16407;
    enum int PARTICLE_DRIP_LAVA = 16408;
    enum int PARTICLE_FALLING_DUST = 16409;
    enum int PARTICLE_MOB_SPELL = 16410;
    enum int PARTICLE_MOB_SPELL_AMBIENT = 16411;
    enum int PARTICLE_MOB_SPELL_INSTANTANEOUS = 16412;
    enum int PARTICLE_INK = 16413;
    enum int PARTICLE_SLIME = 16414;
    enum int PARTICLE_RAIN_SPLASH = 16415;
    enum int PARTICLE_VILLAGER_ANGRY = 16416;
    enum int PARTICLE_VILLAGER_HAPPY = 16417;
    enum int PARTICLE_ENCHANTMENT_TABLE = 16418;
    enum int PARTICLE_TRACKING_EMITTER = 16419;
    enum int PARTICLE_NOTE = 16420;
    enum int PARTICLE_WITCH_SPELL = 16421;
    enum int PARTICLE_CARROT = 16422;
    enum int PARTICLE_END_ROD = 16424;
    enum int PARTICLE_DRAGON_BREATH = 16425;
    enum int PARTICLE_SHOOT = 2000;
    enum int PARTICLE_DESTROY = 2001;
    enum int PARTICLE_SPLASH = 2002;
    enum int PARTICLE_EYE_DESPAWN = 2003;
    enum int PARTICLE_SPAWN = 2004;

    enum string[] __fields = ["eventId", "position", "data"];

    @Var int eventId;
    Vector!(float, "xyz") position;
    @Var int data;

    this() pure nothrow @safe @nogc {}

    this(int eventId, Vector!(float, "xyz") position=Vector!(float, "xyz").init, int data=int.init) pure nothrow @safe @nogc
    {
        this.eventId = eventId;
        this.position = position;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        LevelEvent ret = new LevelEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "LevelEvent(eventId: " ~ std.conv.to!string(this.eventId) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class BlockEvent : Bedrock201Packet
{

    enum uint ID = 26;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position", "data"];

    soupply.bedrock201.types.BlockPosition position;
    @Var int[2] data;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.BlockPosition position, int[2] data=(int[2]).init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        BlockEvent ret = new BlockEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "BlockEvent(position: " ~ std.conv.to!string(this.position) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class EntityEvent : Bedrock201Packet
{

    enum uint ID = 27;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // event id
    enum ubyte HURT_ANIMATION = 2;
    enum ubyte DEATH_ANIMATION = 3;
    enum ubyte ARM_SWING = 4;
    enum ubyte TAME_FAIL = 6;
    enum ubyte TAME_SUCCESS = 7;
    enum ubyte SHAKE_WET = 8;
    enum ubyte USE_ITEM = 9;
    enum ubyte EAT_GRASS_ANIMATION = 10;
    enum ubyte FISH_HOOK_BUBBLES = 11;
    enum ubyte FISH_HOOK_POSITION = 12;
    enum ubyte FISH_HOOK_HOOK = 13;
    enum ubyte FISH_HOOK_TEASE = 14;
    enum ubyte SQUID_INK_CLOUD = 15;
    enum ubyte ZOMBIE_VILLAGER_CURE = 16;
    enum ubyte RESPAWN = 18;
    enum ubyte IRON_GOLEM_OFFER_FLOWER = 19;
    enum ubyte IRON_GOLEM_WITHDRAW_FLOWER = 20;
    enum ubyte LOVE_PARTICLES = 21;
    enum ubyte WITCH_SPELL_ANIMATION = 24;
    enum ubyte FIREWORK_PARTICLES = 25;
    enum ubyte SILVERFISH_SPAWN_ANIMATION = 27;
    enum ubyte WITCH_DRINK_POTION = 29;
    enum ubyte WITCH_THROWN_POTION = 30;
    enum ubyte MINECART_TNT_PRIME_FUSE = 31;
    enum ubyte PLAYER_ADD_XP_LEVELS = 34;
    enum ubyte ELDER_GUARDIAN_CURSE = 35;
    enum ubyte AGENT_ARM_SWING = 36;
    enum ubyte ENDER_DRAGON_DEATH = 37;
    enum ubyte DUST_PARTICLES = 38;
    enum ubyte EATING_ITEM = 57;
    enum ubyte BABY_ANIMAL_FEED = 60;
    enum ubyte DEATH_SMOKE_CLOUD = 61;
    enum ubyte COMPLETE_TRADE = 62;
    enum ubyte REMOVE_LEASH = 63;
    enum ubyte CONSUME_TOTEM = 65;
    enum ubyte ENTITY_SPAWN = 67;
    enum ubyte DRAGON_PUKE = 68;
    enum ubyte ITEM_ENTITY_MERGE = 69;

    enum string[] __fields = ["entityId", "eventId", "data"];

    @Var long entityId;
    ubyte eventId;
    @Var int data;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ubyte eventId=ubyte.init, int data=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.eventId = eventId;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        EntityEvent ret = new EntityEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "EntityEvent(entityId: " ~ std.conv.to!string(this.entityId) ~ ", eventId: " ~ std.conv.to!string(this.eventId) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class MobEffect : Bedrock201Packet
{

    enum uint ID = 28;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // event id
    enum ubyte ADD = 1;
    enum ubyte MODIFY = 2;
    enum ubyte REMOVE = 3;

    enum string[] __fields = ["entityId", "eventId", "effect", "amplifier", "particles", "duration"];

    @Var long entityId;
    ubyte eventId;
    @Var int effect;
    @Var int amplifier;
    bool particles;
    @Var int duration;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ubyte eventId=ubyte.init, int effect=int.init, int amplifier=int.init, bool particles=bool.init, int duration=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.eventId = eventId;
        this.effect = effect;
        this.amplifier = amplifier;
        this.particles = particles;
        this.duration = duration;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MobEffect ret = new MobEffect();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MobEffect(entityId: " ~ std.conv.to!string(this.entityId) ~ ", eventId: " ~ std.conv.to!string(this.eventId) ~ ", effect: " ~ std.conv.to!string(this.effect) ~ ", amplifier: " ~ std.conv.to!string(this.amplifier) ~ ", particles: " ~ std.conv.to!string(this.particles) ~ ", duration: " ~ std.conv.to!string(this.duration) ~ ")";
    }

}

class UpdateAttributes : Bedrock201Packet
{

    enum uint ID = 29;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "attributes"];

    @Var long entityId;
    soupply.bedrock201.types.Attribute[] attributes;

    this() pure nothrow @safe @nogc {}

    this(long entityId, soupply.bedrock201.types.Attribute[] attributes=(soupply.bedrock201.types.Attribute[]).init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.attributes = attributes;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        UpdateAttributes ret = new UpdateAttributes();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "UpdateAttributes(entityId: " ~ std.conv.to!string(this.entityId) ~ ", attributes: " ~ std.conv.to!string(this.attributes) ~ ")";
    }

}

class InventoryTransaction : Bedrock201Packet
{

    enum uint ID = 30;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["type", "actions"];

    @Var uint type;
    soupply.bedrock201.types.InventoryAction[] actions;

    this() pure nothrow @safe @nogc {}

    this(uint type, soupply.bedrock201.types.InventoryAction[] actions=(soupply.bedrock201.types.InventoryAction[]).init) pure nothrow @safe @nogc
    {
        this.type = type;
        this.actions = actions;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        InventoryTransaction ret = new InventoryTransaction();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "InventoryTransaction(type: " ~ std.conv.to!string(this.type) ~ ", actions: " ~ std.conv.to!string(this.actions) ~ ")";
    }

    enum string variantField = "type";

    alias Variants = TypeTuple!(Normal0, Normal1, UseItem, UseItemOnEntity, ReleaseItem);

    class Normal0 : Bedrock201Packet
    {

        enum typeof(type) TYPE = 0;

        enum string[] __fields = [];

        mixin Make;

        override string toString()
        {
            return "InventoryTransaction.Normal0()";
        }

    }

    class Normal1 : Bedrock201Packet
    {

        enum typeof(type) TYPE = 1;

        enum string[] __fields = [];

        mixin Make;

        override string toString()
        {
            return "InventoryTransaction.Normal1()";
        }

    }

    class UseItem : Bedrock201Packet
    {

        enum typeof(type) TYPE = 2;

        // action type
        enum uint CLICK_BLOCK = 0;
        enum uint CLICK_AIR = 1;
        enum uint BREAK_BLOCK = 2;

        enum string[] __fields = ["actionType", "blockPosition", "face", "hotbarSlot", "item", "playerPosition", "clickPosition"];

        @Var uint actionType;
        soupply.bedrock201.types.BlockPosition blockPosition;
        @Var int face;
        @Var int hotbarSlot;
        soupply.bedrock201.types.Slot item;
        Vector!(float, "xyz") playerPosition;
        Vector!(float, "xyz") clickPosition;

        this() pure nothrow @safe @nogc {}

        this(uint actionType, soupply.bedrock201.types.BlockPosition blockPosition=soupply.bedrock201.types.BlockPosition.init, int face=int.init, int hotbarSlot=int.init, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init, Vector!(float, "xyz") playerPosition=Vector!(float, "xyz").init, Vector!(float, "xyz") clickPosition=Vector!(float, "xyz").init) pure nothrow @safe @nogc
        {
            this.actionType = actionType;
            this.blockPosition = blockPosition;
            this.face = face;
            this.hotbarSlot = hotbarSlot;
            this.item = item;
            this.playerPosition = playerPosition;
            this.clickPosition = clickPosition;
        }

        mixin Make;

        override string toString()
        {
            return "InventoryTransaction.UseItem(actionType: " ~ std.conv.to!string(this.actionType) ~ ", blockPosition: " ~ std.conv.to!string(this.blockPosition) ~ ", face: " ~ std.conv.to!string(this.face) ~ ", hotbarSlot: " ~ std.conv.to!string(this.hotbarSlot) ~ ", item: " ~ std.conv.to!string(this.item) ~ ", playerPosition: " ~ std.conv.to!string(this.playerPosition) ~ ", clickPosition: " ~ std.conv.to!string(this.clickPosition) ~ ")";
        }

    }

    class UseItemOnEntity : Bedrock201Packet
    {

        enum typeof(type) TYPE = 3;

        // action type
        enum uint INTERACT = 0;
        enum uint ATTACK = 1;

        enum string[] __fields = ["entityId", "actionType", "hotbarSlot", "item", "unknown4", "unknown5"];

        @Var long entityId;
        @Var uint actionType;
        @Var int hotbarSlot;
        soupply.bedrock201.types.Slot item;
        Vector!(float, "xyz") unknown4;
        Vector!(float, "xyz") unknown5;

        this() pure nothrow @safe @nogc {}

        this(long entityId, uint actionType=uint.init, int hotbarSlot=int.init, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init, Vector!(float, "xyz") unknown4=Vector!(float, "xyz").init, Vector!(float, "xyz") unknown5=Vector!(float, "xyz").init) pure nothrow @safe @nogc
        {
            this.entityId = entityId;
            this.actionType = actionType;
            this.hotbarSlot = hotbarSlot;
            this.item = item;
            this.unknown4 = unknown4;
            this.unknown5 = unknown5;
        }

        mixin Make;

        override string toString()
        {
            return "InventoryTransaction.UseItemOnEntity(entityId: " ~ std.conv.to!string(this.entityId) ~ ", actionType: " ~ std.conv.to!string(this.actionType) ~ ", hotbarSlot: " ~ std.conv.to!string(this.hotbarSlot) ~ ", item: " ~ std.conv.to!string(this.item) ~ ", unknown4: " ~ std.conv.to!string(this.unknown4) ~ ", unknown5: " ~ std.conv.to!string(this.unknown5) ~ ")";
        }

    }

    class ReleaseItem : Bedrock201Packet
    {

        enum typeof(type) TYPE = 4;

        // action type
        enum uint SHOOT_BOW = 0;
        enum uint CONSUME = 1;

        enum string[] __fields = ["actionType", "hotbarSlot", "item", "headPosition"];

        @Var uint actionType;
        @Var int hotbarSlot;
        soupply.bedrock201.types.Slot item;
        Vector!(float, "xyz") headPosition;

        this() pure nothrow @safe @nogc {}

        this(uint actionType, int hotbarSlot=int.init, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init, Vector!(float, "xyz") headPosition=Vector!(float, "xyz").init) pure nothrow @safe @nogc
        {
            this.actionType = actionType;
            this.hotbarSlot = hotbarSlot;
            this.item = item;
            this.headPosition = headPosition;
        }

        mixin Make;

        override string toString()
        {
            return "InventoryTransaction.ReleaseItem(actionType: " ~ std.conv.to!string(this.actionType) ~ ", hotbarSlot: " ~ std.conv.to!string(this.hotbarSlot) ~ ", item: " ~ std.conv.to!string(this.item) ~ ", headPosition: " ~ std.conv.to!string(this.headPosition) ~ ")";
        }

    }

}

class MobEquipment : Bedrock201Packet
{

    enum uint ID = 31;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["entityId", "item", "inventorySlot", "hotbarSlot", "unknown4"];

    @Var long entityId;
    soupply.bedrock201.types.Slot item;
    ubyte inventorySlot;
    ubyte hotbarSlot;
    ubyte unknown4;

    this() pure nothrow @safe @nogc {}

    this(long entityId, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init, ubyte inventorySlot=ubyte.init, ubyte hotbarSlot=ubyte.init, ubyte unknown4=ubyte.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.item = item;
        this.inventorySlot = inventorySlot;
        this.hotbarSlot = hotbarSlot;
        this.unknown4 = unknown4;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MobEquipment ret = new MobEquipment();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MobEquipment(entityId: " ~ std.conv.to!string(this.entityId) ~ ", item: " ~ std.conv.to!string(this.item) ~ ", inventorySlot: " ~ std.conv.to!string(this.inventorySlot) ~ ", hotbarSlot: " ~ std.conv.to!string(this.hotbarSlot) ~ ", unknown4: " ~ std.conv.to!string(this.unknown4) ~ ")";
    }

}

class MobArmorEquipment : Bedrock201Packet
{

    enum uint ID = 32;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["entityId", "armor"];

    @Var long entityId;
    soupply.bedrock201.types.Slot[4] armor;

    this() pure nothrow @safe @nogc {}

    this(long entityId, soupply.bedrock201.types.Slot[4] armor=(soupply.bedrock201.types.Slot[4]).init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.armor = armor;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MobArmorEquipment ret = new MobArmorEquipment();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MobArmorEquipment(entityId: " ~ std.conv.to!string(this.entityId) ~ ", armor: " ~ std.conv.to!string(this.armor) ~ ")";
    }

}

class Interact : Bedrock201Packet
{

    enum uint ID = 33;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    // action
    enum ubyte LEAVE_VEHICLE = 3;
    enum ubyte HOVER = 4;
    enum ubyte OPEN_INVENTORY = 6;

    enum string[] __fields = ["action", "target", "targetPosition"];

    ubyte action;
    @Var long target;
    @Condition("action==4") Vector!(float, "xyz") targetPosition;

    this() pure nothrow @safe @nogc {}

    this(ubyte action, long target=long.init, Vector!(float, "xyz") targetPosition=Vector!(float, "xyz").init) pure nothrow @safe @nogc
    {
        this.action = action;
        this.target = target;
        this.targetPosition = targetPosition;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Interact ret = new Interact();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Interact(action: " ~ std.conv.to!string(this.action) ~ ", target: " ~ std.conv.to!string(this.target) ~ ", targetPosition: " ~ std.conv.to!string(this.targetPosition) ~ ")";
    }

}

class BlockPickRequest : Bedrock201Packet
{

    enum uint ID = 34;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["position", "unknown1", "slot"];

    @Var Vector!(int, "xyz") position;
    bool unknown1;
    ubyte slot;

    this() pure nothrow @safe @nogc {}

    this(Vector!(int, "xyz") position, bool unknown1=bool.init, ubyte slot=ubyte.init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.unknown1 = unknown1;
        this.slot = slot;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        BlockPickRequest ret = new BlockPickRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "BlockPickRequest(position: " ~ std.conv.to!string(this.position) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", slot: " ~ std.conv.to!string(this.slot) ~ ")";
    }

}

class EntityPickRequest : Bedrock201Packet
{

    enum uint ID = 35;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["entityType", "slot"];

    long entityType;
    ubyte slot;

    this() pure nothrow @safe @nogc {}

    this(long entityType, ubyte slot=ubyte.init) pure nothrow @safe @nogc
    {
        this.entityType = entityType;
        this.slot = slot;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        EntityPickRequest ret = new EntityPickRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "EntityPickRequest(entityType: " ~ std.conv.to!string(this.entityType) ~ ", slot: " ~ std.conv.to!string(this.slot) ~ ")";
    }

}

class PlayerAction : Bedrock201Packet
{

    enum uint ID = 36;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    // action
    enum int START_BREAK = 0;
    enum int ABORT_BREAK = 1;
    enum int STOP_BREAK = 2;
    enum int GET_UPDATED_BLOCK = 3;
    enum int DROP_ITEM = 4;
    enum int START_SLEEPING = 5;
    enum int STOP_SLEEPING = 6;
    enum int RESPAWN = 7;
    enum int JUMP = 8;
    enum int START_SPRINT = 9;
    enum int STOP_SPRINT = 10;
    enum int START_SNEAK = 11;
    enum int STOP_SNEAK = 12;
    enum int START_GLIDING = 15;
    enum int STOP_GLIDING = 16;
    enum int BUILD_DENIED = 17;
    enum int CONTINUE_BREAK = 18;
    enum int CHANGE_SKIN = 19;

    enum string[] __fields = ["entityId", "action", "position", "face"];

    @Var long entityId;
    @Var int action;
    soupply.bedrock201.types.BlockPosition position;
    @Var int face;

    this() pure nothrow @safe @nogc {}

    this(long entityId, int action=int.init, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, int face=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.action = action;
        this.position = position;
        this.face = face;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayerAction ret = new PlayerAction();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayerAction(entityId: " ~ std.conv.to!string(this.entityId) ~ ", action: " ~ std.conv.to!string(this.action) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", face: " ~ std.conv.to!string(this.face) ~ ")";
    }

}

class EntityFall : Bedrock201Packet
{

    enum uint ID = 37;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["entityId", "distance", "unknown2"];

    @Var long entityId;
    float distance;
    bool unknown2;

    this() pure nothrow @safe @nogc {}

    this(long entityId, float distance=float.init, bool unknown2=bool.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.distance = distance;
        this.unknown2 = unknown2;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        EntityFall ret = new EntityFall();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "EntityFall(entityId: " ~ std.conv.to!string(this.entityId) ~ ", distance: " ~ std.conv.to!string(this.distance) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
    }

}

class HurtArmor : Bedrock201Packet
{

    enum uint ID = 38;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0"];

    @Var int unknown0;

    this() pure nothrow @safe @nogc {}

    this(int unknown0) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        HurtArmor ret = new HurtArmor();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "HurtArmor(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ")";
    }

}

class SetEntityData : Bedrock201Packet
{

    enum uint ID = 39;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "metadata"];

    @Var long entityId;
    Metadata metadata;

    this() pure nothrow @safe @nogc {}

    this(long entityId, Metadata metadata=Metadata.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.metadata = metadata;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetEntityData ret = new SetEntityData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetEntityData(entityId: " ~ std.conv.to!string(this.entityId) ~ ", metadata: " ~ std.conv.to!string(this.metadata) ~ ")";
    }

}

class SetEntityMotion : Bedrock201Packet
{

    enum uint ID = 40;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "motion"];

    @Var long entityId;
    Vector!(float, "xyz") motion;

    this() pure nothrow @safe @nogc {}

    this(long entityId, Vector!(float, "xyz") motion=Vector!(float, "xyz").init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.motion = motion;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetEntityMotion ret = new SetEntityMotion();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetEntityMotion(entityId: " ~ std.conv.to!string(this.entityId) ~ ", motion: " ~ std.conv.to!string(this.motion) ~ ")";
    }

}

class SetEntityLink : Bedrock201Packet
{

    enum uint ID = 41;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // action
    enum ubyte REMOVE = 0;
    enum ubyte ADD = 1;

    enum string[] __fields = ["vehicle", "passenger", "action"];

    @Var long vehicle;
    @Var long passenger;
    ubyte action;

    this() pure nothrow @safe @nogc {}

    this(long vehicle, long passenger=long.init, ubyte action=ubyte.init) pure nothrow @safe @nogc
    {
        this.vehicle = vehicle;
        this.passenger = passenger;
        this.action = action;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetEntityLink ret = new SetEntityLink();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetEntityLink(vehicle: " ~ std.conv.to!string(this.vehicle) ~ ", passenger: " ~ std.conv.to!string(this.passenger) ~ ", action: " ~ std.conv.to!string(this.action) ~ ")";
    }

}

class SetHealth : Bedrock201Packet
{

    enum uint ID = 42;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["health"];

    @Var int health;

    this() pure nothrow @safe @nogc {}

    this(int health) pure nothrow @safe @nogc
    {
        this.health = health;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetHealth ret = new SetHealth();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetHealth(health: " ~ std.conv.to!string(this.health) ~ ")";
    }

}

class SetSpawnPosition : Bedrock201Packet
{

    enum uint ID = 43;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // type
    enum int PLAYER_SPAWN = 0;
    enum int WORLD_SPAWN = 1;

    enum string[] __fields = ["type", "position", "forced"];

    @Var int type;
    soupply.bedrock201.types.BlockPosition position;
    bool forced;

    this() pure nothrow @safe @nogc {}

    this(int type, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, bool forced=bool.init) pure nothrow @safe @nogc
    {
        this.type = type;
        this.position = position;
        this.forced = forced;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetSpawnPosition ret = new SetSpawnPosition();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetSpawnPosition(type: " ~ std.conv.to!string(this.type) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", forced: " ~ std.conv.to!string(this.forced) ~ ")";
    }

}

class Animate : Bedrock201Packet
{

    enum uint ID = 44;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // action
    enum int BREAKING = 1;
    enum int WAKE_UP = 3;

    enum string[] __fields = ["action", "entityId", "unknown2"];

    @Var int action;
    @Var long entityId;
    @Condition("action>128") float unknown2;

    this() pure nothrow @safe @nogc {}

    this(int action, long entityId=long.init, float unknown2=float.init) pure nothrow @safe @nogc
    {
        this.action = action;
        this.entityId = entityId;
        this.unknown2 = unknown2;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Animate ret = new Animate();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Animate(action: " ~ std.conv.to!string(this.action) ~ ", entityId: " ~ std.conv.to!string(this.entityId) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
    }

}

class Respawn : Bedrock201Packet
{

    enum uint ID = 45;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position"];

    Vector!(float, "xyz") position;

    this() pure nothrow @safe @nogc {}

    this(Vector!(float, "xyz") position) pure nothrow @safe @nogc
    {
        this.position = position;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Respawn ret = new Respawn();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Respawn(position: " ~ std.conv.to!string(this.position) ~ ")";
    }

}

class ContainerOpen : Bedrock201Packet
{

    enum uint ID = 46;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["window", "type", "position", "entityId"];

    ubyte window;
    ubyte type;
    soupply.bedrock201.types.BlockPosition position;
    @Var long entityId;

    this() pure nothrow @safe @nogc {}

    this(ubyte window, ubyte type=ubyte.init, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, long entityId=long.init) pure nothrow @safe @nogc
    {
        this.window = window;
        this.type = type;
        this.position = position;
        this.entityId = entityId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ContainerOpen ret = new ContainerOpen();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ContainerOpen(window: " ~ std.conv.to!string(this.window) ~ ", type: " ~ std.conv.to!string(this.type) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", entityId: " ~ std.conv.to!string(this.entityId) ~ ")";
    }

}

class ContainerClose : Bedrock201Packet
{

    enum uint ID = 47;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["window"];

    ubyte window;

    this() pure nothrow @safe @nogc {}

    this(ubyte window) pure nothrow @safe @nogc
    {
        this.window = window;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ContainerClose ret = new ContainerClose();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ContainerClose(window: " ~ std.conv.to!string(this.window) ~ ")";
    }

}

class PlayerHotbar : Bedrock201Packet
{

    enum uint ID = 48;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayerHotbar ret = new PlayerHotbar();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayerHotbar()";
    }

}

class InventoryContent : Bedrock201Packet
{

    enum uint ID = 49;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["window", "slots"];

    @Var uint window;
    soupply.bedrock201.types.Slot[] slots;

    this() pure nothrow @safe @nogc {}

    this(uint window, soupply.bedrock201.types.Slot[] slots=(soupply.bedrock201.types.Slot[]).init) pure nothrow @safe @nogc
    {
        this.window = window;
        this.slots = slots;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        InventoryContent ret = new InventoryContent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "InventoryContent(window: " ~ std.conv.to!string(this.window) ~ ", slots: " ~ std.conv.to!string(this.slots) ~ ")";
    }

}

class InventorySlot : Bedrock201Packet
{

    enum uint ID = 50;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        InventorySlot ret = new InventorySlot();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "InventorySlot()";
    }

}

class ContainerSetData : Bedrock201Packet
{

    enum uint ID = 51;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["window", "property", "value"];

    ubyte window;
    @Var int property;
    @Var int value;

    this() pure nothrow @safe @nogc {}

    this(ubyte window, int property=int.init, int value=int.init) pure nothrow @safe @nogc
    {
        this.window = window;
        this.property = property;
        this.value = value;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ContainerSetData ret = new ContainerSetData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ContainerSetData(window: " ~ std.conv.to!string(this.window) ~ ", property: " ~ std.conv.to!string(this.property) ~ ", value: " ~ std.conv.to!string(this.value) ~ ")";
    }

}

class CraftingData : Bedrock201Packet
{

    enum uint ID = 52;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["recipes"];

    soupply.bedrock201.types.Recipe[] recipes;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.Recipe[] recipes) pure nothrow @safe @nogc
    {
        this.recipes = recipes;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        CraftingData ret = new CraftingData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "CraftingData(recipes: " ~ std.conv.to!string(this.recipes) ~ ")";
    }

}

class CraftingEvent : Bedrock201Packet
{

    enum uint ID = 53;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["window", "type", "uuid", "input", "output"];

    ubyte window;
    @Var int type;
    soupply.bedrock201.types.McpeUuid uuid;
    soupply.bedrock201.types.Slot[] input;
    soupply.bedrock201.types.Slot[] output;

    this() pure nothrow @safe @nogc {}

    this(ubyte window, int type=int.init, soupply.bedrock201.types.McpeUuid uuid=soupply.bedrock201.types.McpeUuid.init, soupply.bedrock201.types.Slot[] input=(soupply.bedrock201.types.Slot[]).init, soupply.bedrock201.types.Slot[] output=(soupply.bedrock201.types.Slot[]).init) pure nothrow @safe @nogc
    {
        this.window = window;
        this.type = type;
        this.uuid = uuid;
        this.input = input;
        this.output = output;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        CraftingEvent ret = new CraftingEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "CraftingEvent(window: " ~ std.conv.to!string(this.window) ~ ", type: " ~ std.conv.to!string(this.type) ~ ", uuid: " ~ std.conv.to!string(this.uuid) ~ ", input: " ~ std.conv.to!string(this.input) ~ ", output: " ~ std.conv.to!string(this.output) ~ ")";
    }

}

class GuiDataPickItem : Bedrock201Packet
{

    enum uint ID = 54;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["slot"];

    @LittleEndian uint slot;

    this() pure nothrow @safe @nogc {}

    this(uint slot) pure nothrow @safe @nogc
    {
        this.slot = slot;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        GuiDataPickItem ret = new GuiDataPickItem();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "GuiDataPickItem(slot: " ~ std.conv.to!string(this.slot) ~ ")";
    }

}

class AdventureSettings : Bedrock201Packet
{

    enum uint ID = 55;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // flags
    enum uint IMMUTABLE_WORLD = 1;
    enum uint PVP_DISABLED = 2;
    enum uint PVM_DISABLED = 4;
    enum uint MVP_DISBALED = 8;
    enum uint EVP_DISABLED = 16;
    enum uint AUTO_JUMP = 32;
    enum uint ALLOW_FLIGHT = 64;
    enum uint NO_CLIP = 128;
    enum uint FLYING = 512;
    enum uint MUTED = 1024;

    // permission level
    enum uint LEVEL_USER = 0;
    enum uint LEVEL_OPERATOR = 1;
    enum uint LEVEL_HOST = 2;
    enum uint LEVEL_AUTOMATION = 3;
    enum uint LEVEL_ADMIN = 4;

    // abilities
    enum uint BUILD_AND_MINE = 1;
    enum uint DOORS_AND_SWITCHES = 2;
    enum uint OPEN_CONTAINERS = 4;
    enum uint ATTACK_PLAYERS = 8;
    enum uint ATTACK_MOBS = 16;
    enum uint OP = 32;
    enum uint TELEPORT = 64;

    // player rank
    enum uint VISITOR = 0;
    enum uint MEMBER = 1;
    enum uint OPERATOR = 2;
    enum uint CUSTOM = 3;

    enum string[] __fields = ["flags", "permissionLevel", "abilities", "playerRank", "customPermissions", "entityId"];

    @Var uint flags;
    @Var uint permissionLevel;
    @Var uint abilities;
    @Var uint playerRank;
    @Var uint customPermissions;
    long entityId;

    this() pure nothrow @safe @nogc {}

    this(uint flags, uint permissionLevel=uint.init, uint abilities=uint.init, uint playerRank=uint.init, uint customPermissions=uint.init, long entityId=long.init) pure nothrow @safe @nogc
    {
        this.flags = flags;
        this.permissionLevel = permissionLevel;
        this.abilities = abilities;
        this.playerRank = playerRank;
        this.customPermissions = customPermissions;
        this.entityId = entityId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AdventureSettings ret = new AdventureSettings();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AdventureSettings(flags: " ~ std.conv.to!string(this.flags) ~ ", permissionLevel: " ~ std.conv.to!string(this.permissionLevel) ~ ", abilities: " ~ std.conv.to!string(this.abilities) ~ ", playerRank: " ~ std.conv.to!string(this.playerRank) ~ ", customPermissions: " ~ std.conv.to!string(this.customPermissions) ~ ", entityId: " ~ std.conv.to!string(this.entityId) ~ ")";
    }

}

class BlockEntityData : Bedrock201Packet
{

    enum uint ID = 56;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["position", "nbt"];

    soupply.bedrock201.types.BlockPosition position;
    @NoLength ubyte[] nbt;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.BlockPosition position, ubyte[] nbt=(ubyte[]).init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.nbt = nbt;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        BlockEntityData ret = new BlockEntityData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "BlockEntityData(position: " ~ std.conv.to!string(this.position) ~ ", nbt: " ~ std.conv.to!string(this.nbt) ~ ")";
    }

}

class PlayerInput : Bedrock201Packet
{

    enum uint ID = 57;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["sideways", "forward", "unknown2", "unknown3"];

    float sideways;
    float forward;
    bool unknown2;
    bool unknown3;

    this() pure nothrow @safe @nogc {}

    this(float sideways, float forward=float.init, bool unknown2=bool.init, bool unknown3=bool.init) pure nothrow @safe @nogc
    {
        this.sideways = sideways;
        this.forward = forward;
        this.unknown2 = unknown2;
        this.unknown3 = unknown3;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayerInput ret = new PlayerInput();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayerInput(sideways: " ~ std.conv.to!string(this.sideways) ~ ", forward: " ~ std.conv.to!string(this.forward) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ", unknown3: " ~ std.conv.to!string(this.unknown3) ~ ")";
    }

}

class FullChunkData : Bedrock201Packet
{

    enum uint ID = 58;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position", "data"];

    @Var Vector!(int, "xz") position;
    soupply.bedrock201.types.ChunkData data;

    this() pure nothrow @safe @nogc {}

    this(Vector!(int, "xz") position, soupply.bedrock201.types.ChunkData data=soupply.bedrock201.types.ChunkData.init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        FullChunkData ret = new FullChunkData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "FullChunkData(position: " ~ std.conv.to!string(this.position) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class SetCommandsEnabled : Bedrock201Packet
{

    enum uint ID = 59;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["enabled"];

    bool enabled;

    this() pure nothrow @safe @nogc {}

    this(bool enabled) pure nothrow @safe @nogc
    {
        this.enabled = enabled;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetCommandsEnabled ret = new SetCommandsEnabled();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetCommandsEnabled(enabled: " ~ std.conv.to!string(this.enabled) ~ ")";
    }

}

class SetDifficulty : Bedrock201Packet
{

    enum uint ID = 60;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // difficulty
    enum uint PEACEFUL = 0;
    enum uint EASY = 1;
    enum uint NORMAL = 2;
    enum uint HARD = 3;

    enum string[] __fields = ["difficulty"];

    @Var uint difficulty;

    this() pure nothrow @safe @nogc {}

    this(uint difficulty) pure nothrow @safe @nogc
    {
        this.difficulty = difficulty;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetDifficulty ret = new SetDifficulty();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetDifficulty(difficulty: " ~ std.conv.to!string(this.difficulty) ~ ")";
    }

}

class ChangeDimension : Bedrock201Packet
{

    enum uint ID = 61;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // dimension
    enum int OVERWORLD = 0;
    enum int NETHER = 1;
    enum int END = 2;

    enum string[] __fields = ["dimension", "position", "unknown2"];

    @Var int dimension;
    Vector!(float, "xyz") position;
    bool unknown2;

    this() pure nothrow @safe @nogc {}

    this(int dimension, Vector!(float, "xyz") position=Vector!(float, "xyz").init, bool unknown2=bool.init) pure nothrow @safe @nogc
    {
        this.dimension = dimension;
        this.position = position;
        this.unknown2 = unknown2;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ChangeDimension ret = new ChangeDimension();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ChangeDimension(dimension: " ~ std.conv.to!string(this.dimension) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
    }

}

class SetPlayerGameType : Bedrock201Packet
{

    enum uint ID = 62;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // gamemode
    enum int SURVIVAL = 0;
    enum int CREATIVE = 1;
    enum int ADVENTURE = 2;

    enum string[] __fields = ["gamemode"];

    @Var int gamemode;

    this() pure nothrow @safe @nogc {}

    this(int gamemode) pure nothrow @safe @nogc
    {
        this.gamemode = gamemode;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetPlayerGameType ret = new SetPlayerGameType();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetPlayerGameType(gamemode: " ~ std.conv.to!string(this.gamemode) ~ ")";
    }

}

class PlayerList : Bedrock201Packet
{

    enum uint ID = 63;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["action"];

    ubyte action;

    this() pure nothrow @safe @nogc {}

    this(ubyte action) pure nothrow @safe @nogc
    {
        this.action = action;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayerList ret = new PlayerList();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayerList(action: " ~ std.conv.to!string(this.action) ~ ")";
    }

    enum string variantField = "action";

    alias Variants = TypeTuple!(Add, Remove);

    class Add : Bedrock201Packet
    {

        enum typeof(action) ACTION = 0;

        enum string[] __fields = ["players"];

        soupply.bedrock201.types.PlayerList[] players;

        this() pure nothrow @safe @nogc {}

        this(soupply.bedrock201.types.PlayerList[] players) pure nothrow @safe @nogc
        {
            this.players = players;
        }

        mixin Make;

        override string toString()
        {
            return "PlayerList.Add(players: " ~ std.conv.to!string(this.players) ~ ")";
        }

    }

    class Remove : Bedrock201Packet
    {

        enum typeof(action) ACTION = 1;

        enum string[] __fields = ["players"];

        soupply.bedrock201.types.McpeUuid[] players;

        this() pure nothrow @safe @nogc {}

        this(soupply.bedrock201.types.McpeUuid[] players) pure nothrow @safe @nogc
        {
            this.players = players;
        }

        mixin Make;

        override string toString()
        {
            return "PlayerList.Remove(players: " ~ std.conv.to!string(this.players) ~ ")";
        }

    }

}

class SimpleEvent : Bedrock201Packet
{

    enum uint ID = 64;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SimpleEvent ret = new SimpleEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SimpleEvent()";
    }

}

class TelemetryEvent : Bedrock201Packet
{

    enum uint ID = 65;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["entityId", "eventId"];

    @Var long entityId;
    @Var int eventId;

    this() pure nothrow @safe @nogc {}

    this(long entityId, int eventId=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.eventId = eventId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        TelemetryEvent ret = new TelemetryEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "TelemetryEvent(entityId: " ~ std.conv.to!string(this.entityId) ~ ", eventId: " ~ std.conv.to!string(this.eventId) ~ ")";
    }

}

class SpawnExperienceOrb : Bedrock201Packet
{

    enum uint ID = 66;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position", "count"];

    Vector!(float, "xyz") position;
    @Var int count;

    this() pure nothrow @safe @nogc {}

    this(Vector!(float, "xyz") position, int count=int.init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.count = count;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SpawnExperienceOrb ret = new SpawnExperienceOrb();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SpawnExperienceOrb(position: " ~ std.conv.to!string(this.position) ~ ", count: " ~ std.conv.to!string(this.count) ~ ")";
    }

}

class ClientboundMapItemData : Bedrock201Packet
{

    enum uint ID = 67;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // update
    enum uint TEXTURE = 2;
    enum uint DECORATIONS = 4;
    enum uint ENTITIES = 8;

    enum string[] __fields = ["mapId", "update", "scale", "size", "offset", "data", "decorations"];

    @Var long mapId;
    @Var uint update;
    @Condition("update==2||update==4") ubyte scale;
    @Condition("update==2") @Var Vector!(int, "xz") size;
    @Condition("update==2") @Var Vector!(int, "xz") offset;
    @Condition("update==2") @NoLength ubyte[] data;
    @Condition("update==4") soupply.bedrock201.types.Decoration[] decorations;

    this() pure nothrow @safe @nogc {}

    this(long mapId, uint update=uint.init, ubyte scale=ubyte.init, Vector!(int, "xz") size=Vector!(int, "xz").init, Vector!(int, "xz") offset=Vector!(int, "xz").init, ubyte[] data=(ubyte[]).init, soupply.bedrock201.types.Decoration[] decorations=(soupply.bedrock201.types.Decoration[]).init) pure nothrow @safe @nogc
    {
        this.mapId = mapId;
        this.update = update;
        this.scale = scale;
        this.size = size;
        this.offset = offset;
        this.data = data;
        this.decorations = decorations;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ClientboundMapItemData ret = new ClientboundMapItemData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ClientboundMapItemData(mapId: " ~ std.conv.to!string(this.mapId) ~ ", update: " ~ std.conv.to!string(this.update) ~ ", scale: " ~ std.conv.to!string(this.scale) ~ ", size: " ~ std.conv.to!string(this.size) ~ ", offset: " ~ std.conv.to!string(this.offset) ~ ", data: " ~ std.conv.to!string(this.data) ~ ", decorations: " ~ std.conv.to!string(this.decorations) ~ ")";
    }

}

class MapInfoRequest : Bedrock201Packet
{

    enum uint ID = 68;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["mapId"];

    @Var long mapId;

    this() pure nothrow @safe @nogc {}

    this(long mapId) pure nothrow @safe @nogc
    {
        this.mapId = mapId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        MapInfoRequest ret = new MapInfoRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "MapInfoRequest(mapId: " ~ std.conv.to!string(this.mapId) ~ ")";
    }

}

class RequestChunkRadius : Bedrock201Packet
{

    enum uint ID = 69;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["radius"];

    @Var int radius;

    this() pure nothrow @safe @nogc {}

    this(int radius) pure nothrow @safe @nogc
    {
        this.radius = radius;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        RequestChunkRadius ret = new RequestChunkRadius();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "RequestChunkRadius(radius: " ~ std.conv.to!string(this.radius) ~ ")";
    }

}

class ChunkRadiusUpdated : Bedrock201Packet
{

    enum uint ID = 70;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["radius"];

    @Var int radius;

    this() pure nothrow @safe @nogc {}

    this(int radius) pure nothrow @safe @nogc
    {
        this.radius = radius;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ChunkRadiusUpdated ret = new ChunkRadiusUpdated();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ChunkRadiusUpdated(radius: " ~ std.conv.to!string(this.radius) ~ ")";
    }

}

class ItemFrameDropItem : Bedrock201Packet
{

    enum uint ID = 71;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["position", "item"];

    soupply.bedrock201.types.BlockPosition position;
    soupply.bedrock201.types.Slot item;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.BlockPosition position, soupply.bedrock201.types.Slot item=soupply.bedrock201.types.Slot.init) pure nothrow @safe @nogc
    {
        this.position = position;
        this.item = item;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ItemFrameDropItem ret = new ItemFrameDropItem();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ItemFrameDropItem(position: " ~ std.conv.to!string(this.position) ~ ", item: " ~ std.conv.to!string(this.item) ~ ")";
    }

}

class GameRulesChanged : Bedrock201Packet
{

    enum uint ID = 72;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["rules"];

    soupply.bedrock201.types.Rule[] rules;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.Rule[] rules) pure nothrow @safe @nogc
    {
        this.rules = rules;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        GameRulesChanged ret = new GameRulesChanged();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "GameRulesChanged(rules: " ~ std.conv.to!string(this.rules) ~ ")";
    }

}

class Camera : Bedrock201Packet
{

    enum uint ID = 73;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0", "unknown1"];

    @Var long unknown0;
    @Var long unknown1;

    this() pure nothrow @safe @nogc {}

    this(long unknown0, long unknown1=long.init) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
        this.unknown1 = unknown1;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Camera ret = new Camera();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Camera(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ")";
    }

}

class BossEvent : Bedrock201Packet
{

    enum uint ID = 74;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // event id
    enum uint ADD = 0;
    enum uint UPDATE = 1;
    enum uint REMOVE = 2;

    enum string[] __fields = ["entityId", "eventId"];

    @Var long entityId;
    @Var uint eventId;

    this() pure nothrow @safe @nogc {}

    this(long entityId, uint eventId=uint.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.eventId = eventId;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        BossEvent ret = new BossEvent();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "BossEvent(entityId: " ~ std.conv.to!string(this.entityId) ~ ", eventId: " ~ std.conv.to!string(this.eventId) ~ ")";
    }

}

class ShowCredits : Bedrock201Packet
{

    enum uint ID = 75;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    // status
    enum int START = 0;
    enum int END = 1;

    enum string[] __fields = ["entityId", "status"];

    @Var long entityId;
    @Var int status;

    this() pure nothrow @safe @nogc {}

    this(long entityId, int status=int.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.status = status;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ShowCredits ret = new ShowCredits();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ShowCredits(entityId: " ~ std.conv.to!string(this.entityId) ~ ", status: " ~ std.conv.to!string(this.status) ~ ")";
    }

}

class AvailableCommands : Bedrock201Packet
{

    enum uint ID = 76;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["enumValues", "unknown1", "enums", "commands"];

    string[] enumValues;
    string[] unknown1;
    soupply.bedrock201.types.Enum[] enums;
    soupply.bedrock201.types.Command[] commands;

    this() pure nothrow @safe @nogc {}

    this(string[] enumValues, string[] unknown1=(string[]).init, soupply.bedrock201.types.Enum[] enums=(soupply.bedrock201.types.Enum[]).init, soupply.bedrock201.types.Command[] commands=(soupply.bedrock201.types.Command[]).init) pure nothrow @safe @nogc
    {
        this.enumValues = enumValues;
        this.unknown1 = unknown1;
        this.enums = enums;
        this.commands = commands;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AvailableCommands ret = new AvailableCommands();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AvailableCommands(enumValues: " ~ std.conv.to!string(this.enumValues) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", enums: " ~ std.conv.to!string(this.enums) ~ ", commands: " ~ std.conv.to!string(this.commands) ~ ")";
    }

}

class CommandRequest : Bedrock201Packet
{

    enum uint ID = 77;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    // type
    enum uint PLAYER = 0;
    enum uint COMMAND_BLOCK = 1;
    enum uint MINECART_COMMAND_BLOCK = 2;
    enum uint DEV_CONSOLE = 3;

    enum string[] __fields = ["command", "type", "uuid", "requestId", "playerId", "internal"];

    string command;
    @Var uint type;
    soupply.bedrock201.types.McpeUuid uuid;
    string requestId;
    @Condition("type==3") @Var int playerId;
    bool internal;

    this() pure nothrow @safe @nogc {}

    this(string command, uint type=uint.init, soupply.bedrock201.types.McpeUuid uuid=soupply.bedrock201.types.McpeUuid.init, string requestId=string.init, int playerId=int.init, bool internal=bool.init) pure nothrow @safe @nogc
    {
        this.command = command;
        this.type = type;
        this.uuid = uuid;
        this.requestId = requestId;
        this.playerId = playerId;
        this.internal = internal;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        CommandRequest ret = new CommandRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "CommandRequest(command: " ~ std.conv.to!string(this.command) ~ ", type: " ~ std.conv.to!string(this.type) ~ ", uuid: " ~ std.conv.to!string(this.uuid) ~ ", requestId: " ~ std.conv.to!string(this.requestId) ~ ", playerId: " ~ std.conv.to!string(this.playerId) ~ ", internal: " ~ std.conv.to!string(this.internal) ~ ")";
    }

}

class CommandBlockUpdate : Bedrock201Packet
{

    enum uint ID = 78;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["updateBlock", "position", "mode", "redstoneMode", "conditional", "minecart", "command", "lastOutput", "hover", "trackOutput"];

    bool updateBlock;
    @Condition("updateBlock==true") soupply.bedrock201.types.BlockPosition position;
    @Condition("updateBlock==true") @Var uint mode;
    @Condition("updateBlock==true") bool redstoneMode;
    @Condition("updateBlock==true") bool conditional;
    @Condition("updateBlock==false") @Var long minecart;
    string command;
    string lastOutput;
    string hover;
    bool trackOutput;

    this() pure nothrow @safe @nogc {}

    this(bool updateBlock, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, uint mode=uint.init, bool redstoneMode=bool.init, bool conditional=bool.init, long minecart=long.init, string command=string.init, string lastOutput=string.init, string hover=string.init, bool trackOutput=bool.init) pure nothrow @safe @nogc
    {
        this.updateBlock = updateBlock;
        this.position = position;
        this.mode = mode;
        this.redstoneMode = redstoneMode;
        this.conditional = conditional;
        this.minecart = minecart;
        this.command = command;
        this.lastOutput = lastOutput;
        this.hover = hover;
        this.trackOutput = trackOutput;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        CommandBlockUpdate ret = new CommandBlockUpdate();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "CommandBlockUpdate(updateBlock: " ~ std.conv.to!string(this.updateBlock) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", mode: " ~ std.conv.to!string(this.mode) ~ ", redstoneMode: " ~ std.conv.to!string(this.redstoneMode) ~ ", conditional: " ~ std.conv.to!string(this.conditional) ~ ", minecart: " ~ std.conv.to!string(this.minecart) ~ ", command: " ~ std.conv.to!string(this.command) ~ ", lastOutput: " ~ std.conv.to!string(this.lastOutput) ~ ", hover: " ~ std.conv.to!string(this.hover) ~ ", trackOutput: " ~ std.conv.to!string(this.trackOutput) ~ ")";
    }

}

class UpdateTrade : Bedrock201Packet
{

    enum uint ID = 80;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["window", "windowType", "unknown2", "unknown3", "willing", "trader", "player", "displayName", "offers"];

    ubyte window;
    ubyte windowType = 15;
    @Var int unknown2;
    @Var int unknown3;
    bool willing;
    @Var long trader;
    @Var long player;
    string displayName;
    @NoLength ubyte[] offers;

    this() pure nothrow @safe @nogc {}

    this(ubyte window, ubyte windowType=15, int unknown2=int.init, int unknown3=int.init, bool willing=bool.init, long trader=long.init, long player=long.init, string displayName=string.init, ubyte[] offers=(ubyte[]).init) pure nothrow @safe @nogc
    {
        this.window = window;
        this.windowType = windowType;
        this.unknown2 = unknown2;
        this.unknown3 = unknown3;
        this.willing = willing;
        this.trader = trader;
        this.player = player;
        this.displayName = displayName;
        this.offers = offers;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        UpdateTrade ret = new UpdateTrade();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "UpdateTrade(window: " ~ std.conv.to!string(this.window) ~ ", windowType: " ~ std.conv.to!string(this.windowType) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ", unknown3: " ~ std.conv.to!string(this.unknown3) ~ ", willing: " ~ std.conv.to!string(this.willing) ~ ", trader: " ~ std.conv.to!string(this.trader) ~ ", player: " ~ std.conv.to!string(this.player) ~ ", displayName: " ~ std.conv.to!string(this.displayName) ~ ", offers: " ~ std.conv.to!string(this.offers) ~ ")";
    }

}

class UpdateEquip : Bedrock201Packet
{

    enum uint ID = 81;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        UpdateEquip ret = new UpdateEquip();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "UpdateEquip()";
    }

}

class ResourcePackDataInfo : Bedrock201Packet
{

    enum uint ID = 82;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["id", "maxChunkSize", "chunkCount", "compressedPackSize", "sha256"];

    string id;
    uint maxChunkSize;
    uint chunkCount;
    ulong compressedPackSize;
    string sha256;

    this() pure nothrow @safe @nogc {}

    this(string id, uint maxChunkSize=uint.init, uint chunkCount=uint.init, ulong compressedPackSize=ulong.init, string sha256=string.init) pure nothrow @safe @nogc
    {
        this.id = id;
        this.maxChunkSize = maxChunkSize;
        this.chunkCount = chunkCount;
        this.compressedPackSize = compressedPackSize;
        this.sha256 = sha256;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePackDataInfo ret = new ResourcePackDataInfo();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePackDataInfo(id: " ~ std.conv.to!string(this.id) ~ ", maxChunkSize: " ~ std.conv.to!string(this.maxChunkSize) ~ ", chunkCount: " ~ std.conv.to!string(this.chunkCount) ~ ", compressedPackSize: " ~ std.conv.to!string(this.compressedPackSize) ~ ", sha256: " ~ std.conv.to!string(this.sha256) ~ ")";
    }

}

class ResourcePackChunkData : Bedrock201Packet
{

    enum uint ID = 83;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["id", "chunkIndex", "progress", "data"];

    string id;
    uint chunkIndex;
    ulong progress;
    @Length!uint ubyte[] data;

    this() pure nothrow @safe @nogc {}

    this(string id, uint chunkIndex=uint.init, ulong progress=ulong.init, ubyte[] data=(ubyte[]).init) pure nothrow @safe @nogc
    {
        this.id = id;
        this.chunkIndex = chunkIndex;
        this.progress = progress;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePackChunkData ret = new ResourcePackChunkData();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePackChunkData(id: " ~ std.conv.to!string(this.id) ~ ", chunkIndex: " ~ std.conv.to!string(this.chunkIndex) ~ ", progress: " ~ std.conv.to!string(this.progress) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class ResourcePackChunkRequest : Bedrock201Packet
{

    enum uint ID = 84;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["id", "chunkIndex"];

    string id;
    uint chunkIndex;

    this() pure nothrow @safe @nogc {}

    this(string id, uint chunkIndex=uint.init) pure nothrow @safe @nogc
    {
        this.id = id;
        this.chunkIndex = chunkIndex;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ResourcePackChunkRequest ret = new ResourcePackChunkRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ResourcePackChunkRequest(id: " ~ std.conv.to!string(this.id) ~ ", chunkIndex: " ~ std.conv.to!string(this.chunkIndex) ~ ")";
    }

}

class Transfer : Bedrock201Packet
{

    enum uint ID = 85;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["ip", "port"];

    string ip;
    ushort port = 19132;

    this() pure nothrow @safe @nogc {}

    this(string ip, ushort port=19132) pure nothrow @safe @nogc
    {
        this.ip = ip;
        this.port = port;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        Transfer ret = new Transfer();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "Transfer(ip: " ~ std.conv.to!string(this.ip) ~ ", port: " ~ std.conv.to!string(this.port) ~ ")";
    }

}

class PlaySound : Bedrock201Packet
{

    enum uint ID = 86;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["name", "position", "volume", "pitch"];

    string name;
    soupply.bedrock201.types.BlockPosition position;
    float volume;
    float pitch;

    this() pure nothrow @safe @nogc {}

    this(string name, soupply.bedrock201.types.BlockPosition position=soupply.bedrock201.types.BlockPosition.init, float volume=float.init, float pitch=float.init) pure nothrow @safe @nogc
    {
        this.name = name;
        this.position = position;
        this.volume = volume;
        this.pitch = pitch;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlaySound ret = new PlaySound();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlaySound(name: " ~ std.conv.to!string(this.name) ~ ", position: " ~ std.conv.to!string(this.position) ~ ", volume: " ~ std.conv.to!string(this.volume) ~ ", pitch: " ~ std.conv.to!string(this.pitch) ~ ")";
    }

}

class StopSound : Bedrock201Packet
{

    enum uint ID = 87;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["name", "stopAll"];

    string name;
    bool stopAll;

    this() pure nothrow @safe @nogc {}

    this(string name, bool stopAll=bool.init) pure nothrow @safe @nogc
    {
        this.name = name;
        this.stopAll = stopAll;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        StopSound ret = new StopSound();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "StopSound(name: " ~ std.conv.to!string(this.name) ~ ", stopAll: " ~ std.conv.to!string(this.stopAll) ~ ")";
    }

}

class SetTitle : Bedrock201Packet
{

    enum uint ID = 88;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // action
    enum int HIDE = 0;
    enum int RESET = 1;
    enum int SET_TITLE = 2;
    enum int SET_SUBTITLE = 3;
    enum int SET_ACTION_BAR = 4;
    enum int SET_TIMINGS = 5;

    enum string[] __fields = ["action", "text", "fadeIn", "stay", "fadeOut"];

    @Var int action;
    string text;
    @Var int fadeIn;
    @Var int stay;
    @Var int fadeOut;

    this() pure nothrow @safe @nogc {}

    this(int action, string text=string.init, int fadeIn=int.init, int stay=int.init, int fadeOut=int.init) pure nothrow @safe @nogc
    {
        this.action = action;
        this.text = text;
        this.fadeIn = fadeIn;
        this.stay = stay;
        this.fadeOut = fadeOut;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetTitle ret = new SetTitle();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetTitle(action: " ~ std.conv.to!string(this.action) ~ ", text: " ~ std.conv.to!string(this.text) ~ ", fadeIn: " ~ std.conv.to!string(this.fadeIn) ~ ", stay: " ~ std.conv.to!string(this.stay) ~ ", fadeOut: " ~ std.conv.to!string(this.fadeOut) ~ ")";
    }

}

class AddBehaviorTree : Bedrock201Packet
{

    enum uint ID = 89;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0"];

    string unknown0;

    this() pure nothrow @safe @nogc {}

    this(string unknown0) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        AddBehaviorTree ret = new AddBehaviorTree();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "AddBehaviorTree(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ")";
    }

}

class StructureBlockUpdate : Bedrock201Packet
{

    enum uint ID = 90;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        StructureBlockUpdate ret = new StructureBlockUpdate();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "StructureBlockUpdate()";
    }

}

class ShowStoreOffer : Bedrock201Packet
{

    enum uint ID = 91;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0", "unknown1", "unknown2"];

    string unknown0;
    bool unknown1;
    string unknown2;

    this() pure nothrow @safe @nogc {}

    this(string unknown0, bool unknown1=bool.init, string unknown2=string.init) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
        this.unknown1 = unknown1;
        this.unknown2 = unknown2;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ShowStoreOffer ret = new ShowStoreOffer();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ShowStoreOffer(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
    }

}

class PurchaseReceipt : Bedrock201Packet
{

    enum uint ID = 92;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["unknown0"];

    string[] unknown0;

    this() pure nothrow @safe @nogc {}

    this(string[] unknown0) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PurchaseReceipt ret = new PurchaseReceipt();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PurchaseReceipt(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ")";
    }

}

class PlayerSkin : Bedrock201Packet
{

    enum uint ID = 93;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["uuid", "skinId", "skinName", "unknown3", "skinData", "capeData", "geometryModel", "geometryData"];

    soupply.bedrock201.types.McpeUuid uuid;
    string skinId;
    string skinName;
    string unknown3;
    ubyte[] skinData;
    ubyte[] capeData;
    string geometryModel;
    ubyte[] geometryData;

    this() pure nothrow @safe @nogc {}

    this(soupply.bedrock201.types.McpeUuid uuid, string skinId=string.init, string skinName=string.init, string unknown3=string.init, ubyte[] skinData=(ubyte[]).init, ubyte[] capeData=(ubyte[]).init, string geometryModel=string.init, ubyte[] geometryData=(ubyte[]).init) pure nothrow @safe @nogc
    {
        this.uuid = uuid;
        this.skinId = skinId;
        this.skinName = skinName;
        this.unknown3 = unknown3;
        this.skinData = skinData;
        this.capeData = capeData;
        this.geometryModel = geometryModel;
        this.geometryData = geometryData;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PlayerSkin ret = new PlayerSkin();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PlayerSkin(uuid: " ~ std.conv.to!string(this.uuid) ~ ", skinId: " ~ std.conv.to!string(this.skinId) ~ ", skinName: " ~ std.conv.to!string(this.skinName) ~ ", unknown3: " ~ std.conv.to!string(this.unknown3) ~ ", skinData: " ~ std.conv.to!string(this.skinData) ~ ", capeData: " ~ std.conv.to!string(this.capeData) ~ ", geometryModel: " ~ std.conv.to!string(this.geometryModel) ~ ", geometryData: " ~ std.conv.to!string(this.geometryData) ~ ")";
    }

}

class SubClientLogin : Bedrock201Packet
{

    enum uint ID = 94;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SubClientLogin ret = new SubClientLogin();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SubClientLogin()";
    }

}

class InitiateWebSocketConnection : Bedrock201Packet
{

    enum uint ID = 95;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0"];

    string unknown0;

    this() pure nothrow @safe @nogc {}

    this(string unknown0) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        InitiateWebSocketConnection ret = new InitiateWebSocketConnection();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "InitiateWebSocketConnection(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ")";
    }

}

class SetLastHurtBy : Bedrock201Packet
{

    enum uint ID = 96;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["unknown0"];

    @Var int unknown0;

    this() pure nothrow @safe @nogc {}

    this(int unknown0) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetLastHurtBy ret = new SetLastHurtBy();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetLastHurtBy(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ")";
    }

}

class BookEdit : Bedrock201Packet
{

    enum uint ID = 97;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["type", "slot"];

    ubyte type;
    ubyte slot;

    this() pure nothrow @safe @nogc {}

    this(ubyte type, ubyte slot=ubyte.init) pure nothrow @safe @nogc
    {
        this.type = type;
        this.slot = slot;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        BookEdit ret = new BookEdit();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "BookEdit(type: " ~ std.conv.to!string(this.type) ~ ", slot: " ~ std.conv.to!string(this.slot) ~ ")";
    }

    enum string variantField = "type";

    alias Variants = TypeTuple!(ReplacePage, AddPage, DeletePage, SwapPages, Sign);

    class ReplacePage : Bedrock201Packet
    {

        enum typeof(type) TYPE = 0;

        enum string[] __fields = ["pageNumber", "unknown1", "unknown2"];

        ubyte pageNumber;
        string unknown1;
        string unknown2;

        this() pure nothrow @safe @nogc {}

        this(ubyte pageNumber, string unknown1=string.init, string unknown2=string.init) pure nothrow @safe @nogc
        {
            this.pageNumber = pageNumber;
            this.unknown1 = unknown1;
            this.unknown2 = unknown2;
        }

        mixin Make;

        override string toString()
        {
            return "BookEdit.ReplacePage(pageNumber: " ~ std.conv.to!string(this.pageNumber) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
        }

    }

    class AddPage : Bedrock201Packet
    {

        enum typeof(type) TYPE = 1;

        enum string[] __fields = ["pageNumber", "unknown1", "unknown2"];

        ubyte pageNumber;
        string unknown1;
        string unknown2;

        this() pure nothrow @safe @nogc {}

        this(ubyte pageNumber, string unknown1=string.init, string unknown2=string.init) pure nothrow @safe @nogc
        {
            this.pageNumber = pageNumber;
            this.unknown1 = unknown1;
            this.unknown2 = unknown2;
        }

        mixin Make;

        override string toString()
        {
            return "BookEdit.AddPage(pageNumber: " ~ std.conv.to!string(this.pageNumber) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
        }

    }

    class DeletePage : Bedrock201Packet
    {

        enum typeof(type) TYPE = 2;

        enum string[] __fields = ["pageNumber"];

        ubyte pageNumber;

        this() pure nothrow @safe @nogc {}

        this(ubyte pageNumber) pure nothrow @safe @nogc
        {
            this.pageNumber = pageNumber;
        }

        mixin Make;

        override string toString()
        {
            return "BookEdit.DeletePage(pageNumber: " ~ std.conv.to!string(this.pageNumber) ~ ")";
        }

    }

    class SwapPages : Bedrock201Packet
    {

        enum typeof(type) TYPE = 3;

        enum string[] __fields = ["page1", "page2"];

        ubyte page1;
        ubyte page2;

        this() pure nothrow @safe @nogc {}

        this(ubyte page1, ubyte page2=ubyte.init) pure nothrow @safe @nogc
        {
            this.page1 = page1;
            this.page2 = page2;
        }

        mixin Make;

        override string toString()
        {
            return "BookEdit.SwapPages(page1: " ~ std.conv.to!string(this.page1) ~ ", page2: " ~ std.conv.to!string(this.page2) ~ ")";
        }

    }

    class Sign : Bedrock201Packet
    {

        enum typeof(type) TYPE = 4;

        enum string[] __fields = ["title", "author"];

        string title;
        string author;

        this() pure nothrow @safe @nogc {}

        this(string title, string author=string.init) pure nothrow @safe @nogc
        {
            this.title = title;
            this.author = author;
        }

        mixin Make;

        override string toString()
        {
            return "BookEdit.Sign(title: " ~ std.conv.to!string(this.title) ~ ", author: " ~ std.conv.to!string(this.author) ~ ")";
        }

    }

}

class NpcRequest : Bedrock201Packet
{

    enum uint ID = 98;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["entityId", "requestType", "command", "actionType"];

    @Var long entityId;
    ubyte requestType;
    string command;
    ubyte actionType;

    this() pure nothrow @safe @nogc {}

    this(long entityId, ubyte requestType=ubyte.init, string command=string.init, ubyte actionType=ubyte.init) pure nothrow @safe @nogc
    {
        this.entityId = entityId;
        this.requestType = requestType;
        this.command = command;
        this.actionType = actionType;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        NpcRequest ret = new NpcRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "NpcRequest(entityId: " ~ std.conv.to!string(this.entityId) ~ ", requestType: " ~ std.conv.to!string(this.requestType) ~ ", command: " ~ std.conv.to!string(this.command) ~ ", actionType: " ~ std.conv.to!string(this.actionType) ~ ")";
    }

}

class PhotoTransfer : Bedrock201Packet
{

    enum uint ID = 99;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = ["unknown0", "unknown1", "unknown2"];

    string unknown0;
    string unknown1;
    string unknown2;

    this() pure nothrow @safe @nogc {}

    this(string unknown0, string unknown1=string.init, string unknown2=string.init) pure nothrow @safe @nogc
    {
        this.unknown0 = unknown0;
        this.unknown1 = unknown1;
        this.unknown2 = unknown2;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        PhotoTransfer ret = new PhotoTransfer();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "PhotoTransfer(unknown0: " ~ std.conv.to!string(this.unknown0) ~ ", unknown1: " ~ std.conv.to!string(this.unknown1) ~ ", unknown2: " ~ std.conv.to!string(this.unknown2) ~ ")";
    }

}

class ModalFormRequest : Bedrock201Packet
{

    enum uint ID = 100;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["formId", "data"];

    @Var uint formId;
    string data;

    this() pure nothrow @safe @nogc {}

    this(uint formId, string data=string.init) pure nothrow @safe @nogc
    {
        this.formId = formId;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ModalFormRequest ret = new ModalFormRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ModalFormRequest(formId: " ~ std.conv.to!string(this.formId) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class ModalFormResponse : Bedrock201Packet
{

    enum uint ID = 101;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["formId", "data"];

    @Var uint formId;
    string data;

    this() pure nothrow @safe @nogc {}

    this(uint formId, string data=string.init) pure nothrow @safe @nogc
    {
        this.formId = formId;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ModalFormResponse ret = new ModalFormResponse();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ModalFormResponse(formId: " ~ std.conv.to!string(this.formId) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class ServerSettingsRequest : Bedrock201Packet
{

    enum uint ID = 102;

    enum bool CLIENTBOUND = false;
    enum bool SERVERBOUND = true;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ServerSettingsRequest ret = new ServerSettingsRequest();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ServerSettingsRequest()";
    }

}

class ServerSettingsResponse : Bedrock201Packet
{

    enum uint ID = 103;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = ["formId", "data"];

    @Var uint formId;
    string data;

    this() pure nothrow @safe @nogc {}

    this(uint formId, string data=string.init) pure nothrow @safe @nogc
    {
        this.formId = formId;
        this.data = data;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ServerSettingsResponse ret = new ServerSettingsResponse();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ServerSettingsResponse(formId: " ~ std.conv.to!string(this.formId) ~ ", data: " ~ std.conv.to!string(this.data) ~ ")";
    }

}

class ShowProfile : Bedrock201Packet
{

    enum uint ID = 104;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    enum string[] __fields = [];

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        ShowProfile ret = new ShowProfile();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "ShowProfile()";
    }

}

class SetDefaultGameType : Bedrock201Packet
{

    enum uint ID = 105;

    enum bool CLIENTBOUND = true;
    enum bool SERVERBOUND = false;

    // game type
    enum uint SURVIVAL = 0;
    enum uint CREATIVE = 1;
    enum uint ADVENTURE = 2;

    enum string[] __fields = ["gameType"];

    @Var uint gameType;

    this() pure nothrow @safe @nogc {}

    this(uint gameType) pure nothrow @safe @nogc
    {
        this.gameType = gameType;
    }

    mixin Make;

    public static typeof(this) fromBuffer(ubyte[] buffer)
    {
        SetDefaultGameType ret = new SetDefaultGameType();
        ret.decode(buffer);
        return ret;
    }

    override string toString()
    {
        return "SetDefaultGameType(gameType: " ~ std.conv.to!string(this.gameType) ~ ")";
    }

}