/*
 * This file was automatically generated by sel-utils and
 * released under the MIT License.
 * 
 * License: https://github.com/sel-project/sel-utils/blob/master/LICENSE
 * Repository: https://github.com/sel-project/sel-utils
 * Generated from https://github.com/sel-project/sel-utils/blob/master/xml/metadata/java210.xml
 */
module sul.metadata.java210;

import std.typecons : Tuple, tuple;

import sul.utils.buffer : Buffer;
import sul.utils.metadataflags;
import sul.utils.var;

static import sul.protocol.java210.types;

alias Changed(T) = Tuple!(T, "value", bool, "changed");

enum MetadataType : ubyte {

	BYTE = 0,
	INT = 1,
	FLOAT = 2,
	STRING = 3,
	CHAT = 4,
	SLOT = 5,
	BOOL = 6,
	ROTATION = 7,
	POSITION = 8,
	OPTIONAL_POSITION = 9,
	DIRECTION = 10,
	UUID = 11,
	BLOCK = 12,
}

class Metadata {

	public enum ENTITY_FLAGS : size_t {
		ON_FIRE = 0,
		SNEAKING = 1,
		SPRINTING = 3,
		INVISIBLE = 5,
		GLOWING = 6,
		GLIDING = 7,
	}
	public enum ubyte AIR = 1;
	public enum ubyte NAMETAG = 2;
	public enum ubyte SHOW_NAMETAG = 3;
	public enum ubyte SILENT = 4;
	public enum ubyte NO_GRAVITY = 5;
	public enum ubyte POTION = 6;
	public enum ubyte SPAWN_POSITION = 6;
	public enum ubyte RADIUS = 6;
	public enum ubyte COLOR = 7;
	public enum ubyte IS_SINGLE_POINT = 8;
	public enum ubyte PARTICLE_ID = 9;
	public enum ubyte PARTICLE_PARAMETER_1 = 10;
	public enum ubyte PARTICLE_PARAMETER_2 = 11;
	public enum ubyte HOOKED_ENTITY = 6;
	public enum ARROW_FLAGS : size_t {
		CRITICAL = 0,
	}
	public enum ubyte TIME_SINCE_LAST_HIT = 6;
	public enum ubyte FORWARD_DIRECTION = 7;
	public enum ubyte DAMAGE_TAKEN = 8;
	public enum ubyte BOAT_VARIANT = 9;
	public enum ubyte RIGHT_PADDLE_TURNING = 10;
	public enum ubyte LEFT_PADDLE_TURNING = 11;
	public enum ubyte BEAM_TARGET = 6;
	public enum ubyte SHOW_BOTTOM = 7;
	public enum ubyte FIREWORK = 6;
	public enum ubyte ITEM = 6;
	public enum ubyte ROTATION = 7;
	public enum LIVING_FLAGS : size_t {
		HAND_ACTIVE = 0,
		OFFHAND = 1,
	}
	public enum ubyte HEALTH = 7;
	public enum ubyte POTION_COLOR = 8;
	public enum ubyte POTION_AMBIENT = 9;
	public enum ubyte ARROWS = 10;
	public enum ubyte ADDITIONAL_HEARTS = 11;
	public enum ubyte SCORE = 12;
	public enum SKIN_PARTS : size_t {
		CAPE = 0,
		JACKET = 1,
		LEFT_SLEEVE = 2,
		RIGHT_SLEEVE = 3,
		LEFT_PANTS = 4,
		RIGHT_PANTS = 5,
		HAT = 6,
	}
	public enum ubyte MAIN_HAND = 14;
	public enum ARMOR_STAND_FLAGS : size_t {
		IS_SMALL = 0,
		HAS_ARMS = 2,
		NO_BASE_PLATE = 3,
		SET_MARKER = 4,
	}
	public enum ubyte HEAD_ROTATION = 12;
	public enum ubyte BODY_ROTATION = 13;
	public enum ubyte LEFT_ARM_ROTATION = 14;
	public enum ubyte RIGHT_ARM_ROTATION = 15;
	public enum ubyte LEFT_LEG_ROTATION = 16;
	public enum ubyte RIGHT_LEG_ROTATION = 17;
	public enum INSTENTIENT_FLAGS : size_t {
		NO_AI = 0,
		LEFT_HANDED = 1,
	}
	public enum ubyte HANGING = 12;
	public enum ubyte BABY = 12;
	public enum HORSE_FLAGS : size_t {
		HORSE_TAMED = 1,
		HORSE_SADDLED = 2,
		HORSE_CHESTED = 3,
		HORSE_EATING = 5,
		HORSE_REARING = 6,
		MOUTH_OPEN = 7,
	}
	public enum ubyte HORSE_TYPE = 14;
	public enum ubyte HORSE_VARIANT = 15;
	public enum ubyte OWNER_UUID = 16;
	public enum ubyte HORSE_ARMOR = 17;
	public enum ubyte PIG_SADDLED = 13;
	public enum ubyte RABBIT_VARIANT = 13;
	public enum ubyte STANDING_UP = 13;
	public enum SHEEP_FLAGS_AND_COLOR : size_t {
		SHEARED = 7,
	}
	public enum TAMEABLE_FLAGS : size_t {
		SITTING = 0,
		ANGRY = 1,
		TAMED = 2,
	}
	public enum ubyte OCELOT_VARIANT = 15;
	public enum ubyte WOLF_HEALTH = 15;
	public enum ubyte BEGGING = 16;
	public enum ubyte COLLAR_COLOR = 17;
	public enum ubyte PROFESSION = 13;
	public enum ubyte CREATED_BY_PLAYER = 12;
	public enum SNOWMAN_FLAGS : size_t {
		PUMPKINLESS = 4,
	}
	public enum ubyte SHULKER_DIRECTION = 12;
	public enum ubyte SHULKER_ATTACHMENT = 13;
	public enum ubyte SHULKER_SHIELD_HEIGHT = 14;
	public enum ubyte BLAZE_ON_FIRE = 12;
	public enum ubyte CREEPER_STATE = 12;
	public enum ubyte CHARGED = 13;
	public enum ubyte IGNITED = 14;
	public enum GUARDIAN_FLAGS : size_t {
		RETRACTING_SPIKES = 1,
		ELDER = 2,
	}
	public enum ubyte GUARDIAN_TARGET = 13;
	public enum ubyte SKELETON_TYPE = 12;
	public enum ubyte SWINGING_ARMS = 13;
	public enum ubyte CLIMBING = 12;
	public enum ubyte CENTER_HEAD_TARGET = 12;
	public enum ubyte LEFT_HEAD_TARGET = 13;
	public enum ubyte RIGHT_HEAD_TARGET = 14;
	public enum ubyte INVULNERABLE_TIME = 15;
	public enum ubyte ZOMBIE_TYPE = 13;
	public enum ubyte CONVERTING = 14;
	public enum ubyte HANDS_HELD_UP = 15;
	public enum ubyte CARRIED_BLOCK = 12;
	public enum ubyte SCREAMING = 13;
	public enum ubyte DRAGON_PHASE = 12;
	public enum ubyte GHAST_ATTACKING = 12;
	public enum ubyte SLIME_SIZE = 12;
	public enum ubyte SHAKING_POWER = 6;
	public enum ubyte SHAKING_DIRECTION = 7;
	public enum ubyte SHAKING_MULTIPLIER = 8;
	public enum ubyte MINECART_BLOCK = 9;
	public enum ubyte MINECART_BLOCK_POSITION = 10;
	public enum ubyte MINECART_CUSTOM_BLOCK = 11;
	public enum ubyte FURNACE_POWERED = 12;
	public enum ubyte COMMAND = 12;
	public enum ubyte LAST_OUTPUT = 13;
	public enum ubyte FUSE_TIME = 6;

	public DecodedMetadata[] decoded;

	private bool _cached = false;
	private ubyte[] _cache;

	private void delegate(Buffer) pure nothrow @safe[] _changed;

	private MetadataFlags!(byte) _entityFlags;
	private Changed!(uint) _air = tuple(cast(uint)300, false);
	private Changed!(string) _nametag;
	private Changed!(bool) _showNametag;
	private Changed!(bool) _silent;
	private Changed!(bool) _noGravity;
	private Changed!(sul.protocol.java210.types.Slot) _potion;
	private Changed!(ulong) _spawnPosition;
	private Changed!(float) _radius = tuple(cast(float)0.5, false);
	private Changed!(uint) _color;
	private Changed!(bool) _isSinglePoint;
	private Changed!(uint) _particleId;
	private Changed!(uint) _particleParameter1;
	private Changed!(uint) _particleParameter2;
	private Changed!(uint) _hookedEntity;
	private Changed!(MetadataFlags!(byte)) _arrowFlags;
	private Changed!(uint) _timeSinceLastHit;
	private Changed!(uint) _forwardDirection = tuple(cast(uint)1, false);
	private Changed!(float) _damageTaken = tuple(cast(float)0, false);
	private Changed!(uint) _boatVariant;
	private Changed!(bool) _rightPaddleTurning;
	private Changed!(bool) _leftPaddleTurning;
	private Changed!(sul.protocol.java210.types.OptionalPosition) _beamTarget;
	private Changed!(bool) _showBottom;
	private Changed!(sul.protocol.java210.types.Slot) _firework;
	private Changed!(sul.protocol.java210.types.Slot) _item;
	private Changed!(uint) _rotation;
	private Changed!(MetadataFlags!(byte)) _livingFlags;
	private Changed!(float) _health = tuple(cast(float)1, false);
	private Changed!(uint) _potionColor;
	private Changed!(bool) _potionAmbient;
	private Changed!(uint) _arrows;
	private Changed!(float) _additionalHearts = tuple(cast(float)0, false);
	private Changed!(uint) _score;
	private Changed!(MetadataFlags!(byte)) _skinParts = tuple(cast(MetadataFlags!(byte))0, false);
	private Changed!(byte) _mainHand = tuple(cast(byte)1, false);
	private Changed!(MetadataFlags!(byte)) _armorStandFlags;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _headRotation;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _bodyRotation;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _leftArmRotation;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _rightArmRotation;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _leftLegRotation;
	private Changed!(Tuple!(float, "x", float, "y", float, "z")) _rightLegRotation;
	private Changed!(MetadataFlags!(byte)) _instentientFlags;
	private Changed!(byte) _hanging;
	private Changed!(bool) _baby;
	private Changed!(MetadataFlags!(byte)) _horseFlags;
	private Changed!(uint) _horseType;
	private Changed!(uint) _horseVariant;
	private Changed!(sul.protocol.java210.types.OptionalUuid) _ownerUuid;
	private Changed!(uint) _horseArmor;
	private Changed!(bool) _pigSaddled;
	private Changed!(uint) _rabbitVariant;
	private Changed!(bool) _standingUp;
	private Changed!(MetadataFlags!(byte)) _sheepFlagsAndColor;
	private Changed!(MetadataFlags!(byte)) _tameableFlags;
	private Changed!(uint) _ocelotVariant;
	private Changed!(float) _wolfHealth;
	private Changed!(bool) _begging;
	private Changed!(uint) _collarColor = tuple(cast(uint)14, false);
	private Changed!(uint) _profession;
	private Changed!(byte) _createdByPlayer;
	private Changed!(MetadataFlags!(byte)) _snowmanFlags;
	private Changed!(uint) _shulkerDirection;
	private Changed!(sul.protocol.java210.types.OptionalPosition) _shulkerAttachment;
	private Changed!(byte) _shulkerShieldHeight;
	private Changed!(byte) _blazeOnFire;
	private Changed!(uint) _creeperState = tuple(cast(uint)-1, false);
	private Changed!(bool) _charged;
	private Changed!(bool) _ignited;
	private Changed!(MetadataFlags!(byte)) _guardianFlags;
	private Changed!(uint) _guardianTarget;
	private Changed!(uint) _skeletonType;
	private Changed!(bool) _swingingArms;
	private Changed!(byte) _climbing;
	private Changed!(uint) _centerHeadTarget;
	private Changed!(uint) _leftHeadTarget;
	private Changed!(uint) _rightHeadTarget;
	private Changed!(uint) _invulnerableTime;
	private Changed!(uint) _zombieType;
	private Changed!(bool) _converting;
	private Changed!(bool) _handsHeldUp;
	private Changed!(uint) _carriedBlock;
	private Changed!(bool) _screaming;
	private Changed!(uint) _dragonPhase;
	private Changed!(bool) _ghastAttacking;
	private Changed!(uint) _slimeSize = tuple(cast(uint)1, false);
	private Changed!(uint) _shakingPower;
	private Changed!(uint) _shakingDirection;
	private Changed!(float) _shakingMultiplier = tuple(cast(float)0, false);
	private Changed!(uint) _minecartBlock;
	private Changed!(uint) _minecartBlockPosition = tuple(cast(uint)6, false);
	private Changed!(bool) _minecartCustomBlock;
	private Changed!(bool) _furnacePowered;
	private Changed!(string) _command;
	private Changed!(string) _lastOutput;
	private Changed!(uint) _fuseTime;

	public pure nothrow @safe this() {
		this.reset();
	}

	public pure nothrow @safe void reset() {
		this._changed = [
			&this.encodeEntityFlags,
		];
	}

	public pure nothrow @property @safe @nogc byte entityFlags() {
		return _entityFlags;
	}

	public pure nothrow @property @safe byte entityFlags(byte value) {
		this._cached = false;
		this._entityFlags = value;
		return value;
	}

	public pure nothrow @safe encodeEntityFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(0);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._entityFlags);
		}
	}

	public pure nothrow @property @safe bool onFire() {
		return _entityFlags._0;
	}

	public pure nothrow @property @safe bool onFire(bool value) {
		_entityFlags._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool sneaking() {
		return _entityFlags._1;
	}

	public pure nothrow @property @safe bool sneaking(bool value) {
		_entityFlags._1 = value;
		return value;
	}

	public pure nothrow @property @safe bool sprinting() {
		return _entityFlags._3;
	}

	public pure nothrow @property @safe bool sprinting(bool value) {
		_entityFlags._3 = value;
		return value;
	}

	public pure nothrow @property @safe bool invisible() {
		return _entityFlags._5;
	}

	public pure nothrow @property @safe bool invisible(bool value) {
		_entityFlags._5 = value;
		return value;
	}

	public pure nothrow @property @safe bool glowing() {
		return _entityFlags._6;
	}

	public pure nothrow @property @safe bool glowing(bool value) {
		_entityFlags._6 = value;
		return value;
	}

	public pure nothrow @property @safe bool gliding() {
		return _entityFlags._7;
	}

	public pure nothrow @property @safe bool gliding(bool value) {
		_entityFlags._7 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint air() {
		return _air.value;
	}

	public pure nothrow @property @safe uint air(uint value) {
		this._cached = false;
		this._air.value = value;
		if(!this._air.changed) {
			this._air.changed = true;
			this._changed ~= &this.encodeAir;
		}
		return value;
	}

	public pure nothrow @safe encodeAir(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(1);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._air.value));
		}
	}

	public pure nothrow @property @safe @nogc string nametag() {
		return _nametag.value;
	}

	public pure nothrow @property @safe string nametag(string value) {
		this._cached = false;
		this._nametag.value = value;
		if(!this._nametag.changed) {
			this._nametag.changed = true;
			this._changed ~= &this.encodeNametag;
		}
		return value;
	}

	public pure nothrow @safe encodeNametag(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(2);
			writeBigEndianUbyte(3);
			writeBytes(varuint.encode(cast(uint)this._nametag.value.length)); writeString(this._nametag.value);
		}
	}

	public pure nothrow @property @safe @nogc bool showNametag() {
		return _showNametag.value;
	}

	public pure nothrow @property @safe bool showNametag(bool value) {
		this._cached = false;
		this._showNametag.value = value;
		if(!this._showNametag.changed) {
			this._showNametag.changed = true;
			this._changed ~= &this.encodeShowNametag;
		}
		return value;
	}

	public pure nothrow @safe encodeShowNametag(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(3);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._showNametag.value);
		}
	}

	public pure nothrow @property @safe @nogc bool silent() {
		return _silent.value;
	}

	public pure nothrow @property @safe bool silent(bool value) {
		this._cached = false;
		this._silent.value = value;
		if(!this._silent.changed) {
			this._silent.changed = true;
			this._changed ~= &this.encodeSilent;
		}
		return value;
	}

	public pure nothrow @safe encodeSilent(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(4);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._silent.value);
		}
	}

	public pure nothrow @property @safe @nogc bool noGravity() {
		return _noGravity.value;
	}

	public pure nothrow @property @safe bool noGravity(bool value) {
		this._cached = false;
		this._noGravity.value = value;
		if(!this._noGravity.changed) {
			this._noGravity.changed = true;
			this._changed ~= &this.encodeNoGravity;
		}
		return value;
	}

	public pure nothrow @safe encodeNoGravity(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(5);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._noGravity.value);
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.Slot potion() {
		return _potion.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.Slot potion(sul.protocol.java210.types.Slot value) {
		this._cached = false;
		this._potion.value = value;
		if(!this._potion.changed) {
			this._potion.changed = true;
			this._changed ~= &this.encodePotion;
		}
		return value;
	}

	public pure nothrow @safe encodePotion(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(5);
			this._potion.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc ulong spawnPosition() {
		return _spawnPosition.value;
	}

	public pure nothrow @property @safe ulong spawnPosition(ulong value) {
		this._cached = false;
		this._spawnPosition.value = value;
		if(!this._spawnPosition.changed) {
			this._spawnPosition.changed = true;
			this._changed ~= &this.encodeSpawnPosition;
		}
		return value;
	}

	public pure nothrow @safe encodeSpawnPosition(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(8);
			writeBigEndianUlong(this._spawnPosition.value);
		}
	}

	public pure nothrow @property @safe @nogc float radius() {
		return _radius.value;
	}

	public pure nothrow @property @safe float radius(float value) {
		this._cached = false;
		this._radius.value = value;
		if(!this._radius.changed) {
			this._radius.changed = true;
			this._changed ~= &this.encodeRadius;
		}
		return value;
	}

	public pure nothrow @safe encodeRadius(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._radius.value);
		}
	}

	public pure nothrow @property @safe @nogc uint color() {
		return _color.value;
	}

	public pure nothrow @property @safe uint color(uint value) {
		this._cached = false;
		this._color.value = value;
		if(!this._color.changed) {
			this._color.changed = true;
			this._changed ~= &this.encodeColor;
		}
		return value;
	}

	public pure nothrow @safe encodeColor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._color.value));
		}
	}

	public pure nothrow @property @safe @nogc bool isSinglePoint() {
		return _isSinglePoint.value;
	}

	public pure nothrow @property @safe bool isSinglePoint(bool value) {
		this._cached = false;
		this._isSinglePoint.value = value;
		if(!this._isSinglePoint.changed) {
			this._isSinglePoint.changed = true;
			this._changed ~= &this.encodeIsSinglePoint;
		}
		return value;
	}

	public pure nothrow @safe encodeIsSinglePoint(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(8);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._isSinglePoint.value);
		}
	}

	public pure nothrow @property @safe @nogc uint particleId() {
		return _particleId.value;
	}

	public pure nothrow @property @safe uint particleId(uint value) {
		this._cached = false;
		this._particleId.value = value;
		if(!this._particleId.changed) {
			this._particleId.changed = true;
			this._changed ~= &this.encodeParticleId;
		}
		return value;
	}

	public pure nothrow @safe encodeParticleId(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(9);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._particleId.value));
		}
	}

	public pure nothrow @property @safe @nogc uint particleParameter1() {
		return _particleParameter1.value;
	}

	public pure nothrow @property @safe uint particleParameter1(uint value) {
		this._cached = false;
		this._particleParameter1.value = value;
		if(!this._particleParameter1.changed) {
			this._particleParameter1.changed = true;
			this._changed ~= &this.encodeParticleParameter1;
		}
		return value;
	}

	public pure nothrow @safe encodeParticleParameter1(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(10);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._particleParameter1.value));
		}
	}

	public pure nothrow @property @safe @nogc uint particleParameter2() {
		return _particleParameter2.value;
	}

	public pure nothrow @property @safe uint particleParameter2(uint value) {
		this._cached = false;
		this._particleParameter2.value = value;
		if(!this._particleParameter2.changed) {
			this._particleParameter2.changed = true;
			this._changed ~= &this.encodeParticleParameter2;
		}
		return value;
	}

	public pure nothrow @safe encodeParticleParameter2(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._particleParameter2.value));
		}
	}

	public pure nothrow @property @safe @nogc uint hookedEntity() {
		return _hookedEntity.value;
	}

	public pure nothrow @property @safe uint hookedEntity(uint value) {
		this._cached = false;
		this._hookedEntity.value = value;
		if(!this._hookedEntity.changed) {
			this._hookedEntity.changed = true;
			this._changed ~= &this.encodeHookedEntity;
		}
		return value;
	}

	public pure nothrow @safe encodeHookedEntity(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._hookedEntity.value));
		}
	}

	public pure nothrow @property @safe @nogc byte arrowFlags() {
		return _arrowFlags.value;
	}

	public pure nothrow @property @safe byte arrowFlags(byte value) {
		this._cached = false;
		this._arrowFlags.value = value;
		if(!this._arrowFlags.changed) {
			this._arrowFlags.changed = true;
			this._changed ~= &this.encodeArrowFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeArrowFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._arrowFlags.value);
		}
	}

	public pure nothrow @property @safe bool critical() {
		return _arrowFlags.value._0;
	}

	public pure nothrow @property @safe bool critical(bool value) {
		_arrowFlags.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint timeSinceLastHit() {
		return _timeSinceLastHit.value;
	}

	public pure nothrow @property @safe uint timeSinceLastHit(uint value) {
		this._cached = false;
		this._timeSinceLastHit.value = value;
		if(!this._timeSinceLastHit.changed) {
			this._timeSinceLastHit.changed = true;
			this._changed ~= &this.encodeTimeSinceLastHit;
		}
		return value;
	}

	public pure nothrow @safe encodeTimeSinceLastHit(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._timeSinceLastHit.value));
		}
	}

	public pure nothrow @property @safe @nogc uint forwardDirection() {
		return _forwardDirection.value;
	}

	public pure nothrow @property @safe uint forwardDirection(uint value) {
		this._cached = false;
		this._forwardDirection.value = value;
		if(!this._forwardDirection.changed) {
			this._forwardDirection.changed = true;
			this._changed ~= &this.encodeForwardDirection;
		}
		return value;
	}

	public pure nothrow @safe encodeForwardDirection(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._forwardDirection.value));
		}
	}

	public pure nothrow @property @safe @nogc float damageTaken() {
		return _damageTaken.value;
	}

	public pure nothrow @property @safe float damageTaken(float value) {
		this._cached = false;
		this._damageTaken.value = value;
		if(!this._damageTaken.changed) {
			this._damageTaken.changed = true;
			this._changed ~= &this.encodeDamageTaken;
		}
		return value;
	}

	public pure nothrow @safe encodeDamageTaken(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(8);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._damageTaken.value);
		}
	}

	public pure nothrow @property @safe @nogc uint boatVariant() {
		return _boatVariant.value;
	}

	public pure nothrow @property @safe uint boatVariant(uint value) {
		this._cached = false;
		this._boatVariant.value = value;
		if(!this._boatVariant.changed) {
			this._boatVariant.changed = true;
			this._changed ~= &this.encodeBoatVariant;
		}
		return value;
	}

	public pure nothrow @safe encodeBoatVariant(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(9);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._boatVariant.value));
		}
	}

	public pure nothrow @property @safe @nogc bool rightPaddleTurning() {
		return _rightPaddleTurning.value;
	}

	public pure nothrow @property @safe bool rightPaddleTurning(bool value) {
		this._cached = false;
		this._rightPaddleTurning.value = value;
		if(!this._rightPaddleTurning.changed) {
			this._rightPaddleTurning.changed = true;
			this._changed ~= &this.encodeRightPaddleTurning;
		}
		return value;
	}

	public pure nothrow @safe encodeRightPaddleTurning(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(10);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._rightPaddleTurning.value);
		}
	}

	public pure nothrow @property @safe @nogc bool leftPaddleTurning() {
		return _leftPaddleTurning.value;
	}

	public pure nothrow @property @safe bool leftPaddleTurning(bool value) {
		this._cached = false;
		this._leftPaddleTurning.value = value;
		if(!this._leftPaddleTurning.changed) {
			this._leftPaddleTurning.changed = true;
			this._changed ~= &this.encodeLeftPaddleTurning;
		}
		return value;
	}

	public pure nothrow @safe encodeLeftPaddleTurning(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._leftPaddleTurning.value);
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.OptionalPosition beamTarget() {
		return _beamTarget.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.OptionalPosition beamTarget(sul.protocol.java210.types.OptionalPosition value) {
		this._cached = false;
		this._beamTarget.value = value;
		if(!this._beamTarget.changed) {
			this._beamTarget.changed = true;
			this._changed ~= &this.encodeBeamTarget;
		}
		return value;
	}

	public pure nothrow @safe encodeBeamTarget(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(9);
			this._beamTarget.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc bool showBottom() {
		return _showBottom.value;
	}

	public pure nothrow @property @safe bool showBottom(bool value) {
		this._cached = false;
		this._showBottom.value = value;
		if(!this._showBottom.changed) {
			this._showBottom.changed = true;
			this._changed ~= &this.encodeShowBottom;
		}
		return value;
	}

	public pure nothrow @safe encodeShowBottom(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._showBottom.value);
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.Slot firework() {
		return _firework.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.Slot firework(sul.protocol.java210.types.Slot value) {
		this._cached = false;
		this._firework.value = value;
		if(!this._firework.changed) {
			this._firework.changed = true;
			this._changed ~= &this.encodeFirework;
		}
		return value;
	}

	public pure nothrow @safe encodeFirework(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(5);
			this._firework.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.Slot item() {
		return _item.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.Slot item(sul.protocol.java210.types.Slot value) {
		this._cached = false;
		this._item.value = value;
		if(!this._item.changed) {
			this._item.changed = true;
			this._changed ~= &this.encodeItem;
		}
		return value;
	}

	public pure nothrow @safe encodeItem(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(5);
			this._item.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc uint rotation() {
		return _rotation.value;
	}

	public pure nothrow @property @safe uint rotation(uint value) {
		this._cached = false;
		this._rotation.value = value;
		if(!this._rotation.changed) {
			this._rotation.changed = true;
			this._changed ~= &this.encodeRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._rotation.value));
		}
	}

	public pure nothrow @property @safe @nogc byte livingFlags() {
		return _livingFlags.value;
	}

	public pure nothrow @property @safe byte livingFlags(byte value) {
		this._cached = false;
		this._livingFlags.value = value;
		if(!this._livingFlags.changed) {
			this._livingFlags.changed = true;
			this._changed ~= &this.encodeLivingFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeLivingFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._livingFlags.value);
		}
	}

	public pure nothrow @property @safe bool handActive() {
		return _livingFlags.value._0;
	}

	public pure nothrow @property @safe bool handActive(bool value) {
		_livingFlags.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool offhand() {
		return _livingFlags.value._1;
	}

	public pure nothrow @property @safe bool offhand(bool value) {
		_livingFlags.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc float health() {
		return _health.value;
	}

	public pure nothrow @property @safe float health(float value) {
		this._cached = false;
		this._health.value = value;
		if(!this._health.changed) {
			this._health.changed = true;
			this._changed ~= &this.encodeHealth;
		}
		return value;
	}

	public pure nothrow @safe encodeHealth(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._health.value);
		}
	}

	public pure nothrow @property @safe @nogc uint potionColor() {
		return _potionColor.value;
	}

	public pure nothrow @property @safe uint potionColor(uint value) {
		this._cached = false;
		this._potionColor.value = value;
		if(!this._potionColor.changed) {
			this._potionColor.changed = true;
			this._changed ~= &this.encodePotionColor;
		}
		return value;
	}

	public pure nothrow @safe encodePotionColor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(8);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._potionColor.value));
		}
	}

	public pure nothrow @property @safe @nogc bool potionAmbient() {
		return _potionAmbient.value;
	}

	public pure nothrow @property @safe bool potionAmbient(bool value) {
		this._cached = false;
		this._potionAmbient.value = value;
		if(!this._potionAmbient.changed) {
			this._potionAmbient.changed = true;
			this._changed ~= &this.encodePotionAmbient;
		}
		return value;
	}

	public pure nothrow @safe encodePotionAmbient(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(9);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._potionAmbient.value);
		}
	}

	public pure nothrow @property @safe @nogc uint arrows() {
		return _arrows.value;
	}

	public pure nothrow @property @safe uint arrows(uint value) {
		this._cached = false;
		this._arrows.value = value;
		if(!this._arrows.changed) {
			this._arrows.changed = true;
			this._changed ~= &this.encodeArrows;
		}
		return value;
	}

	public pure nothrow @safe encodeArrows(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(10);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._arrows.value));
		}
	}

	public pure nothrow @property @safe @nogc float additionalHearts() {
		return _additionalHearts.value;
	}

	public pure nothrow @property @safe float additionalHearts(float value) {
		this._cached = false;
		this._additionalHearts.value = value;
		if(!this._additionalHearts.changed) {
			this._additionalHearts.changed = true;
			this._changed ~= &this.encodeAdditionalHearts;
		}
		return value;
	}

	public pure nothrow @safe encodeAdditionalHearts(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._additionalHearts.value);
		}
	}

	public pure nothrow @property @safe @nogc uint score() {
		return _score.value;
	}

	public pure nothrow @property @safe uint score(uint value) {
		this._cached = false;
		this._score.value = value;
		if(!this._score.changed) {
			this._score.changed = true;
			this._changed ~= &this.encodeScore;
		}
		return value;
	}

	public pure nothrow @safe encodeScore(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._score.value));
		}
	}

	public pure nothrow @property @safe @nogc byte skinParts() {
		return _skinParts.value;
	}

	public pure nothrow @property @safe byte skinParts(byte value) {
		this._cached = false;
		this._skinParts.value = value;
		if(!this._skinParts.changed) {
			this._skinParts.changed = true;
			this._changed ~= &this.encodeSkinParts;
		}
		return value;
	}

	public pure nothrow @safe encodeSkinParts(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._skinParts.value);
		}
	}

	public pure nothrow @property @safe bool cape() {
		return _skinParts.value._0;
	}

	public pure nothrow @property @safe bool cape(bool value) {
		_skinParts.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool jacket() {
		return _skinParts.value._1;
	}

	public pure nothrow @property @safe bool jacket(bool value) {
		_skinParts.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe bool leftSleeve() {
		return _skinParts.value._2;
	}

	public pure nothrow @property @safe bool leftSleeve(bool value) {
		_skinParts.value._2 = value;
		return value;
	}

	public pure nothrow @property @safe bool rightSleeve() {
		return _skinParts.value._3;
	}

	public pure nothrow @property @safe bool rightSleeve(bool value) {
		_skinParts.value._3 = value;
		return value;
	}

	public pure nothrow @property @safe bool leftPants() {
		return _skinParts.value._4;
	}

	public pure nothrow @property @safe bool leftPants(bool value) {
		_skinParts.value._4 = value;
		return value;
	}

	public pure nothrow @property @safe bool rightPants() {
		return _skinParts.value._5;
	}

	public pure nothrow @property @safe bool rightPants(bool value) {
		_skinParts.value._5 = value;
		return value;
	}

	public pure nothrow @property @safe bool hat() {
		return _skinParts.value._6;
	}

	public pure nothrow @property @safe bool hat(bool value) {
		_skinParts.value._6 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc byte mainHand() {
		return _mainHand.value;
	}

	public pure nothrow @property @safe byte mainHand(byte value) {
		this._cached = false;
		this._mainHand.value = value;
		if(!this._mainHand.changed) {
			this._mainHand.changed = true;
			this._changed ~= &this.encodeMainHand;
		}
		return value;
	}

	public pure nothrow @safe encodeMainHand(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._mainHand.value);
		}
	}

	public pure nothrow @property @safe @nogc byte armorStandFlags() {
		return _armorStandFlags.value;
	}

	public pure nothrow @property @safe byte armorStandFlags(byte value) {
		this._cached = false;
		this._armorStandFlags.value = value;
		if(!this._armorStandFlags.changed) {
			this._armorStandFlags.changed = true;
			this._changed ~= &this.encodeArmorStandFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeArmorStandFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._armorStandFlags.value);
		}
	}

	public pure nothrow @property @safe bool isSmall() {
		return _armorStandFlags.value._0;
	}

	public pure nothrow @property @safe bool isSmall(bool value) {
		_armorStandFlags.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool hasArms() {
		return _armorStandFlags.value._2;
	}

	public pure nothrow @property @safe bool hasArms(bool value) {
		_armorStandFlags.value._2 = value;
		return value;
	}

	public pure nothrow @property @safe bool noBasePlate() {
		return _armorStandFlags.value._3;
	}

	public pure nothrow @property @safe bool noBasePlate(bool value) {
		_armorStandFlags.value._3 = value;
		return value;
	}

	public pure nothrow @property @safe bool setMarker() {
		return _armorStandFlags.value._4;
	}

	public pure nothrow @property @safe bool setMarker(bool value) {
		_armorStandFlags.value._4 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") headRotation() {
		return _headRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") headRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._headRotation.value = value;
		if(!this._headRotation.changed) {
			this._headRotation.changed = true;
			this._changed ~= &this.encodeHeadRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeHeadRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._headRotation.value.x); writeBigEndianFloat(this._headRotation.value.y); writeBigEndianFloat(this._headRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") bodyRotation() {
		return _bodyRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") bodyRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._bodyRotation.value = value;
		if(!this._bodyRotation.changed) {
			this._bodyRotation.changed = true;
			this._changed ~= &this.encodeBodyRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeBodyRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._bodyRotation.value.x); writeBigEndianFloat(this._bodyRotation.value.y); writeBigEndianFloat(this._bodyRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") leftArmRotation() {
		return _leftArmRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") leftArmRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._leftArmRotation.value = value;
		if(!this._leftArmRotation.changed) {
			this._leftArmRotation.changed = true;
			this._changed ~= &this.encodeLeftArmRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeLeftArmRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._leftArmRotation.value.x); writeBigEndianFloat(this._leftArmRotation.value.y); writeBigEndianFloat(this._leftArmRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") rightArmRotation() {
		return _rightArmRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") rightArmRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._rightArmRotation.value = value;
		if(!this._rightArmRotation.changed) {
			this._rightArmRotation.changed = true;
			this._changed ~= &this.encodeRightArmRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeRightArmRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._rightArmRotation.value.x); writeBigEndianFloat(this._rightArmRotation.value.y); writeBigEndianFloat(this._rightArmRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") leftLegRotation() {
		return _leftLegRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") leftLegRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._leftLegRotation.value = value;
		if(!this._leftLegRotation.changed) {
			this._leftLegRotation.changed = true;
			this._changed ~= &this.encodeLeftLegRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeLeftLegRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(16);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._leftLegRotation.value.x); writeBigEndianFloat(this._leftLegRotation.value.y); writeBigEndianFloat(this._leftLegRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc Tuple!(float, "x", float, "y", float, "z") rightLegRotation() {
		return _rightLegRotation.value;
	}

	public pure nothrow @property @safe Tuple!(float, "x", float, "y", float, "z") rightLegRotation(Tuple!(float, "x", float, "y", float, "z") value) {
		this._cached = false;
		this._rightLegRotation.value = value;
		if(!this._rightLegRotation.changed) {
			this._rightLegRotation.changed = true;
			this._changed ~= &this.encodeRightLegRotation;
		}
		return value;
	}

	public pure nothrow @safe encodeRightLegRotation(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(17);
			writeBigEndianUbyte(7);
			writeBigEndianFloat(this._rightLegRotation.value.x); writeBigEndianFloat(this._rightLegRotation.value.y); writeBigEndianFloat(this._rightLegRotation.value.z);
		}
	}

	public pure nothrow @property @safe @nogc byte instentientFlags() {
		return _instentientFlags.value;
	}

	public pure nothrow @property @safe byte instentientFlags(byte value) {
		this._cached = false;
		this._instentientFlags.value = value;
		if(!this._instentientFlags.changed) {
			this._instentientFlags.changed = true;
			this._changed ~= &this.encodeInstentientFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeInstentientFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._instentientFlags.value);
		}
	}

	public pure nothrow @property @safe bool noAi() {
		return _instentientFlags.value._0;
	}

	public pure nothrow @property @safe bool noAi(bool value) {
		_instentientFlags.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool leftHanded() {
		return _instentientFlags.value._1;
	}

	public pure nothrow @property @safe bool leftHanded(bool value) {
		_instentientFlags.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc byte hanging() {
		return _hanging.value;
	}

	public pure nothrow @property @safe byte hanging(byte value) {
		this._cached = false;
		this._hanging.value = value;
		if(!this._hanging.changed) {
			this._hanging.changed = true;
			this._changed ~= &this.encodeHanging;
		}
		return value;
	}

	public pure nothrow @safe encodeHanging(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._hanging.value);
		}
	}

	public pure nothrow @property @safe @nogc bool baby() {
		return _baby.value;
	}

	public pure nothrow @property @safe bool baby(bool value) {
		this._cached = false;
		this._baby.value = value;
		if(!this._baby.changed) {
			this._baby.changed = true;
			this._changed ~= &this.encodeBaby;
		}
		return value;
	}

	public pure nothrow @safe encodeBaby(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._baby.value);
		}
	}

	public pure nothrow @property @safe @nogc byte horseFlags() {
		return _horseFlags.value;
	}

	public pure nothrow @property @safe byte horseFlags(byte value) {
		this._cached = false;
		this._horseFlags.value = value;
		if(!this._horseFlags.changed) {
			this._horseFlags.changed = true;
			this._changed ~= &this.encodeHorseFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeHorseFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._horseFlags.value);
		}
	}

	public pure nothrow @property @safe bool horseTamed() {
		return _horseFlags.value._1;
	}

	public pure nothrow @property @safe bool horseTamed(bool value) {
		_horseFlags.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe bool horseSaddled() {
		return _horseFlags.value._2;
	}

	public pure nothrow @property @safe bool horseSaddled(bool value) {
		_horseFlags.value._2 = value;
		return value;
	}

	public pure nothrow @property @safe bool horseChested() {
		return _horseFlags.value._3;
	}

	public pure nothrow @property @safe bool horseChested(bool value) {
		_horseFlags.value._3 = value;
		return value;
	}

	public pure nothrow @property @safe bool horseEating() {
		return _horseFlags.value._5;
	}

	public pure nothrow @property @safe bool horseEating(bool value) {
		_horseFlags.value._5 = value;
		return value;
	}

	public pure nothrow @property @safe bool horseRearing() {
		return _horseFlags.value._6;
	}

	public pure nothrow @property @safe bool horseRearing(bool value) {
		_horseFlags.value._6 = value;
		return value;
	}

	public pure nothrow @property @safe bool mouthOpen() {
		return _horseFlags.value._7;
	}

	public pure nothrow @property @safe bool mouthOpen(bool value) {
		_horseFlags.value._7 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint horseType() {
		return _horseType.value;
	}

	public pure nothrow @property @safe uint horseType(uint value) {
		this._cached = false;
		this._horseType.value = value;
		if(!this._horseType.changed) {
			this._horseType.changed = true;
			this._changed ~= &this.encodeHorseType;
		}
		return value;
	}

	public pure nothrow @safe encodeHorseType(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._horseType.value));
		}
	}

	public pure nothrow @property @safe @nogc uint horseVariant() {
		return _horseVariant.value;
	}

	public pure nothrow @property @safe uint horseVariant(uint value) {
		this._cached = false;
		this._horseVariant.value = value;
		if(!this._horseVariant.changed) {
			this._horseVariant.changed = true;
			this._changed ~= &this.encodeHorseVariant;
		}
		return value;
	}

	public pure nothrow @safe encodeHorseVariant(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._horseVariant.value));
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.OptionalUuid ownerUuid() {
		return _ownerUuid.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.OptionalUuid ownerUuid(sul.protocol.java210.types.OptionalUuid value) {
		this._cached = false;
		this._ownerUuid.value = value;
		if(!this._ownerUuid.changed) {
			this._ownerUuid.changed = true;
			this._changed ~= &this.encodeOwnerUuid;
		}
		return value;
	}

	public pure nothrow @safe encodeOwnerUuid(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(16);
			writeBigEndianUbyte(11);
			this._ownerUuid.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc uint horseArmor() {
		return _horseArmor.value;
	}

	public pure nothrow @property @safe uint horseArmor(uint value) {
		this._cached = false;
		this._horseArmor.value = value;
		if(!this._horseArmor.changed) {
			this._horseArmor.changed = true;
			this._changed ~= &this.encodeHorseArmor;
		}
		return value;
	}

	public pure nothrow @safe encodeHorseArmor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(17);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._horseArmor.value));
		}
	}

	public pure nothrow @property @safe @nogc bool pigSaddled() {
		return _pigSaddled.value;
	}

	public pure nothrow @property @safe bool pigSaddled(bool value) {
		this._cached = false;
		this._pigSaddled.value = value;
		if(!this._pigSaddled.changed) {
			this._pigSaddled.changed = true;
			this._changed ~= &this.encodePigSaddled;
		}
		return value;
	}

	public pure nothrow @safe encodePigSaddled(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._pigSaddled.value);
		}
	}

	public pure nothrow @property @safe @nogc uint rabbitVariant() {
		return _rabbitVariant.value;
	}

	public pure nothrow @property @safe uint rabbitVariant(uint value) {
		this._cached = false;
		this._rabbitVariant.value = value;
		if(!this._rabbitVariant.changed) {
			this._rabbitVariant.changed = true;
			this._changed ~= &this.encodeRabbitVariant;
		}
		return value;
	}

	public pure nothrow @safe encodeRabbitVariant(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._rabbitVariant.value));
		}
	}

	public pure nothrow @property @safe @nogc bool standingUp() {
		return _standingUp.value;
	}

	public pure nothrow @property @safe bool standingUp(bool value) {
		this._cached = false;
		this._standingUp.value = value;
		if(!this._standingUp.changed) {
			this._standingUp.changed = true;
			this._changed ~= &this.encodeStandingUp;
		}
		return value;
	}

	public pure nothrow @safe encodeStandingUp(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._standingUp.value);
		}
	}

	public pure nothrow @property @safe @nogc byte sheepFlagsAndColor() {
		return _sheepFlagsAndColor.value;
	}

	public pure nothrow @property @safe byte sheepFlagsAndColor(byte value) {
		this._cached = false;
		this._sheepFlagsAndColor.value = value;
		if(!this._sheepFlagsAndColor.changed) {
			this._sheepFlagsAndColor.changed = true;
			this._changed ~= &this.encodeSheepFlagsAndColor;
		}
		return value;
	}

	public pure nothrow @safe encodeSheepFlagsAndColor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._sheepFlagsAndColor.value);
		}
	}

	public pure nothrow @property @safe bool sheared() {
		return _sheepFlagsAndColor.value._7;
	}

	public pure nothrow @property @safe bool sheared(bool value) {
		_sheepFlagsAndColor.value._7 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc byte tameableFlags() {
		return _tameableFlags.value;
	}

	public pure nothrow @property @safe byte tameableFlags(byte value) {
		this._cached = false;
		this._tameableFlags.value = value;
		if(!this._tameableFlags.changed) {
			this._tameableFlags.changed = true;
			this._changed ~= &this.encodeTameableFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeTameableFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._tameableFlags.value);
		}
	}

	public pure nothrow @property @safe bool sitting() {
		return _tameableFlags.value._0;
	}

	public pure nothrow @property @safe bool sitting(bool value) {
		_tameableFlags.value._0 = value;
		return value;
	}

	public pure nothrow @property @safe bool angry() {
		return _tameableFlags.value._1;
	}

	public pure nothrow @property @safe bool angry(bool value) {
		_tameableFlags.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe bool tamed() {
		return _tameableFlags.value._2;
	}

	public pure nothrow @property @safe bool tamed(bool value) {
		_tameableFlags.value._2 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint ocelotVariant() {
		return _ocelotVariant.value;
	}

	public pure nothrow @property @safe uint ocelotVariant(uint value) {
		this._cached = false;
		this._ocelotVariant.value = value;
		if(!this._ocelotVariant.changed) {
			this._ocelotVariant.changed = true;
			this._changed ~= &this.encodeOcelotVariant;
		}
		return value;
	}

	public pure nothrow @safe encodeOcelotVariant(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._ocelotVariant.value));
		}
	}

	public pure nothrow @property @safe @nogc float wolfHealth() {
		return _wolfHealth.value;
	}

	public pure nothrow @property @safe float wolfHealth(float value) {
		this._cached = false;
		this._wolfHealth.value = value;
		if(!this._wolfHealth.changed) {
			this._wolfHealth.changed = true;
			this._changed ~= &this.encodeWolfHealth;
		}
		return value;
	}

	public pure nothrow @safe encodeWolfHealth(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._wolfHealth.value);
		}
	}

	public pure nothrow @property @safe @nogc bool begging() {
		return _begging.value;
	}

	public pure nothrow @property @safe bool begging(bool value) {
		this._cached = false;
		this._begging.value = value;
		if(!this._begging.changed) {
			this._begging.changed = true;
			this._changed ~= &this.encodeBegging;
		}
		return value;
	}

	public pure nothrow @safe encodeBegging(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(16);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._begging.value);
		}
	}

	public pure nothrow @property @safe @nogc uint collarColor() {
		return _collarColor.value;
	}

	public pure nothrow @property @safe uint collarColor(uint value) {
		this._cached = false;
		this._collarColor.value = value;
		if(!this._collarColor.changed) {
			this._collarColor.changed = true;
			this._changed ~= &this.encodeCollarColor;
		}
		return value;
	}

	public pure nothrow @safe encodeCollarColor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(17);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._collarColor.value));
		}
	}

	public pure nothrow @property @safe @nogc uint profession() {
		return _profession.value;
	}

	public pure nothrow @property @safe uint profession(uint value) {
		this._cached = false;
		this._profession.value = value;
		if(!this._profession.changed) {
			this._profession.changed = true;
			this._changed ~= &this.encodeProfession;
		}
		return value;
	}

	public pure nothrow @safe encodeProfession(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._profession.value));
		}
	}

	public pure nothrow @property @safe @nogc byte createdByPlayer() {
		return _createdByPlayer.value;
	}

	public pure nothrow @property @safe byte createdByPlayer(byte value) {
		this._cached = false;
		this._createdByPlayer.value = value;
		if(!this._createdByPlayer.changed) {
			this._createdByPlayer.changed = true;
			this._changed ~= &this.encodeCreatedByPlayer;
		}
		return value;
	}

	public pure nothrow @safe encodeCreatedByPlayer(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._createdByPlayer.value);
		}
	}

	public pure nothrow @property @safe @nogc byte snowmanFlags() {
		return _snowmanFlags.value;
	}

	public pure nothrow @property @safe byte snowmanFlags(byte value) {
		this._cached = false;
		this._snowmanFlags.value = value;
		if(!this._snowmanFlags.changed) {
			this._snowmanFlags.changed = true;
			this._changed ~= &this.encodeSnowmanFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeSnowmanFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._snowmanFlags.value);
		}
	}

	public pure nothrow @property @safe bool pumpkinless() {
		return _snowmanFlags.value._4;
	}

	public pure nothrow @property @safe bool pumpkinless(bool value) {
		_snowmanFlags.value._4 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint shulkerDirection() {
		return _shulkerDirection.value;
	}

	public pure nothrow @property @safe uint shulkerDirection(uint value) {
		this._cached = false;
		this._shulkerDirection.value = value;
		if(!this._shulkerDirection.changed) {
			this._shulkerDirection.changed = true;
			this._changed ~= &this.encodeShulkerDirection;
		}
		return value;
	}

	public pure nothrow @safe encodeShulkerDirection(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(10);
			writeBytes(varuint.encode(this._shulkerDirection.value));
		}
	}

	public pure nothrow @property @safe @nogc sul.protocol.java210.types.OptionalPosition shulkerAttachment() {
		return _shulkerAttachment.value;
	}

	public pure nothrow @property @safe sul.protocol.java210.types.OptionalPosition shulkerAttachment(sul.protocol.java210.types.OptionalPosition value) {
		this._cached = false;
		this._shulkerAttachment.value = value;
		if(!this._shulkerAttachment.changed) {
			this._shulkerAttachment.changed = true;
			this._changed ~= &this.encodeShulkerAttachment;
		}
		return value;
	}

	public pure nothrow @safe encodeShulkerAttachment(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(9);
			this._shulkerAttachment.value.encode(bufferInstance);
		}
	}

	public pure nothrow @property @safe @nogc byte shulkerShieldHeight() {
		return _shulkerShieldHeight.value;
	}

	public pure nothrow @property @safe byte shulkerShieldHeight(byte value) {
		this._cached = false;
		this._shulkerShieldHeight.value = value;
		if(!this._shulkerShieldHeight.changed) {
			this._shulkerShieldHeight.changed = true;
			this._changed ~= &this.encodeShulkerShieldHeight;
		}
		return value;
	}

	public pure nothrow @safe encodeShulkerShieldHeight(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._shulkerShieldHeight.value);
		}
	}

	public pure nothrow @property @safe @nogc byte blazeOnFire() {
		return _blazeOnFire.value;
	}

	public pure nothrow @property @safe byte blazeOnFire(byte value) {
		this._cached = false;
		this._blazeOnFire.value = value;
		if(!this._blazeOnFire.changed) {
			this._blazeOnFire.changed = true;
			this._changed ~= &this.encodeBlazeOnFire;
		}
		return value;
	}

	public pure nothrow @safe encodeBlazeOnFire(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._blazeOnFire.value);
		}
	}

	public pure nothrow @property @safe @nogc uint creeperState() {
		return _creeperState.value;
	}

	public pure nothrow @property @safe uint creeperState(uint value) {
		this._cached = false;
		this._creeperState.value = value;
		if(!this._creeperState.changed) {
			this._creeperState.changed = true;
			this._changed ~= &this.encodeCreeperState;
		}
		return value;
	}

	public pure nothrow @safe encodeCreeperState(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._creeperState.value));
		}
	}

	public pure nothrow @property @safe @nogc bool charged() {
		return _charged.value;
	}

	public pure nothrow @property @safe bool charged(bool value) {
		this._cached = false;
		this._charged.value = value;
		if(!this._charged.changed) {
			this._charged.changed = true;
			this._changed ~= &this.encodeCharged;
		}
		return value;
	}

	public pure nothrow @safe encodeCharged(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._charged.value);
		}
	}

	public pure nothrow @property @safe @nogc bool ignited() {
		return _ignited.value;
	}

	public pure nothrow @property @safe bool ignited(bool value) {
		this._cached = false;
		this._ignited.value = value;
		if(!this._ignited.changed) {
			this._ignited.changed = true;
			this._changed ~= &this.encodeIgnited;
		}
		return value;
	}

	public pure nothrow @safe encodeIgnited(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._ignited.value);
		}
	}

	public pure nothrow @property @safe @nogc byte guardianFlags() {
		return _guardianFlags.value;
	}

	public pure nothrow @property @safe byte guardianFlags(byte value) {
		this._cached = false;
		this._guardianFlags.value = value;
		if(!this._guardianFlags.changed) {
			this._guardianFlags.changed = true;
			this._changed ~= &this.encodeGuardianFlags;
		}
		return value;
	}

	public pure nothrow @safe encodeGuardianFlags(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._guardianFlags.value);
		}
	}

	public pure nothrow @property @safe bool retractingSpikes() {
		return _guardianFlags.value._1;
	}

	public pure nothrow @property @safe bool retractingSpikes(bool value) {
		_guardianFlags.value._1 = value;
		return value;
	}

	public pure nothrow @property @safe bool elder() {
		return _guardianFlags.value._2;
	}

	public pure nothrow @property @safe bool elder(bool value) {
		_guardianFlags.value._2 = value;
		return value;
	}

	public pure nothrow @property @safe @nogc uint guardianTarget() {
		return _guardianTarget.value;
	}

	public pure nothrow @property @safe uint guardianTarget(uint value) {
		this._cached = false;
		this._guardianTarget.value = value;
		if(!this._guardianTarget.changed) {
			this._guardianTarget.changed = true;
			this._changed ~= &this.encodeGuardianTarget;
		}
		return value;
	}

	public pure nothrow @safe encodeGuardianTarget(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._guardianTarget.value));
		}
	}

	public pure nothrow @property @safe @nogc uint skeletonType() {
		return _skeletonType.value;
	}

	public pure nothrow @property @safe uint skeletonType(uint value) {
		this._cached = false;
		this._skeletonType.value = value;
		if(!this._skeletonType.changed) {
			this._skeletonType.changed = true;
			this._changed ~= &this.encodeSkeletonType;
		}
		return value;
	}

	public pure nothrow @safe encodeSkeletonType(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._skeletonType.value));
		}
	}

	public pure nothrow @property @safe @nogc bool swingingArms() {
		return _swingingArms.value;
	}

	public pure nothrow @property @safe bool swingingArms(bool value) {
		this._cached = false;
		this._swingingArms.value = value;
		if(!this._swingingArms.changed) {
			this._swingingArms.changed = true;
			this._changed ~= &this.encodeSwingingArms;
		}
		return value;
	}

	public pure nothrow @safe encodeSwingingArms(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._swingingArms.value);
		}
	}

	public pure nothrow @property @safe @nogc byte climbing() {
		return _climbing.value;
	}

	public pure nothrow @property @safe byte climbing(byte value) {
		this._cached = false;
		this._climbing.value = value;
		if(!this._climbing.changed) {
			this._climbing.changed = true;
			this._changed ~= &this.encodeClimbing;
		}
		return value;
	}

	public pure nothrow @safe encodeClimbing(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._climbing.value);
		}
	}

	public pure nothrow @property @safe @nogc uint centerHeadTarget() {
		return _centerHeadTarget.value;
	}

	public pure nothrow @property @safe uint centerHeadTarget(uint value) {
		this._cached = false;
		this._centerHeadTarget.value = value;
		if(!this._centerHeadTarget.changed) {
			this._centerHeadTarget.changed = true;
			this._changed ~= &this.encodeCenterHeadTarget;
		}
		return value;
	}

	public pure nothrow @safe encodeCenterHeadTarget(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._centerHeadTarget.value));
		}
	}

	public pure nothrow @property @safe @nogc uint leftHeadTarget() {
		return _leftHeadTarget.value;
	}

	public pure nothrow @property @safe uint leftHeadTarget(uint value) {
		this._cached = false;
		this._leftHeadTarget.value = value;
		if(!this._leftHeadTarget.changed) {
			this._leftHeadTarget.changed = true;
			this._changed ~= &this.encodeLeftHeadTarget;
		}
		return value;
	}

	public pure nothrow @safe encodeLeftHeadTarget(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._leftHeadTarget.value));
		}
	}

	public pure nothrow @property @safe @nogc uint rightHeadTarget() {
		return _rightHeadTarget.value;
	}

	public pure nothrow @property @safe uint rightHeadTarget(uint value) {
		this._cached = false;
		this._rightHeadTarget.value = value;
		if(!this._rightHeadTarget.changed) {
			this._rightHeadTarget.changed = true;
			this._changed ~= &this.encodeRightHeadTarget;
		}
		return value;
	}

	public pure nothrow @safe encodeRightHeadTarget(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._rightHeadTarget.value));
		}
	}

	public pure nothrow @property @safe @nogc uint invulnerableTime() {
		return _invulnerableTime.value;
	}

	public pure nothrow @property @safe uint invulnerableTime(uint value) {
		this._cached = false;
		this._invulnerableTime.value = value;
		if(!this._invulnerableTime.changed) {
			this._invulnerableTime.changed = true;
			this._changed ~= &this.encodeInvulnerableTime;
		}
		return value;
	}

	public pure nothrow @safe encodeInvulnerableTime(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._invulnerableTime.value));
		}
	}

	public pure nothrow @property @safe @nogc uint zombieType() {
		return _zombieType.value;
	}

	public pure nothrow @property @safe uint zombieType(uint value) {
		this._cached = false;
		this._zombieType.value = value;
		if(!this._zombieType.changed) {
			this._zombieType.changed = true;
			this._changed ~= &this.encodeZombieType;
		}
		return value;
	}

	public pure nothrow @safe encodeZombieType(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._zombieType.value));
		}
	}

	public pure nothrow @property @safe @nogc bool converting() {
		return _converting.value;
	}

	public pure nothrow @property @safe bool converting(bool value) {
		this._cached = false;
		this._converting.value = value;
		if(!this._converting.changed) {
			this._converting.changed = true;
			this._changed ~= &this.encodeConverting;
		}
		return value;
	}

	public pure nothrow @safe encodeConverting(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._converting.value);
		}
	}

	public pure nothrow @property @safe @nogc bool handsHeldUp() {
		return _handsHeldUp.value;
	}

	public pure nothrow @property @safe bool handsHeldUp(bool value) {
		this._cached = false;
		this._handsHeldUp.value = value;
		if(!this._handsHeldUp.changed) {
			this._handsHeldUp.changed = true;
			this._changed ~= &this.encodeHandsHeldUp;
		}
		return value;
	}

	public pure nothrow @safe encodeHandsHeldUp(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._handsHeldUp.value);
		}
	}

	public pure nothrow @property @safe @nogc uint carriedBlock() {
		return _carriedBlock.value;
	}

	public pure nothrow @property @safe uint carriedBlock(uint value) {
		this._cached = false;
		this._carriedBlock.value = value;
		if(!this._carriedBlock.changed) {
			this._carriedBlock.changed = true;
			this._changed ~= &this.encodeCarriedBlock;
		}
		return value;
	}

	public pure nothrow @safe encodeCarriedBlock(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(12);
			writeBytes(varuint.encode(this._carriedBlock.value));
		}
	}

	public pure nothrow @property @safe @nogc bool screaming() {
		return _screaming.value;
	}

	public pure nothrow @property @safe bool screaming(bool value) {
		this._cached = false;
		this._screaming.value = value;
		if(!this._screaming.changed) {
			this._screaming.changed = true;
			this._changed ~= &this.encodeScreaming;
		}
		return value;
	}

	public pure nothrow @safe encodeScreaming(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._screaming.value);
		}
	}

	public pure nothrow @property @safe @nogc uint dragonPhase() {
		return _dragonPhase.value;
	}

	public pure nothrow @property @safe uint dragonPhase(uint value) {
		this._cached = false;
		this._dragonPhase.value = value;
		if(!this._dragonPhase.changed) {
			this._dragonPhase.changed = true;
			this._changed ~= &this.encodeDragonPhase;
		}
		return value;
	}

	public pure nothrow @safe encodeDragonPhase(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._dragonPhase.value));
		}
	}

	public pure nothrow @property @safe @nogc bool ghastAttacking() {
		return _ghastAttacking.value;
	}

	public pure nothrow @property @safe bool ghastAttacking(bool value) {
		this._cached = false;
		this._ghastAttacking.value = value;
		if(!this._ghastAttacking.changed) {
			this._ghastAttacking.changed = true;
			this._changed ~= &this.encodeGhastAttacking;
		}
		return value;
	}

	public pure nothrow @safe encodeGhastAttacking(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._ghastAttacking.value);
		}
	}

	public pure nothrow @property @safe @nogc uint slimeSize() {
		return _slimeSize.value;
	}

	public pure nothrow @property @safe uint slimeSize(uint value) {
		this._cached = false;
		this._slimeSize.value = value;
		if(!this._slimeSize.changed) {
			this._slimeSize.changed = true;
			this._changed ~= &this.encodeSlimeSize;
		}
		return value;
	}

	public pure nothrow @safe encodeSlimeSize(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._slimeSize.value));
		}
	}

	public pure nothrow @property @safe @nogc uint shakingPower() {
		return _shakingPower.value;
	}

	public pure nothrow @property @safe uint shakingPower(uint value) {
		this._cached = false;
		this._shakingPower.value = value;
		if(!this._shakingPower.changed) {
			this._shakingPower.changed = true;
			this._changed ~= &this.encodeShakingPower;
		}
		return value;
	}

	public pure nothrow @safe encodeShakingPower(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._shakingPower.value));
		}
	}

	public pure nothrow @property @safe @nogc uint shakingDirection() {
		return _shakingDirection.value;
	}

	public pure nothrow @property @safe uint shakingDirection(uint value) {
		this._cached = false;
		this._shakingDirection.value = value;
		if(!this._shakingDirection.changed) {
			this._shakingDirection.changed = true;
			this._changed ~= &this.encodeShakingDirection;
		}
		return value;
	}

	public pure nothrow @safe encodeShakingDirection(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(7);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._shakingDirection.value));
		}
	}

	public pure nothrow @property @safe @nogc float shakingMultiplier() {
		return _shakingMultiplier.value;
	}

	public pure nothrow @property @safe float shakingMultiplier(float value) {
		this._cached = false;
		this._shakingMultiplier.value = value;
		if(!this._shakingMultiplier.changed) {
			this._shakingMultiplier.changed = true;
			this._changed ~= &this.encodeShakingMultiplier;
		}
		return value;
	}

	public pure nothrow @safe encodeShakingMultiplier(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(8);
			writeBigEndianUbyte(2);
			writeBigEndianFloat(this._shakingMultiplier.value);
		}
	}

	public pure nothrow @property @safe @nogc uint minecartBlock() {
		return _minecartBlock.value;
	}

	public pure nothrow @property @safe uint minecartBlock(uint value) {
		this._cached = false;
		this._minecartBlock.value = value;
		if(!this._minecartBlock.changed) {
			this._minecartBlock.changed = true;
			this._changed ~= &this.encodeMinecartBlock;
		}
		return value;
	}

	public pure nothrow @safe encodeMinecartBlock(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(9);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._minecartBlock.value));
		}
	}

	public pure nothrow @property @safe @nogc uint minecartBlockPosition() {
		return _minecartBlockPosition.value;
	}

	public pure nothrow @property @safe uint minecartBlockPosition(uint value) {
		this._cached = false;
		this._minecartBlockPosition.value = value;
		if(!this._minecartBlockPosition.changed) {
			this._minecartBlockPosition.changed = true;
			this._changed ~= &this.encodeMinecartBlockPosition;
		}
		return value;
	}

	public pure nothrow @safe encodeMinecartBlockPosition(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(10);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._minecartBlockPosition.value));
		}
	}

	public pure nothrow @property @safe @nogc bool minecartCustomBlock() {
		return _minecartCustomBlock.value;
	}

	public pure nothrow @property @safe bool minecartCustomBlock(bool value) {
		this._cached = false;
		this._minecartCustomBlock.value = value;
		if(!this._minecartCustomBlock.changed) {
			this._minecartCustomBlock.changed = true;
			this._changed ~= &this.encodeMinecartCustomBlock;
		}
		return value;
	}

	public pure nothrow @safe encodeMinecartCustomBlock(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(11);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._minecartCustomBlock.value);
		}
	}

	public pure nothrow @property @safe @nogc bool furnacePowered() {
		return _furnacePowered.value;
	}

	public pure nothrow @property @safe bool furnacePowered(bool value) {
		this._cached = false;
		this._furnacePowered.value = value;
		if(!this._furnacePowered.changed) {
			this._furnacePowered.changed = true;
			this._changed ~= &this.encodeFurnacePowered;
		}
		return value;
	}

	public pure nothrow @safe encodeFurnacePowered(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._furnacePowered.value);
		}
	}

	public pure nothrow @property @safe @nogc string command() {
		return _command.value;
	}

	public pure nothrow @property @safe string command(string value) {
		this._cached = false;
		this._command.value = value;
		if(!this._command.changed) {
			this._command.changed = true;
			this._changed ~= &this.encodeCommand;
		}
		return value;
	}

	public pure nothrow @safe encodeCommand(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(3);
			writeBytes(varuint.encode(cast(uint)this._command.value.length)); writeString(this._command.value);
		}
	}

	public pure nothrow @property @safe @nogc string lastOutput() {
		return _lastOutput.value;
	}

	public pure nothrow @property @safe string lastOutput(string value) {
		this._cached = false;
		this._lastOutput.value = value;
		if(!this._lastOutput.changed) {
			this._lastOutput.changed = true;
			this._changed ~= &this.encodeLastOutput;
		}
		return value;
	}

	public pure nothrow @safe encodeLastOutput(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(13);
			writeBigEndianUbyte(4);
			writeBytes(varuint.encode(cast(uint)this._lastOutput.value.length)); writeString(this._lastOutput.value);
		}
	}

	public pure nothrow @property @safe @nogc uint fuseTime() {
		return _fuseTime.value;
	}

	public pure nothrow @property @safe uint fuseTime(uint value) {
		this._cached = false;
		this._fuseTime.value = value;
		if(!this._fuseTime.changed) {
			this._fuseTime.changed = true;
			this._changed ~= &this.encodeFuseTime;
		}
		return value;
	}

	public pure nothrow @safe encodeFuseTime(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(6);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._fuseTime.value));
		}
	}

	public pure nothrow @safe encode(Buffer buffer) {
		with(buffer) {
			if(this._cached) {
				buffer.writeBytes(this._cache);
			} else {
				immutable start = buffer._buffer.length;
				foreach(del ; this._changed) del(buffer);
				writeBigEndianUbyte(255);
				this._cached = true;
				this._cache = buffer._buffer[start..$];
			}
		}
	}

	public static pure nothrow @safe Metadata decode(Buffer buffer) {
		auto metadata = new Metadata();
		with(buffer) {
			ubyte id;
			while(_index < _buffer.length && (id=readBigEndianUbyte()) != 255) {
				switch(readBigEndianUbyte()) {
					case 0:
						byte _0;
						_0=readBigEndianByte();
						metadata.decoded ~= DecodedMetadata.fromByte(id, _0);
						break;
					case 1:
						uint _1;
						_1=varuint.decode(_buffer, &_index);
						metadata.decoded ~= DecodedMetadata.fromInt(id, _1);
						break;
					case 2:
						float _2;
						_2=readBigEndianFloat();
						metadata.decoded ~= DecodedMetadata.fromFloat(id, _2);
						break;
					case 3:
						string _3;
						uint xm=varuint.decode(_buffer, &_index); _3=readString(xm);
						metadata.decoded ~= DecodedMetadata.fromString(id, _3);
						break;
					case 4:
						string _4;
						uint xq=varuint.decode(_buffer, &_index); _4=readString(xq);
						metadata.decoded ~= DecodedMetadata.fromChat(id, _4);
						break;
					case 5:
						sul.protocol.java210.types.Slot _5;
						_5.decode(bufferInstance);
						metadata.decoded ~= DecodedMetadata.fromSlot(id, _5);
						break;
					case 6:
						bool _6;
						_6=readBigEndianBool();
						metadata.decoded ~= DecodedMetadata.fromBool(id, _6);
						break;
					case 7:
						Tuple!(float, "x", float, "y", float, "z") _7;
						_7.x=readBigEndianFloat(); _7.y=readBigEndianFloat(); _7.z=readBigEndianFloat();
						metadata.decoded ~= DecodedMetadata.fromRotation(id, _7);
						break;
					case 8:
						ulong _8;
						_8=readBigEndianUlong();
						metadata.decoded ~= DecodedMetadata.fromPosition(id, _8);
						break;
					case 9:
						sul.protocol.java210.types.OptionalPosition _9;
						_9.decode(bufferInstance);
						metadata.decoded ~= DecodedMetadata.fromOptionalPosition(id, _9);
						break;
					case 10:
						uint _10;
						_10=varuint.decode(_buffer, &_index);
						metadata.decoded ~= DecodedMetadata.fromDirection(id, _10);
						break;
					case 11:
						sul.protocol.java210.types.OptionalUuid _11;
						_11.decode(bufferInstance);
						metadata.decoded ~= DecodedMetadata.fromUuid(id, _11);
						break;
					case 12:
						uint _12;
						_12=varuint.decode(_buffer, &_index);
						metadata.decoded ~= DecodedMetadata.fromBlock(id, _12);
						break;
					default:
						break;
				}
			}
		}
		return metadata;
	}

}

class DecodedMetadata {

	public immutable ubyte id;
	public immutable ubyte type;

	union {
		byte byte_;
		uint int_;
		float float_;
		string string_;
		string chat;
		sul.protocol.java210.types.Slot slot;
		bool bool_;
		Tuple!(float, "x", float, "y", float, "z") rotation;
		ulong position;
		sul.protocol.java210.types.OptionalPosition optional_position;
		uint direction;
		sul.protocol.java210.types.OptionalUuid uuid;
		uint block;
	}

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

	public static pure nothrow @trusted DecodedMetadata fromByte(ubyte id, byte value) {
		auto ret = new DecodedMetadata(id, 0);
		ret.byte_ = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromInt(ubyte id, uint value) {
		auto ret = new DecodedMetadata(id, 1);
		ret.int_ = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromFloat(ubyte id, float value) {
		auto ret = new DecodedMetadata(id, 2);
		ret.float_ = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromString(ubyte id, string value) {
		auto ret = new DecodedMetadata(id, 3);
		ret.string_ = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromChat(ubyte id, string value) {
		auto ret = new DecodedMetadata(id, 4);
		ret.chat = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromSlot(ubyte id, sul.protocol.java210.types.Slot value) {
		auto ret = new DecodedMetadata(id, 5);
		ret.slot = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromBool(ubyte id, bool value) {
		auto ret = new DecodedMetadata(id, 6);
		ret.bool_ = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromRotation(ubyte id, Tuple!(float, "x", float, "y", float, "z") value) {
		auto ret = new DecodedMetadata(id, 7);
		ret.rotation = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromPosition(ubyte id, ulong value) {
		auto ret = new DecodedMetadata(id, 8);
		ret.position = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromOptionalPosition(ubyte id, sul.protocol.java210.types.OptionalPosition value) {
		auto ret = new DecodedMetadata(id, 9);
		ret.optional_position = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromDirection(ubyte id, uint value) {
		auto ret = new DecodedMetadata(id, 10);
		ret.direction = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromUuid(ubyte id, sul.protocol.java210.types.OptionalUuid value) {
		auto ret = new DecodedMetadata(id, 11);
		ret.uuid = value;
		return ret;
	}

	public static pure nothrow @trusted DecodedMetadata fromBlock(ubyte id, uint value) {
		auto ret = new DecodedMetadata(id, 12);
		ret.block = value;
		return ret;
	}

}