/*
 * 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/minecraft316.xml
 */
module sul.metadata.minecraft316;

import std.typecons : Tuple, tuple;

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

static import sul.protocol.minecraft316.types;

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

class Metadata {

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

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

	private 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.minecraft316.types.Slot) _potion;
	private Changed!(ulong) _spawnPosition;
	private Changed!(float) _radius = tuple(cast(float)0.5, false);
	private Changed!(uint) _color = tuple(cast(uint)-1, false);
	private Changed!(bool) _isSinglePoint;
	private Changed!(uint) _particleId;
	private Changed!(uint) _particleParameter1;
	private Changed!(uint) _particleParameter2;
	private Changed!(uint) _hookedEntity;
	private Changed!(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.minecraft316.types.OptionalPosition) _beamTarget;
	private Changed!(bool) _showBottom;
	private Changed!(sul.protocol.minecraft316.types.Slot) _firework;
	private Changed!(uint) _fireworkThrower;
	private Changed!(sul.protocol.minecraft316.types.Slot) _item;
	private Changed!(uint) _rotation;
	private Changed!(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!(byte) _skinParts = tuple(cast(byte)0, false);
	private Changed!(byte) _mainHand = tuple(cast(byte)1, false);
	private Changed!(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!(byte) _instentientFlags;
	private Changed!(byte) _hanging;
	private Changed!(bool) _baby;
	private Changed!(byte) _horseFlags;
	private Changed!(sul.protocol.minecraft316.types.OptionalUuid) _ownerUuid;
	private Changed!(uint) _horseVariant;
	private Changed!(uint) _horseArmor;
	private Changed!(bool) _chested;
	private Changed!(uint) _llamaStrength;
	private Changed!(uint) _carpetColor = tuple(cast(uint)-1, false);
	private Changed!(uint) _llamaVariant;
	private Changed!(bool) _pigSaddled;
	private Changed!(uint) _carrotBoost;
	private Changed!(uint) _rabbitVariant;
	private Changed!(bool) _standingUp;
	private Changed!(byte) _sheepFlagsAndColor;
	private Changed!(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!(byte) _snowmanFlags;
	private Changed!(uint) _shulkerDirection;
	private Changed!(sul.protocol.minecraft316.types.OptionalPosition) _shulkerAttachment;
	private Changed!(byte) _shulkerShieldHeight;
	private Changed!(byte) _shulkerColor;
	private Changed!(byte) _blazeOnFire;
	private Changed!(uint) _creeperState = tuple(cast(uint)-1, false);
	private Changed!(bool) _charged;
	private Changed!(bool) _ignited;
	private Changed!(bool) _rectractingSpikes;
	private Changed!(uint) _guardianTarget;
	private Changed!(byte) _spell;
	private Changed!(byte) _attackMode;
	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!(bool) _handsHeldUp;
	private Changed!(bool) _converting;
	private Changed!(uint) _zombieVillagerProfession;
	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) & 1;
	}

	public pure nothrow @property @safe bool onFire(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 0));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 0));
		return value;
	}

	public pure nothrow @property @safe bool sneaking() {
		return (_entityFlags >>> 1) & 1;
	}

	public pure nothrow @property @safe bool sneaking(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 1));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 1));
		return value;
	}

	public pure nothrow @property @safe bool sprinting() {
		return (_entityFlags >>> 3) & 1;
	}

	public pure nothrow @property @safe bool sprinting(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 3));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 3));
		return value;
	}

	public pure nothrow @property @safe bool invisible() {
		return (_entityFlags >>> 5) & 1;
	}

	public pure nothrow @property @safe bool invisible(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 5));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 5));
		return value;
	}

	public pure nothrow @property @safe bool glowing() {
		return (_entityFlags >>> 6) & 1;
	}

	public pure nothrow @property @safe bool glowing(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 6));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 6));
		return value;
	}

	public pure nothrow @property @safe bool gliding() {
		return (_entityFlags >>> 7) & 1;
	}

	public pure nothrow @property @safe bool gliding(bool value) {
		if(value) entityFlags = cast(byte)(_entityFlags | (cast(byte)true << 7));
		else entityFlags = cast(byte)(_entityFlags & ~(cast(byte)true << 7));
		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.minecraft316.types.Slot potion() {
		return _potion.value;
	}

	public pure nothrow @property @safe sul.protocol.minecraft316.types.Slot potion(sul.protocol.minecraft316.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) & 1;
	}

	public pure nothrow @property @safe bool critical(bool value) {
		if(value) arrowFlags = cast(byte)(_arrowFlags.value | (cast(byte)true << 0));
		else arrowFlags = cast(byte)(_arrowFlags.value & ~(cast(byte)true << 0));
		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.minecraft316.types.OptionalPosition beamTarget() {
		return _beamTarget.value;
	}

	public pure nothrow @property @safe sul.protocol.minecraft316.types.OptionalPosition beamTarget(sul.protocol.minecraft316.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.minecraft316.types.Slot firework() {
		return _firework.value;
	}

	public pure nothrow @property @safe sul.protocol.minecraft316.types.Slot firework(sul.protocol.minecraft316.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 uint fireworkThrower() {
		return _fireworkThrower.value;
	}

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

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

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

	public pure nothrow @property @safe sul.protocol.minecraft316.types.Slot item(sul.protocol.minecraft316.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) & 1;
	}

	public pure nothrow @property @safe bool handActive(bool value) {
		if(value) livingFlags = cast(byte)(_livingFlags.value | (cast(byte)true << 0));
		else livingFlags = cast(byte)(_livingFlags.value & ~(cast(byte)true << 0));
		return value;
	}

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

	public pure nothrow @property @safe bool offhand(bool value) {
		if(value) livingFlags = cast(byte)(_livingFlags.value | (cast(byte)true << 1));
		else livingFlags = cast(byte)(_livingFlags.value & ~(cast(byte)true << 1));
		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) & 1;
	}

	public pure nothrow @property @safe bool cape(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 0));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 0));
		return value;
	}

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

	public pure nothrow @property @safe bool jacket(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 1));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 1));
		return value;
	}

	public pure nothrow @property @safe bool leftSleeve() {
		return (_skinParts.value >>> 2) & 1;
	}

	public pure nothrow @property @safe bool leftSleeve(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 2));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 2));
		return value;
	}

	public pure nothrow @property @safe bool rightSleeve() {
		return (_skinParts.value >>> 3) & 1;
	}

	public pure nothrow @property @safe bool rightSleeve(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 3));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 3));
		return value;
	}

	public pure nothrow @property @safe bool leftPants() {
		return (_skinParts.value >>> 4) & 1;
	}

	public pure nothrow @property @safe bool leftPants(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 4));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 4));
		return value;
	}

	public pure nothrow @property @safe bool rightPants() {
		return (_skinParts.value >>> 5) & 1;
	}

	public pure nothrow @property @safe bool rightPants(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 5));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 5));
		return value;
	}

	public pure nothrow @property @safe bool hat() {
		return (_skinParts.value >>> 6) & 1;
	}

	public pure nothrow @property @safe bool hat(bool value) {
		if(value) skinParts = cast(byte)(_skinParts.value | (cast(byte)true << 6));
		else skinParts = cast(byte)(_skinParts.value & ~(cast(byte)true << 6));
		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) & 1;
	}

	public pure nothrow @property @safe bool isSmall(bool value) {
		if(value) armorStandFlags = cast(byte)(_armorStandFlags.value | (cast(byte)true << 0));
		else armorStandFlags = cast(byte)(_armorStandFlags.value & ~(cast(byte)true << 0));
		return value;
	}

	public pure nothrow @property @safe bool hasArms() {
		return (_armorStandFlags.value >>> 2) & 1;
	}

	public pure nothrow @property @safe bool hasArms(bool value) {
		if(value) armorStandFlags = cast(byte)(_armorStandFlags.value | (cast(byte)true << 2));
		else armorStandFlags = cast(byte)(_armorStandFlags.value & ~(cast(byte)true << 2));
		return value;
	}

	public pure nothrow @property @safe bool noBasePlate() {
		return (_armorStandFlags.value >>> 3) & 1;
	}

	public pure nothrow @property @safe bool noBasePlate(bool value) {
		if(value) armorStandFlags = cast(byte)(_armorStandFlags.value | (cast(byte)true << 3));
		else armorStandFlags = cast(byte)(_armorStandFlags.value & ~(cast(byte)true << 3));
		return value;
	}

	public pure nothrow @property @safe bool setMarker() {
		return (_armorStandFlags.value >>> 4) & 1;
	}

	public pure nothrow @property @safe bool setMarker(bool value) {
		if(value) armorStandFlags = cast(byte)(_armorStandFlags.value | (cast(byte)true << 4));
		else armorStandFlags = cast(byte)(_armorStandFlags.value & ~(cast(byte)true << 4));
		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) & 1;
	}

	public pure nothrow @property @safe bool noAi(bool value) {
		if(value) instentientFlags = cast(byte)(_instentientFlags.value | (cast(byte)true << 0));
		else instentientFlags = cast(byte)(_instentientFlags.value & ~(cast(byte)true << 0));
		return value;
	}

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

	public pure nothrow @property @safe bool leftHanded(bool value) {
		if(value) instentientFlags = cast(byte)(_instentientFlags.value | (cast(byte)true << 1));
		else instentientFlags = cast(byte)(_instentientFlags.value & ~(cast(byte)true << 1));
		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) & 1;
	}

	public pure nothrow @property @safe bool horseTamed(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 1));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 1));
		return value;
	}

	public pure nothrow @property @safe bool horseSaddled() {
		return (_horseFlags.value >>> 2) & 1;
	}

	public pure nothrow @property @safe bool horseSaddled(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 2));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 2));
		return value;
	}

	public pure nothrow @property @safe bool horseChested() {
		return (_horseFlags.value >>> 3) & 1;
	}

	public pure nothrow @property @safe bool horseChested(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 3));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 3));
		return value;
	}

	public pure nothrow @property @safe bool horseEating() {
		return (_horseFlags.value >>> 5) & 1;
	}

	public pure nothrow @property @safe bool horseEating(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 5));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 5));
		return value;
	}

	public pure nothrow @property @safe bool horseRearing() {
		return (_horseFlags.value >>> 6) & 1;
	}

	public pure nothrow @property @safe bool horseRearing(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 6));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 6));
		return value;
	}

	public pure nothrow @property @safe bool mouthOpen() {
		return (_horseFlags.value >>> 7) & 1;
	}

	public pure nothrow @property @safe bool mouthOpen(bool value) {
		if(value) horseFlags = cast(byte)(_horseFlags.value | (cast(byte)true << 7));
		else horseFlags = cast(byte)(_horseFlags.value & ~(cast(byte)true << 7));
		return value;
	}

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

	public pure nothrow @property @safe sul.protocol.minecraft316.types.OptionalUuid ownerUuid(sul.protocol.minecraft316.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(14);
			writeBigEndianUbyte(11);
			this._ownerUuid.value.encode(bufferInstance);
		}
	}

	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 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(16);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._horseArmor.value));
		}
	}

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

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

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

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

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

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

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

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

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

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

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

	public pure nothrow @safe encodeLlamaVariant(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(18);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._llamaVariant.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 carrotBoost() {
		return _carrotBoost.value;
	}

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

	public pure nothrow @safe encodeCarrotBoost(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(14);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._carrotBoost.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) & 1;
	}

	public pure nothrow @property @safe bool sheared(bool value) {
		if(value) sheepFlagsAndColor = cast(byte)(_sheepFlagsAndColor.value | (cast(byte)true << 7));
		else sheepFlagsAndColor = cast(byte)(_sheepFlagsAndColor.value & ~(cast(byte)true << 7));
		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) & 1;
	}

	public pure nothrow @property @safe bool sitting(bool value) {
		if(value) tameableFlags = cast(byte)(_tameableFlags.value | (cast(byte)true << 0));
		else tameableFlags = cast(byte)(_tameableFlags.value & ~(cast(byte)true << 0));
		return value;
	}

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

	public pure nothrow @property @safe bool angry(bool value) {
		if(value) tameableFlags = cast(byte)(_tameableFlags.value | (cast(byte)true << 1));
		else tameableFlags = cast(byte)(_tameableFlags.value & ~(cast(byte)true << 1));
		return value;
	}

	public pure nothrow @property @safe bool tamed() {
		return (_tameableFlags.value >>> 2) & 1;
	}

	public pure nothrow @property @safe bool tamed(bool value) {
		if(value) tameableFlags = cast(byte)(_tameableFlags.value | (cast(byte)true << 2));
		else tameableFlags = cast(byte)(_tameableFlags.value & ~(cast(byte)true << 2));
		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) & 1;
	}

	public pure nothrow @property @safe bool pumpkinless(bool value) {
		if(value) snowmanFlags = cast(byte)(_snowmanFlags.value | (cast(byte)true << 4));
		else snowmanFlags = cast(byte)(_snowmanFlags.value & ~(cast(byte)true << 4));
		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.minecraft316.types.OptionalPosition shulkerAttachment() {
		return _shulkerAttachment.value;
	}

	public pure nothrow @property @safe sul.protocol.minecraft316.types.OptionalPosition shulkerAttachment(sul.protocol.minecraft316.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 shulkerColor() {
		return _shulkerColor.value;
	}

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

	public pure nothrow @safe encodeShulkerColor(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(15);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._shulkerColor.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 bool rectractingSpikes() {
		return _rectractingSpikes.value;
	}

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

	public pure nothrow @safe encodeRectractingSpikes(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._rectractingSpikes.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 byte spell() {
		return _spell.value;
	}

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

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

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

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

	public pure nothrow @safe encodeAttackMode(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(12);
			writeBigEndianUbyte(0);
			writeBigEndianByte(this._attackMode.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(12);
			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 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(14);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._handsHeldUp.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(15);
			writeBigEndianUbyte(6);
			writeBigEndianBool(this._converting.value);
		}
	}

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

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

	public pure nothrow @safe encodeZombieVillagerProfession(Buffer buffer) {
		with(buffer) {
			writeBigEndianUbyte(16);
			writeBigEndianUbyte(1);
			writeBytes(varuint.encode(this._zombieVillagerProfession.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) {
		return null;
	}

}