1.21.5

Co-authored-by: Bjarne Koll <git@lynxplay.dev>
Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
Co-authored-by: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
Co-authored-by: MiniDigger | Martin <admin@minidigger.dev>
Co-authored-by: Nassim Jahnke <nassim@njahnke.dev>
Co-authored-by: Noah van der Aa <ndvdaa@gmail.com>
Co-authored-by: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
Co-authored-by: Shane Freeder <theboyetronic@gmail.com>
Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
Co-authored-by: Tamion <70228790+notTamion@users.noreply.github.com>
Co-authored-by: Warrior <50800980+Warriorrrr@users.noreply.github.com>

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftAmethystCluster.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.AmethystCluster;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftAmethystCluster extends CraftBlockData implements AmethystCluster {
+    private static final EnumProperty<Direction> FACING = AmethystClusterBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = AmethystClusterBlock.WATERLOGGED;
+
+    public CraftAmethystCluster(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftAnvil.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.AnvilBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftAnvil extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = AnvilBlock.FACING;
+
+    public CraftAnvil(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftAttachedStem.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.AttachedStemBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftAttachedStem extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = AttachedStemBlock.FACING;
+
+    public CraftAttachedStem(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBambooStalk.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BambooStalkBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BambooLeaves;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Bamboo;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBambooStalk extends CraftBlockData implements Bamboo {
+    private static final IntegerProperty AGE = BambooStalkBlock.AGE;
+
+    private static final EnumProperty<BambooLeaves> LEAVES = BambooStalkBlock.LEAVES;
+
+    private static final IntegerProperty STAGE = BambooStalkBlock.STAGE;
+
+    public CraftBambooStalk(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+
+    @Override
+    public Bamboo.Leaves getLeaves() {
+        return this.get(LEAVES, Bamboo.Leaves.class);
+    }
+
+    @Override
+    public void setLeaves(final Bamboo.Leaves leaves) {
+        Preconditions.checkArgument(leaves != null, "leaves cannot be null!");
+        this.set(LEAVES, leaves);
+    }
+
+    @Override
+    public int getStage() {
+        return this.get(STAGE);
+    }
+
+    @Override
+    public void setStage(final int stage) {
+        this.set(STAGE, stage);
+    }
+
+    @Override
+    public int getMaximumStage() {
+        return STAGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBanner.java

@@ -0,0 +1,35 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BannerBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import net.minecraft.world.level.block.state.properties.RotationSegment;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Rotatable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.util.Vector;
+
+@GeneratedFrom("1.21.5")
+public class CraftBanner extends CraftBlockData implements Rotatable {
+    private static final IntegerProperty ROTATION = BannerBlock.ROTATION;
+
+    public CraftBanner(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getRotation() {
+        return CraftBlockData.ROTATION_CYCLE[this.get(ROTATION)];
+    }
+
+    @Override
+    public void setRotation(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace != BlockFace.SELF && blockFace.getModY() == 0, "Invalid face, only horizontal face are allowed for this property!");
+        Vector dir = blockFace.getDirection();
+        float angle = (float) -Math.toDegrees(Math.atan2(dir.getX(), dir.getZ()));
+        this.set(ROTATION, RotationSegment.convertToSegment(angle));
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBarrel.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BarrelBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Barrel;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBarrel extends CraftBlockData implements Barrel {
+    private static final EnumProperty<Direction> FACING = BarrelBlock.FACING;
+
+    private static final BooleanProperty OPEN = BarrelBlock.OPEN;
+
+    public CraftBarrel(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isOpen() {
+        return this.get(OPEN);
+    }
+
+    @Override
+    public void setOpen(final boolean open) {
+        this.set(OPEN, open);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBarrier.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BarrierBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBarrier extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = BarrierBlock.WATERLOGGED;
+
+    public CraftBarrier(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBaseCoralFan.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BaseCoralFanBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBaseCoralFan extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = BaseCoralFanBlock.WATERLOGGED;
+
+    public CraftBaseCoralFan(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBaseCoralPlant.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BaseCoralPlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBaseCoralPlant extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = BaseCoralPlantBlock.WATERLOGGED;
+
+    public CraftBaseCoralPlant(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBaseCoralWallFan.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BaseCoralWallFanBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.CoralWallFan;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBaseCoralWallFan extends CraftBlockData implements CoralWallFan {
+    private static final EnumProperty<Direction> FACING = BaseCoralWallFanBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = BaseCoralWallFanBlock.WATERLOGGED;
+
+    public CraftBaseCoralWallFan(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBed.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BedBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BedPart;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Bed;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBed extends CraftBlockData implements Bed {
+    private static final EnumProperty<Direction> FACING = BedBlock.FACING;
+
+    private static final BooleanProperty OCCUPIED = BedBlock.OCCUPIED;
+
+    private static final EnumProperty<BedPart> PART = BedBlock.PART;
+
+    public CraftBed(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isOccupied() {
+        return this.get(OCCUPIED);
+    }
+
+    @Override
+    public void setOccupied(final boolean occupied) {
+        this.set(OCCUPIED, occupied);
+    }
+
+    @Override
+    public Bed.Part getPart() {
+        return this.get(PART, Bed.Part.class);
+    }
+
+    @Override
+    public void setPart(final Bed.Part part) {
+        Preconditions.checkArgument(part != null, "part cannot be null!");
+        this.set(PART, part);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBeehive.java

@@ -0,0 +1,56 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BeehiveBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Beehive;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBeehive extends CraftBlockData implements Beehive {
+    private static final EnumProperty<Direction> FACING = BeehiveBlock.FACING;
+
+    private static final IntegerProperty HONEY_LEVEL = BeehiveBlock.HONEY_LEVEL;
+
+    public CraftBeehive(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public int getHoneyLevel() {
+        return this.get(HONEY_LEVEL);
+    }
+
+    @Override
+    public void setHoneyLevel(final int honeyLevel) {
+        this.set(HONEY_LEVEL, honeyLevel);
+    }
+
+    @Override
+    public int getMaximumHoneyLevel() {
+        return HONEY_LEVEL.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBeetroot.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BeetrootBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBeetroot extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = BeetrootBlock.AGE;
+
+    public CraftBeetroot(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBell.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BellBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BellAttachType;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Bell;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBell extends CraftBlockData implements Bell {
+    private static final EnumProperty<BellAttachType> ATTACHMENT = BellBlock.ATTACHMENT;
+
+    private static final EnumProperty<Direction> FACING = BellBlock.FACING;
+
+    private static final BooleanProperty POWERED = BellBlock.POWERED;
+
+    public CraftBell(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Bell.Attachment getAttachment() {
+        return this.get(ATTACHMENT, Bell.Attachment.class);
+    }
+
+    @Override
+    public void setAttachment(final Bell.Attachment attachment) {
+        Preconditions.checkArgument(attachment != null, "attachment cannot be null!");
+        this.set(ATTACHMENT, attachment);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBigDripleaf.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BigDripleafBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.BigDripleaf;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBigDripleaf extends CraftBlockData implements BigDripleaf {
+    private static final EnumProperty<Direction> FACING = BigDripleafBlock.FACING;
+
+    private static final EnumProperty<net.minecraft.world.level.block.state.properties.Tilt> TILT = BlockStateProperties.TILT;
+
+    private static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;
+
+    public CraftBigDripleaf(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public BigDripleaf.Tilt getTilt() {
+        return this.get(TILT, BigDripleaf.Tilt.class);
+    }
+
+    @Override
+    public void setTilt(final BigDripleaf.Tilt tilt) {
+        Preconditions.checkArgument(tilt != null, "tilt cannot be null!");
+        this.set(TILT, tilt);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBigDripleafStem.java

@@ -0,0 +1,52 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BigDripleafStemBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Dripleaf;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBigDripleafStem extends CraftBlockData implements Dripleaf {
+    private static final EnumProperty<Direction> FACING = BigDripleafStemBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;
+
+    public CraftBigDripleafStem(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBlastFurnace.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.BlastFurnaceBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Furnace;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBlastFurnace extends CraftBlockData implements Furnace {
+    private static final EnumProperty<Direction> FACING = BlastFurnaceBlock.FACING;
+
+    private static final BooleanProperty LIT = BlastFurnaceBlock.LIT;
+
+    public CraftBlastFurnace(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBrewingStand.java

@@ -0,0 +1,45 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.world.level.block.BrewingStandBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.BrewingStand;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBrewingStand extends CraftBlockData implements BrewingStand {
+    private static final BooleanProperty[] HAS_BOTTLE = BrewingStandBlock.HAS_BOTTLE;
+
+    public CraftBrewingStand(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasBottle(final int index) {
+        return this.get(HAS_BOTTLE[index]);
+    }
+
+    @Override
+    public void setBottle(final int index, final boolean bottle) {
+        this.set(HAS_BOTTLE[index], bottle);
+    }
+
+    @Override
+    public Set<Integer> getBottles() {
+        ImmutableSet.Builder<Integer> bottles = ImmutableSet.builder();
+        for (int index = 0, len = HAS_BOTTLE.length; index < len; index++) {
+            if (this.get(HAS_BOTTLE[index])) {
+                bottles.add(index);
+            }
+        }
+        return bottles.build();
+    }
+
+    @Override
+    public int getMaximumBottles() {
+        return HAS_BOTTLE.length;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBrushable.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Brushable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBrushable extends CraftBlockData implements Brushable {
+    private static final IntegerProperty DUSTED = BlockStateProperties.DUSTED;
+
+    public CraftBrushable(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getDusted() {
+        return this.get(DUSTED);
+    }
+
+    @Override
+    public void setDusted(final int dusted) {
+        this.set(DUSTED, dusted);
+    }
+
+    @Override
+    public int getMaximumDusted() {
+        return DUSTED.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftBubbleColumn.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.BubbleColumnBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.BubbleColumn;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftBubbleColumn extends CraftBlockData implements BubbleColumn {
+    private static final BooleanProperty DRAG_DOWN = BubbleColumnBlock.DRAG_DOWN;
+
+    public CraftBubbleColumn(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isDrag() {
+        return this.get(DRAG_DOWN);
+    }
+
+    @Override
+    public void setDrag(final boolean drag) {
+        this.set(DRAG_DOWN, drag);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftButton.java

@@ -0,0 +1,66 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.ButtonBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.AttachFace;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Switch;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftButton extends CraftBlockData implements Switch {
+    private static final EnumProperty<AttachFace> FACE = ButtonBlock.FACE;
+
+    private static final EnumProperty<Direction> FACING = ButtonBlock.FACING;
+
+    private static final BooleanProperty POWERED = ButtonBlock.POWERED;
+
+    public CraftButton(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public org.bukkit.block.data.FaceAttachable.AttachedFace getAttachedFace() {
+        return this.get(FACE, org.bukkit.block.data.FaceAttachable.AttachedFace.class);
+    }
+
+    @Override
+    public void setAttachedFace(
+            final org.bukkit.block.data.FaceAttachable.AttachedFace attachedFace) {
+        Preconditions.checkArgument(attachedFace != null, "attachedFace cannot be null!");
+        this.set(FACE, attachedFace);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCactus.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CactusBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCactus extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = CactusBlock.AGE;
+
+    public CraftCactus(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCake.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CakeBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Cake;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCake extends CraftBlockData implements Cake {
+    private static final IntegerProperty BITES = CakeBlock.BITES;
+
+    public CraftCake(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getBites() {
+        return this.get(BITES);
+    }
+
+    @Override
+    public void setBites(final int bites) {
+        this.set(BITES, bites);
+    }
+
+    @Override
+    public int getMaximumBites() {
+        return BITES.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCalibratedSculkSensor.java

@@ -0,0 +1,83 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CalibratedSculkSensorBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import net.minecraft.world.level.block.state.properties.SculkSensorPhase;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.CalibratedSculkSensor;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCalibratedSculkSensor extends CraftBlockData implements CalibratedSculkSensor {
+    private static final EnumProperty<Direction> FACING = CalibratedSculkSensorBlock.FACING;
+
+    private static final IntegerProperty POWER = CalibratedSculkSensorBlock.POWER;
+
+    private static final EnumProperty<SculkSensorPhase> PHASE = CalibratedSculkSensorBlock.PHASE;
+
+    private static final BooleanProperty WATERLOGGED = CalibratedSculkSensorBlock.WATERLOGGED;
+
+    public CraftCalibratedSculkSensor(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public int getPower() {
+        return this.get(POWER);
+    }
+
+    @Override
+    public void setPower(final int power) {
+        this.set(POWER, power);
+    }
+
+    @Override
+    public int getMaximumPower() {
+        return POWER.max;
+    }
+
+    @Override
+    public org.bukkit.block.data.type.SculkSensor.Phase getSculkSensorPhase() {
+        return this.get(PHASE, org.bukkit.block.data.type.SculkSensor.Phase.class);
+    }
+
+    @Override
+    public void setSculkSensorPhase(final org.bukkit.block.data.type.SculkSensor.Phase phase) {
+        Preconditions.checkArgument(phase != null, "phase cannot be null!");
+        this.set(PHASE, phase);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCampfire.java

@@ -0,0 +1,75 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CampfireBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Campfire;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCampfire extends CraftBlockData implements Campfire {
+    private static final EnumProperty<Direction> FACING = CampfireBlock.FACING;
+
+    private static final BooleanProperty LIT = CampfireBlock.LIT;
+
+    private static final BooleanProperty SIGNAL_FIRE = CampfireBlock.SIGNAL_FIRE;
+
+    private static final BooleanProperty WATERLOGGED = CampfireBlock.WATERLOGGED;
+
+    public CraftCampfire(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+
+    @Override
+    public boolean isSignalFire() {
+        return this.get(SIGNAL_FIRE);
+    }
+
+    @Override
+    public void setSignalFire(final boolean signalFire) {
+        this.set(SIGNAL_FIRE, signalFire);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCandle.java

@@ -0,0 +1,62 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CandleBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Candle;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCandle extends CraftBlockData implements Candle {
+    private static final IntegerProperty CANDLES = CandleBlock.CANDLES;
+
+    private static final BooleanProperty LIT = CandleBlock.LIT;
+
+    private static final BooleanProperty WATERLOGGED = CandleBlock.WATERLOGGED;
+
+    public CraftCandle(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getCandles() {
+        return this.get(CANDLES);
+    }
+
+    @Override
+    public void setCandles(final int candles) {
+        this.set(CANDLES, candles);
+    }
+
+    @Override
+    public int getMinimumCandles() {
+        return CANDLES.min;
+    }
+
+    @Override
+    public int getMaximumCandles() {
+        return CANDLES.max;
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCandleCake.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CandleCakeBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Lightable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCandleCake extends CraftBlockData implements Lightable {
+    private static final BooleanProperty LIT = CandleCakeBlock.LIT;
+
+    public CraftCandleCake(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCarrot.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CarrotBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCarrot extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = CarrotBlock.AGE;
+
+    public CraftCarrot(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCarvedPumpkin.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CarvedPumpkinBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCarvedPumpkin extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = CarvedPumpkinBlock.FACING;
+
+    public CraftCarvedPumpkin(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCaveVines.java

@@ -0,0 +1,45 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CaveVinesBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.CaveVines;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCaveVines extends CraftBlockData implements CaveVines {
+    private static final IntegerProperty AGE = CaveVinesBlock.AGE;
+
+    private static final BooleanProperty BERRIES = CaveVinesBlock.BERRIES;
+
+    public CraftCaveVines(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+
+    @Override
+    public boolean hasBerries() {
+        return this.get(BERRIES);
+    }
+
+    @Override
+    public void setBerries(final boolean berries) {
+        this.set(BERRIES, berries);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCaveVinesPlant.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CaveVinesPlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.CaveVinesPlant;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCaveVinesPlant extends CraftBlockData implements CaveVinesPlant {
+    private static final BooleanProperty BERRIES = CaveVinesPlantBlock.BERRIES;
+
+    public CraftCaveVinesPlant(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasBerries() {
+        return this.get(BERRIES);
+    }
+
+    @Override
+    public void setBerries(final boolean berries) {
+        this.set(BERRIES, berries);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCeilingHangingSign.java

@@ -0,0 +1,60 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CeilingHangingSignBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import net.minecraft.world.level.block.state.properties.RotationSegment;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.HangingSign;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.util.Vector;
+
+@GeneratedFrom("1.21.5")
+public class CraftCeilingHangingSign extends CraftBlockData implements HangingSign {
+    private static final BooleanProperty ATTACHED = CeilingHangingSignBlock.ATTACHED;
+
+    private static final IntegerProperty ROTATION = CeilingHangingSignBlock.ROTATION;
+
+    private static final BooleanProperty WATERLOGGED = CeilingHangingSignBlock.WATERLOGGED;
+
+    public CraftCeilingHangingSign(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isAttached() {
+        return this.get(ATTACHED);
+    }
+
+    @Override
+    public void setAttached(final boolean attached) {
+        this.set(ATTACHED, attached);
+    }
+
+    @Override
+    public BlockFace getRotation() {
+        return CraftBlockData.ROTATION_CYCLE[this.get(ROTATION)];
+    }
+
+    @Override
+    public void setRotation(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace != BlockFace.SELF && blockFace.getModY() == 0, "Invalid face, only horizontal face are allowed for this property!");
+        Vector dir = blockFace.getDirection();
+        float angle = (float) -Math.toDegrees(Math.atan2(dir.getX(), dir.getZ()));
+        this.set(ROTATION, RotationSegment.convertToSegment(angle));
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftChain.java

@@ -0,0 +1,50 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.ChainBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.Axis;
+import org.bukkit.block.data.type.Chain;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftChain extends CraftBlockData implements Chain {
+    private static final EnumProperty<Direction.Axis> AXIS = ChainBlock.AXIS;
+
+    private static final BooleanProperty WATERLOGGED = ChainBlock.WATERLOGGED;
+
+    public CraftChain(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Axis getAxis() {
+        return this.get(AXIS, Axis.class);
+    }
+
+    @Override
+    public void setAxis(final Axis axis) {
+        Preconditions.checkArgument(axis != null, "axis cannot be null!");
+        this.set(AXIS, axis);
+    }
+
+    @Override
+    public Set<Axis> getAxes() {
+        return this.getValues(AXIS, Axis.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftChest.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.ChestType;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Chest;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftChest extends CraftBlockData implements Chest {
+    private static final EnumProperty<Direction> FACING = ChestBlock.FACING;
+
+    private static final EnumProperty<ChestType> TYPE = ChestBlock.TYPE;
+
+    private static final BooleanProperty WATERLOGGED = ChestBlock.WATERLOGGED;
+
+    public CraftChest(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public Chest.Type getType() {
+        return this.get(TYPE, Chest.Type.class);
+    }
+
+    @Override
+    public void setType(final Chest.Type type) {
+        Preconditions.checkArgument(type != null, "type cannot be null!");
+        this.set(TYPE, type);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftChiseledBookShelf.java

@@ -0,0 +1,70 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.List;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.ChiseledBookShelfBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.ChiseledBookshelf;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftChiseledBookShelf extends CraftBlockData implements ChiseledBookshelf {
+    private static final EnumProperty<Direction> HORIZONTAL_FACING = BlockStateProperties.HORIZONTAL_FACING;
+
+    private static final List<BooleanProperty> SLOT_OCCUPIED_PROPERTIES = ChiseledBookShelfBlock.SLOT_OCCUPIED_PROPERTIES;
+
+    public CraftChiseledBookShelf(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(HORIZONTAL_FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(HORIZONTAL_FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(HORIZONTAL_FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isSlotOccupied(final int index) {
+        return this.get(SLOT_OCCUPIED_PROPERTIES.get(index));
+    }
+
+    @Override
+    public void setSlotOccupied(final int index, final boolean slotOccupied) {
+        this.set(SLOT_OCCUPIED_PROPERTIES.get(index), slotOccupied);
+    }
+
+    @Override
+    public Set<Integer> getOccupiedSlots() {
+        ImmutableSet.Builder<Integer> slotOccupieds = ImmutableSet.builder();
+        for (int index = 0, size = SLOT_OCCUPIED_PROPERTIES.size(); index < size; index++) {
+            if (this.get(SLOT_OCCUPIED_PROPERTIES.get(index))) {
+                slotOccupieds.add(index);
+            }
+        }
+        return slotOccupieds.build();
+    }
+
+    @Override
+    public int getMaximumOccupiedSlots() {
+        return SLOT_OCCUPIED_PROPERTIES.size();
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftChorusFlower.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.ChorusFlowerBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftChorusFlower extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = ChorusFlowerBlock.AGE;
+
+    public CraftChorusFlower(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftChorusPlant.java

@@ -0,0 +1,58 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.ChorusPlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.MultipleFacing;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftChorusPlant extends CraftBlockData implements MultipleFacing {
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = ChorusPlantBlock.PROPERTY_BY_DIRECTION.entrySet().stream()
+            .collect(Collectors.toMap(entry -> CraftBlock.notchToBlockFace(entry.getKey()), entry -> entry.getValue()));
+
+    public CraftChorusPlant(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCocoa.java

@@ -0,0 +1,56 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CocoaBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Cocoa;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCocoa extends CraftBlockData implements Cocoa {
+    private static final IntegerProperty AGE = CocoaBlock.AGE;
+
+    private static final EnumProperty<Direction> FACING = CocoaBlock.FACING;
+
+    public CraftCocoa(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCommandBlock.java

@@ -0,0 +1,50 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.CommandBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCommandBlock extends CraftBlockData implements CommandBlock {
+    private static final BooleanProperty CONDITIONAL = net.minecraft.world.level.block.CommandBlock.CONDITIONAL;
+
+    private static final EnumProperty<Direction> FACING = net.minecraft.world.level.block.CommandBlock.FACING;
+
+    public CraftCommandBlock(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isConditional() {
+        return this.get(CONDITIONAL);
+    }
+
+    @Override
+    public void setConditional(final boolean conditional) {
+        this.set(CONDITIONAL, conditional);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftComparator.java

@@ -0,0 +1,65 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.ComparatorBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.ComparatorMode;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Comparator;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftComparator extends CraftBlockData implements Comparator {
+    private static final EnumProperty<Direction> FACING = ComparatorBlock.FACING;
+
+    private static final EnumProperty<ComparatorMode> MODE = ComparatorBlock.MODE;
+
+    private static final BooleanProperty POWERED = ComparatorBlock.POWERED;
+
+    public CraftComparator(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public Comparator.Mode getMode() {
+        return this.get(MODE, Comparator.Mode.class);
+    }
+
+    @Override
+    public void setMode(final Comparator.Mode mode) {
+        Preconditions.checkArgument(mode != null, "mode cannot be null!");
+        this.set(MODE, mode);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftComposter.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.ComposterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Levelled;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftComposter extends CraftBlockData implements Levelled {
+    private static final IntegerProperty LEVEL = ComposterBlock.LEVEL;
+
+    public CraftComposter(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getLevel() {
+        return this.get(LEVEL);
+    }
+
+    @Override
+    public void setLevel(final int level) {
+        this.set(LEVEL, level);
+    }
+
+    @Override
+    public int getMinimumLevel() {
+        return LEVEL.min;
+    }
+
+    @Override
+    public int getMaximumLevel() {
+        return LEVEL.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftConduit.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.ConduitBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftConduit extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = ConduitBlock.WATERLOGGED;
+
+    public CraftConduit(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCopperBulb.java

@@ -0,0 +1,39 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CopperBulbBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.CopperBulb;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCopperBulb extends CraftBlockData implements CopperBulb {
+    private static final BooleanProperty LIT = CopperBulbBlock.LIT;
+
+    private static final BooleanProperty POWERED = CopperBulbBlock.POWERED;
+
+    public CraftCopperBulb(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCoralFan.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CoralFanBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCoralFan extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = CoralFanBlock.WATERLOGGED;
+
+    public CraftCoralFan(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCoralPlant.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CoralPlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCoralPlant extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = CoralPlantBlock.WATERLOGGED;
+
+    public CraftCoralPlant(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCoralWallFan.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CoralWallFanBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.CoralWallFan;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCoralWallFan extends CraftBlockData implements CoralWallFan {
+    private static final EnumProperty<Direction> FACING = CoralWallFanBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = CoralWallFanBlock.WATERLOGGED;
+
+    public CraftCoralWallFan(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCrafter.java

@@ -0,0 +1,56 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.core.FrontAndTop;
+import net.minecraft.world.level.block.CrafterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.data.type.Crafter;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCrafter extends CraftBlockData implements Crafter {
+    private static final BooleanProperty CRAFTING = CrafterBlock.CRAFTING;
+
+    private static final EnumProperty<FrontAndTop> ORIENTATION = BlockStateProperties.ORIENTATION;
+
+    private static final BooleanProperty TRIGGERED = CrafterBlock.TRIGGERED;
+
+    public CraftCrafter(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isCrafting() {
+        return this.get(CRAFTING);
+    }
+
+    @Override
+    public void setCrafting(final boolean crafting) {
+        this.set(CRAFTING, crafting);
+    }
+
+    @Override
+    public org.bukkit.block.Orientation getOrientation() {
+        return this.get(ORIENTATION, org.bukkit.block.Orientation.class);
+    }
+
+    @Override
+    public void setOrientation(final org.bukkit.block.Orientation orientation) {
+        Preconditions.checkArgument(orientation != null, "orientation cannot be null!");
+        this.set(ORIENTATION, orientation);
+    }
+
+    @Override
+    public boolean isTriggered() {
+        return this.get(TRIGGERED);
+    }
+
+    @Override
+    public void setTriggered(final boolean triggered) {
+        this.set(TRIGGERED, triggered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCreakingHeart.java

@@ -0,0 +1,64 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.CreakingHeartBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.CreakingHeartState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.Axis;
+import org.bukkit.block.data.type.CreakingHeart;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCreakingHeart extends CraftBlockData implements CreakingHeart {
+    private static final EnumProperty<Direction.Axis> AXIS = CreakingHeartBlock.AXIS;
+
+    private static final EnumProperty<CreakingHeartState> STATE = CreakingHeartBlock.STATE;
+
+    private static final BooleanProperty NATURAL = CreakingHeartBlock.NATURAL;
+
+    public CraftCreakingHeart(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Axis getAxis() {
+        return this.get(AXIS, Axis.class);
+    }
+
+    @Override
+    public void setAxis(final Axis axis) {
+        Preconditions.checkArgument(axis != null, "axis cannot be null!");
+        this.set(AXIS, axis);
+    }
+
+    @Override
+    public Set<Axis> getAxes() {
+        return this.getValues(AXIS, Axis.class);
+    }
+
+    @Override
+    public CreakingHeart.State getCreakingHeartState() {
+        return this.get(STATE, CreakingHeart.State.class);
+    }
+
+    @Override
+    public void setCreakingHeartState(final CreakingHeart.State state) {
+        Preconditions.checkArgument(state != null, "state cannot be null!");
+        this.set(STATE, state);
+    }
+
+    @Override
+    public boolean isNatural() {
+        return this.get(NATURAL);
+    }
+
+    @Override
+    public void setNatural(final boolean natural) {
+        this.set(NATURAL, natural);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftCrop.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.CropBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftCrop extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = CropBlock.AGE;
+
+    public CraftCrop(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDaylightDetector.java

@@ -0,0 +1,45 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.DaylightDetectorBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.DaylightDetector;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDaylightDetector extends CraftBlockData implements DaylightDetector {
+    private static final BooleanProperty INVERTED = DaylightDetectorBlock.INVERTED;
+
+    private static final IntegerProperty POWER = DaylightDetectorBlock.POWER;
+
+    public CraftDaylightDetector(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isInverted() {
+        return this.get(INVERTED);
+    }
+
+    @Override
+    public void setInverted(final boolean inverted) {
+        this.set(INVERTED, inverted);
+    }
+
+    @Override
+    public int getPower() {
+        return this.get(POWER);
+    }
+
+    @Override
+    public void setPower(final int power) {
+        this.set(POWER, power);
+    }
+
+    @Override
+    public int getMaximumPower() {
+        return POWER.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDecoratedPot.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.DecoratedPotBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.DecoratedPot;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDecoratedPot extends CraftBlockData implements DecoratedPot {
+    private static final BooleanProperty CRACKED = DecoratedPotBlock.CRACKED;
+
+    private static final EnumProperty<Direction> HORIZONTAL_FACING = DecoratedPotBlock.HORIZONTAL_FACING;
+
+    private static final BooleanProperty WATERLOGGED = DecoratedPotBlock.WATERLOGGED;
+
+    public CraftDecoratedPot(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isCracked() {
+        return this.get(CRACKED);
+    }
+
+    @Override
+    public void setCracked(final boolean cracked) {
+        this.set(CRACKED, cracked);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(HORIZONTAL_FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(HORIZONTAL_FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(HORIZONTAL_FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDetectorRail.java

@@ -0,0 +1,62 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.world.level.block.DetectorRailBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.RailShape;
+import org.bukkit.block.data.type.RedstoneRail;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDetectorRail extends CraftBlockData implements RedstoneRail {
+    private static final BooleanProperty POWERED = DetectorRailBlock.POWERED;
+
+    private static final EnumProperty<RailShape> SHAPE = DetectorRailBlock.SHAPE;
+
+    private static final BooleanProperty WATERLOGGED = DetectorRailBlock.WATERLOGGED;
+
+    public CraftDetectorRail(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+
+    @Override
+    public org.bukkit.block.data.Rail.Shape getShape() {
+        return this.get(SHAPE, org.bukkit.block.data.Rail.Shape.class);
+    }
+
+    @Override
+    public void setShape(final org.bukkit.block.data.Rail.Shape shape) {
+        Preconditions.checkArgument(shape != null, "shape cannot be null!");
+        Preconditions.checkArgument(shape != org.bukkit.block.data.Rail.Shape.NORTH_EAST && shape != org.bukkit.block.data.Rail.Shape.NORTH_WEST && shape != org.bukkit.block.data.Rail.Shape.SOUTH_EAST && shape != org.bukkit.block.data.Rail.Shape.SOUTH_WEST, "Invalid rail shape, only straight rail are allowed for this property!");
+        this.set(SHAPE, shape);
+    }
+
+    @Override
+    public Set<org.bukkit.block.data.Rail.Shape> getShapes() {
+        return this.getValues(SHAPE, org.bukkit.block.data.Rail.Shape.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDispenser.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.DispenserBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDispenser extends CraftBlockData implements Dispenser {
+    private static final EnumProperty<Direction> FACING = DispenserBlock.FACING;
+
+    private static final BooleanProperty TRIGGERED = DispenserBlock.TRIGGERED;
+
+    public CraftDispenser(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isTriggered() {
+        return this.get(TRIGGERED);
+    }
+
+    @Override
+    public void setTriggered(final boolean triggered) {
+        this.set(TRIGGERED, triggered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDoor.java

@@ -0,0 +1,91 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.DoorBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.DoorHingeSide;
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Door;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDoor extends CraftBlockData implements Door {
+    private static final EnumProperty<Direction> FACING = DoorBlock.FACING;
+
+    private static final EnumProperty<DoubleBlockHalf> HALF = DoorBlock.HALF;
+
+    private static final EnumProperty<DoorHingeSide> HINGE = DoorBlock.HINGE;
+
+    private static final BooleanProperty OPEN = DoorBlock.OPEN;
+
+    private static final BooleanProperty POWERED = DoorBlock.POWERED;
+
+    public CraftDoor(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public org.bukkit.block.data.Bisected.Half getHalf() {
+        return this.get(HALF, org.bukkit.block.data.Bisected.Half.class);
+    }
+
+    @Override
+    public void setHalf(final org.bukkit.block.data.Bisected.Half half) {
+        Preconditions.checkArgument(half != null, "half cannot be null!");
+        this.set(HALF, half);
+    }
+
+    @Override
+    public Door.Hinge getHinge() {
+        return this.get(HINGE, Door.Hinge.class);
+    }
+
+    @Override
+    public void setHinge(final Door.Hinge hinge) {
+        Preconditions.checkArgument(hinge != null, "hinge cannot be null!");
+        this.set(HINGE, hinge);
+    }
+
+    @Override
+    public boolean isOpen() {
+        return this.get(OPEN);
+    }
+
+    @Override
+    public void setOpen(final boolean open) {
+        this.set(OPEN, open);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDoublePlant.java

@@ -0,0 +1,30 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.DoublePlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.data.Bisected;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDoublePlant extends CraftBlockData implements Bisected {
+    private static final EnumProperty<DoubleBlockHalf> HALF = DoublePlantBlock.HALF;
+
+    public CraftDoublePlant(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Bisected.Half getHalf() {
+        return this.get(HALF, Bisected.Half.class);
+    }
+
+    @Override
+    public void setHalf(final Bisected.Half half) {
+        Preconditions.checkArgument(half != null, "half cannot be null!");
+        this.set(HALF, half);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftDropper.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.DropperBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftDropper extends CraftBlockData implements Dispenser {
+    private static final EnumProperty<Direction> FACING = DropperBlock.FACING;
+
+    private static final BooleanProperty TRIGGERED = DropperBlock.TRIGGERED;
+
+    public CraftDropper(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isTriggered() {
+        return this.get(TRIGGERED);
+    }
+
+    @Override
+    public void setTriggered(final boolean triggered) {
+        this.set(TRIGGERED, triggered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftEndPortalFrame.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.EndPortalFrameBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.EndPortalFrame;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftEndPortalFrame extends CraftBlockData implements EndPortalFrame {
+    private static final BooleanProperty HAS_EYE = EndPortalFrameBlock.HAS_EYE;
+
+    private static final EnumProperty<Direction> FACING = EndPortalFrameBlock.FACING;
+
+    public CraftEndPortalFrame(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasEye() {
+        return this.get(HAS_EYE);
+    }
+
+    @Override
+    public void setEye(final boolean eye) {
+        this.set(HAS_EYE, eye);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftEndRod.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.EndRodBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftEndRod extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = EndRodBlock.FACING;
+
+    public CraftEndRod(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftEnderChest.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.EnderChestBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.EnderChest;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftEnderChest extends CraftBlockData implements EnderChest {
+    private static final EnumProperty<Direction> FACING = EnderChestBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = EnderChestBlock.WATERLOGGED;
+
+    public CraftEnderChest(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFarm.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.FarmBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Farmland;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFarm extends CraftBlockData implements Farmland {
+    private static final IntegerProperty MOISTURE = FarmBlock.MOISTURE;
+
+    public CraftFarm(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getMoisture() {
+        return this.get(MOISTURE);
+    }
+
+    @Override
+    public void setMoisture(final int moisture) {
+        this.set(MOISTURE, moisture);
+    }
+
+    @Override
+    public int getMaximumMoisture() {
+        return MOISTURE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFence.java

@@ -0,0 +1,70 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.FenceBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Fence;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFence extends CraftBlockData implements Fence {
+    private static final BooleanProperty WATERLOGGED = FenceBlock.WATERLOGGED;
+
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = FenceBlock.PROPERTY_BY_DIRECTION.entrySet().stream()
+            .collect(Collectors.toMap(entry -> CraftBlock.notchToBlockFace(entry.getKey()), entry -> entry.getValue()));
+
+    public CraftFence(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFenceGate.java

@@ -0,0 +1,75 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.FenceGateBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Gate;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFenceGate extends CraftBlockData implements Gate {
+    private static final EnumProperty<Direction> FACING = FenceGateBlock.FACING;
+
+    private static final BooleanProperty IN_WALL = FenceGateBlock.IN_WALL;
+
+    private static final BooleanProperty OPEN = FenceGateBlock.OPEN;
+
+    private static final BooleanProperty POWERED = FenceGateBlock.POWERED;
+
+    public CraftFenceGate(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isInWall() {
+        return this.get(IN_WALL);
+    }
+
+    @Override
+    public void setInWall(final boolean inWall) {
+        this.set(IN_WALL, inWall);
+    }
+
+    @Override
+    public boolean isOpen() {
+        return this.get(OPEN);
+    }
+
+    @Override
+    public void setOpen(final boolean open) {
+        this.set(OPEN, open);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFire.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.FireBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Fire;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFire extends CraftBlockData implements Fire {
+    private static final IntegerProperty AGE = FireBlock.AGE;
+
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = FireBlock.PROPERTY_BY_DIRECTION.entrySet().stream()
+            .collect(Collectors.toMap(entry -> CraftBlock.notchToBlockFace(entry.getKey()), entry -> entry.getValue()));
+
+    public CraftFire(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFlowerBed.java

@@ -0,0 +1,61 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.FlowerBedBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.FlowerBed;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFlowerBed extends CraftBlockData implements FlowerBed {
+    private static final EnumProperty<Direction> FACING = FlowerBedBlock.FACING;
+
+    private static final IntegerProperty AMOUNT = FlowerBedBlock.AMOUNT;
+
+    public CraftFlowerBed(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public int getFlowerAmount() {
+        return this.get(AMOUNT);
+    }
+
+    @Override
+    public void setFlowerAmount(final int flowerAmount) {
+        this.set(AMOUNT, flowerAmount);
+    }
+
+    @Override
+    public int getMinimumFlowerAmount() {
+        return AMOUNT.min;
+    }
+
+    @Override
+    public int getMaximumFlowerAmount() {
+        return AMOUNT.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFrostedIce.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.FrostedIceBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFrostedIce extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = FrostedIceBlock.AGE;
+
+    public CraftFrostedIce(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftFurnace.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.FurnaceBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Furnace;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftFurnace extends CraftBlockData implements Furnace {
+    private static final EnumProperty<Direction> FACING = FurnaceBlock.FACING;
+
+    private static final BooleanProperty LIT = FurnaceBlock.LIT;
+
+    public CraftFurnace(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isLit() {
+        return this.get(LIT);
+    }
+
+    @Override
+    public void setLit(final boolean lit) {
+        this.set(LIT, lit);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftGlazedTerracotta.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.GlazedTerracottaBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftGlazedTerracotta extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = GlazedTerracottaBlock.FACING;
+
+    public CraftGlazedTerracotta(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftGlowLichen.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.GlowLichenBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.GlowLichen;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftGlowLichen extends CraftBlockData implements GlowLichen {
+    private static final BooleanProperty WATERLOGGED = GlowLichenBlock.WATERLOGGED;
+
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = Map.of(
+        BlockFace.DOWN, BlockStateProperties.DOWN,
+        BlockFace.UP, BlockStateProperties.UP,
+        BlockFace.NORTH, BlockStateProperties.NORTH,
+        BlockFace.SOUTH, BlockStateProperties.SOUTH,
+        BlockFace.WEST, BlockStateProperties.WEST,
+        BlockFace.EAST, BlockStateProperties.EAST
+    );
+
+    public CraftGlowLichen(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftGrass.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.GrassBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Snowable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftGrass extends CraftBlockData implements Snowable {
+    private static final BooleanProperty SNOWY = GrassBlock.SNOWY;
+
+    public CraftGrass(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isSnowy() {
+        return this.get(SNOWY);
+    }
+
+    @Override
+    public void setSnowy(final boolean snowy) {
+        this.set(SNOWY, snowy);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftGrindstone.java

@@ -0,0 +1,53 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.GrindstoneBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.AttachFace;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Grindstone;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftGrindstone extends CraftBlockData implements Grindstone {
+    private static final EnumProperty<AttachFace> FACE = GrindstoneBlock.FACE;
+
+    private static final EnumProperty<Direction> FACING = GrindstoneBlock.FACING;
+
+    public CraftGrindstone(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public org.bukkit.block.data.FaceAttachable.AttachedFace getAttachedFace() {
+        return this.get(FACE, org.bukkit.block.data.FaceAttachable.AttachedFace.class);
+    }
+
+    @Override
+    public void setAttachedFace(
+            final org.bukkit.block.data.FaceAttachable.AttachedFace attachedFace) {
+        Preconditions.checkArgument(attachedFace != null, "attachedFace cannot be null!");
+        this.set(FACE, attachedFace);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHangingMoss.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.HangingMossBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.HangingMoss;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHangingMoss extends CraftBlockData implements HangingMoss {
+    private static final BooleanProperty TIP = HangingMossBlock.TIP;
+
+    public CraftHangingMoss(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isTip() {
+        return this.get(TIP);
+    }
+
+    @Override
+    public void setTip(final boolean tip) {
+        this.set(TIP, tip);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHangingRoots.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHangingRoots extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;
+
+    public CraftHangingRoots(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHay.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.HayBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.Axis;
+import org.bukkit.block.data.Orientable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHay extends CraftBlockData implements Orientable {
+    private static final EnumProperty<Direction.Axis> AXIS = HayBlock.AXIS;
+
+    public CraftHay(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Axis getAxis() {
+        return this.get(AXIS, Axis.class);
+    }
+
+    @Override
+    public void setAxis(final Axis axis) {
+        Preconditions.checkArgument(axis != null, "axis cannot be null!");
+        this.set(AXIS, axis);
+    }
+
+    @Override
+    public Set<Axis> getAxes() {
+        return this.getValues(AXIS, Axis.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHeavyCore.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.HeavyCoreBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHeavyCore extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = HeavyCoreBlock.WATERLOGGED;
+
+    public CraftHeavyCore(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHopper.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.HopperBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Hopper;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHopper extends CraftBlockData implements Hopper {
+    private static final BooleanProperty ENABLED = HopperBlock.ENABLED;
+
+    private static final EnumProperty<Direction> FACING = HopperBlock.FACING;
+
+    public CraftHopper(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return this.get(ENABLED);
+    }
+
+    @Override
+    public void setEnabled(final boolean enabled) {
+        this.set(ENABLED, enabled);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace != BlockFace.UP, "Invalid face, only cartesian face (excluding UP) are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftHugeMushroom.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.HugeMushroomBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.MultipleFacing;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftHugeMushroom extends CraftBlockData implements MultipleFacing {
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = Map.of(
+        BlockFace.DOWN, HugeMushroomBlock.DOWN,
+        BlockFace.UP, HugeMushroomBlock.UP,
+        BlockFace.NORTH, HugeMushroomBlock.NORTH,
+        BlockFace.SOUTH, HugeMushroomBlock.SOUTH,
+        BlockFace.WEST, HugeMushroomBlock.WEST,
+        BlockFace.EAST, HugeMushroomBlock.EAST
+    );
+
+    public CraftHugeMushroom(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftInfestedRotatedPillar.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.Axis;
+import org.bukkit.block.data.Orientable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftInfestedRotatedPillar extends CraftBlockData implements Orientable {
+    private static final EnumProperty<Direction.Axis> AXIS = BlockStateProperties.AXIS;
+
+    public CraftInfestedRotatedPillar(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Axis getAxis() {
+        return this.get(AXIS, Axis.class);
+    }
+
+    @Override
+    public void setAxis(final Axis axis) {
+        Preconditions.checkArgument(axis != null, "axis cannot be null!");
+        this.set(AXIS, axis);
+    }
+
+    @Override
+    public Set<Axis> getAxes() {
+        return this.getValues(AXIS, Axis.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftIronBars.java

@@ -0,0 +1,70 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.IronBarsBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Fence;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftIronBars extends CraftBlockData implements Fence {
+    private static final BooleanProperty WATERLOGGED = IronBarsBlock.WATERLOGGED;
+
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = IronBarsBlock.PROPERTY_BY_DIRECTION.entrySet().stream()
+            .collect(Collectors.toMap(entry -> CraftBlock.notchToBlockFace(entry.getKey()), entry -> entry.getValue()));
+
+    public CraftIronBars(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftJigsaw.java

@@ -0,0 +1,30 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.core.FrontAndTop;
+import net.minecraft.world.level.block.JigsawBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.data.type.Jigsaw;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftJigsaw extends CraftBlockData implements Jigsaw {
+    private static final EnumProperty<FrontAndTop> ORIENTATION = JigsawBlock.ORIENTATION;
+
+    public CraftJigsaw(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public org.bukkit.block.Orientation getOrientation() {
+        return this.get(ORIENTATION, org.bukkit.block.Orientation.class);
+    }
+
+    @Override
+    public void setOrientation(final org.bukkit.block.Orientation orientation) {
+        Preconditions.checkArgument(orientation != null, "orientation cannot be null!");
+        this.set(ORIENTATION, orientation);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftJukebox.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.JukeboxBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.Jukebox;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftJukebox extends CraftBlockData implements Jukebox {
+    private static final BooleanProperty HAS_RECORD = JukeboxBlock.HAS_RECORD;
+
+    public CraftJukebox(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean hasRecord() {
+        return this.get(HAS_RECORD);
+    }
+
+    @Override
+    public void setHasRecord(final boolean hasRecord) {
+        this.set(HAS_RECORD, hasRecord);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftKelp.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.KelpBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftKelp extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = KelpBlock.AGE;
+
+    public CraftKelp(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLadder.java

@@ -0,0 +1,51 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LadderBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Ladder;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLadder extends CraftBlockData implements Ladder {
+    private static final EnumProperty<Direction> FACING = LadderBlock.FACING;
+
+    private static final BooleanProperty WATERLOGGED = LadderBlock.WATERLOGGED;
+
+    public CraftLadder(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLantern.java

@@ -0,0 +1,39 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.LanternBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.type.Lantern;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLantern extends CraftBlockData implements Lantern {
+    private static final BooleanProperty HANGING = LanternBlock.HANGING;
+
+    private static final BooleanProperty WATERLOGGED = LanternBlock.WATERLOGGED;
+
+    public CraftLantern(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isHanging() {
+        return this.get(HANGING);
+    }
+
+    @Override
+    public void setHanging(final boolean hanging) {
+        this.set(HANGING, hanging);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLayeredCauldron.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.LayeredCauldronBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Levelled;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLayeredCauldron extends CraftBlockData implements Levelled {
+    private static final IntegerProperty LEVEL = LayeredCauldronBlock.LEVEL;
+
+    public CraftLayeredCauldron(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getLevel() {
+        return this.get(LEVEL);
+    }
+
+    @Override
+    public void setLevel(final int level) {
+        this.set(LEVEL, level);
+    }
+
+    @Override
+    public int getMinimumLevel() {
+        return LEVEL.min;
+    }
+
+    @Override
+    public int getMaximumLevel() {
+        return LEVEL.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLeafLitter.java

@@ -0,0 +1,61 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LeafLitterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.LeafLitter;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLeafLitter extends CraftBlockData implements LeafLitter {
+    private static final EnumProperty<Direction> FACING = LeafLitterBlock.FACING;
+
+    private static final IntegerProperty AMOUNT = LeafLitterBlock.AMOUNT;
+
+    public CraftLeafLitter(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public int getSegmentAmount() {
+        return this.get(AMOUNT);
+    }
+
+    @Override
+    public void setSegmentAmount(final int segmentAmount) {
+        this.set(AMOUNT, segmentAmount);
+    }
+
+    @Override
+    public int getMinimumSegmentAmount() {
+        return AMOUNT.min;
+    }
+
+    @Override
+    public int getMaximumSegmentAmount() {
+        return AMOUNT.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLectern.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LecternBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Lectern;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLectern extends CraftBlockData implements Lectern {
+    private static final EnumProperty<Direction> FACING = LecternBlock.FACING;
+
+    private static final BooleanProperty HAS_BOOK = LecternBlock.HAS_BOOK;
+
+    private static final BooleanProperty POWERED = LecternBlock.POWERED;
+
+    public CraftLectern(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean hasBook() {
+        return this.get(HAS_BOOK);
+    }
+
+    @Override
+    public void setHasBook(final boolean hasBook) {
+        this.set(HAS_BOOK, hasBook);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLever.java

@@ -0,0 +1,66 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LeverBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.AttachFace;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Switch;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLever extends CraftBlockData implements Switch {
+    private static final EnumProperty<AttachFace> FACE = LeverBlock.FACE;
+
+    private static final EnumProperty<Direction> FACING = LeverBlock.FACING;
+
+    private static final BooleanProperty POWERED = LeverBlock.POWERED;
+
+    public CraftLever(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public org.bukkit.block.data.FaceAttachable.AttachedFace getAttachedFace() {
+        return this.get(FACE, org.bukkit.block.data.FaceAttachable.AttachedFace.class);
+    }
+
+    @Override
+    public void setAttachedFace(
+            final org.bukkit.block.data.FaceAttachable.AttachedFace attachedFace) {
+        Preconditions.checkArgument(attachedFace != null, "attachedFace cannot be null!");
+        this.set(FACE, attachedFace);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLight.java

@@ -0,0 +1,50 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.LightBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Light;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLight extends CraftBlockData implements Light {
+    private static final IntegerProperty LEVEL = LightBlock.LEVEL;
+
+    private static final BooleanProperty WATERLOGGED = LightBlock.WATERLOGGED;
+
+    public CraftLight(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getLevel() {
+        return this.get(LEVEL);
+    }
+
+    @Override
+    public void setLevel(final int level) {
+        this.set(LEVEL, level);
+    }
+
+    @Override
+    public int getMinimumLevel() {
+        return LEVEL.min;
+    }
+
+    @Override
+    public int getMaximumLevel() {
+        return LEVEL.max;
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLightningRod.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LightningRodBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.LightningRod;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLightningRod extends CraftBlockData implements LightningRod {
+    private static final EnumProperty<Direction> FACING = LightningRodBlock.FACING;
+
+    private static final BooleanProperty POWERED = LightningRodBlock.POWERED;
+
+    private static final BooleanProperty WATERLOGGED = LightningRodBlock.WATERLOGGED;
+
+    public CraftLightningRod(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public boolean isPowered() {
+        return this.get(POWERED);
+    }
+
+    @Override
+    public void setPowered(final boolean powered) {
+        this.set(POWERED, powered);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLiquid.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Levelled;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLiquid extends CraftBlockData implements Levelled {
+    private static final IntegerProperty LEVEL = LiquidBlock.LEVEL;
+
+    public CraftLiquid(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getLevel() {
+        return this.get(LEVEL);
+    }
+
+    @Override
+    public void setLevel(final int level) {
+        this.set(LEVEL, level);
+    }
+
+    @Override
+    public int getMinimumLevel() {
+        return LEVEL.min;
+    }
+
+    @Override
+    public int getMaximumLevel() {
+        return LEVEL.max;
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftLoom.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.LoomBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Directional;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftLoom extends CraftBlockData implements Directional {
+    private static final EnumProperty<Direction> FACING = LoomBlock.FACING;
+
+    public CraftLoom(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian() && blockFace.getModY() == 0, "Invalid face, only cartesian horizontal face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMangroveLeaves.java

@@ -0,0 +1,62 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.MangroveLeavesBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.Leaves;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMangroveLeaves extends CraftBlockData implements Leaves {
+    private static final IntegerProperty DISTANCE = MangroveLeavesBlock.DISTANCE;
+
+    private static final BooleanProperty PERSISTENT = MangroveLeavesBlock.PERSISTENT;
+
+    private static final BooleanProperty WATERLOGGED = MangroveLeavesBlock.WATERLOGGED;
+
+    public CraftMangroveLeaves(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getDistance() {
+        return this.get(DISTANCE);
+    }
+
+    @Override
+    public void setDistance(final int distance) {
+        this.set(DISTANCE, distance);
+    }
+
+    @Override
+    public int getMinimumDistance() {
+        return DISTANCE.min;
+    }
+
+    @Override
+    public int getMaximumDistance() {
+        return DISTANCE.max;
+    }
+
+    @Override
+    public boolean isPersistent() {
+        return this.get(PERSISTENT);
+    }
+
+    @Override
+    public void setPersistent(final boolean persistent) {
+        this.set(PERSISTENT, persistent);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMangrovePropagule.java

@@ -0,0 +1,75 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.MangrovePropaguleBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.type.MangrovePropagule;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMangrovePropagule extends CraftBlockData implements MangrovePropagule {
+    private static final IntegerProperty AGE = MangrovePropaguleBlock.AGE;
+
+    private static final BooleanProperty HANGING = MangrovePropaguleBlock.HANGING;
+
+    private static final IntegerProperty STAGE = MangrovePropaguleBlock.STAGE;
+
+    private static final BooleanProperty WATERLOGGED = BlockStateProperties.WATERLOGGED;
+
+    public CraftMangrovePropagule(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+
+    @Override
+    public boolean isHanging() {
+        return this.get(HANGING);
+    }
+
+    @Override
+    public void setHanging(final boolean hanging) {
+        this.set(HANGING, hanging);
+    }
+
+    @Override
+    public int getStage() {
+        return this.get(STAGE);
+    }
+
+    @Override
+    public void setStage(final int stage) {
+        this.set(STAGE, stage);
+    }
+
+    @Override
+    public int getMaximumStage() {
+        return STAGE.max;
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMangroveRoots.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.MangroveRootsBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMangroveRoots extends CraftBlockData implements Waterlogged {
+    private static final BooleanProperty WATERLOGGED = MangroveRootsBlock.WATERLOGGED;
+
+    public CraftMangroveRoots(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMossyCarpet.java

@@ -0,0 +1,55 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Map;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.MossyCarpetBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.WallSide;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.MossyCarpet;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMossyCarpet extends CraftBlockData implements MossyCarpet {
+    private static final BooleanProperty BASE = MossyCarpetBlock.BASE;
+
+    private static final Map<BlockFace, EnumProperty<WallSide>> PROPERTY_BY_DIRECTION = MossyCarpetBlock.PROPERTY_BY_DIRECTION.entrySet().stream()
+            .collect(Collectors.toMap(entry -> CraftBlock.notchToBlockFace(entry.getKey()), entry -> entry.getValue()));
+
+    public CraftMossyCarpet(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isBottom() {
+        return this.get(BASE);
+    }
+
+    @Override
+    public void setBottom(final boolean bottom) {
+        this.set(BASE, bottom);
+    }
+
+    @Override
+    public org.bukkit.block.data.type.Wall.Height getHeight(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        EnumProperty<WallSide> property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property, org.bukkit.block.data.type.Wall.Height.class);
+    }
+
+    @Override
+    public void setHeight(final BlockFace blockFace,
+            final org.bukkit.block.data.type.Wall.Height height) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(height != null, "height cannot be null!");
+        EnumProperty<WallSide> property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, height);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMovingPiston.java

@@ -0,0 +1,52 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.piston.MovingPistonBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.PistonType;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.TechnicalPiston;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMovingPiston extends CraftBlockData implements TechnicalPiston {
+    private static final EnumProperty<Direction> FACING = MovingPistonBlock.FACING;
+
+    private static final EnumProperty<PistonType> TYPE = MovingPistonBlock.TYPE;
+
+    public CraftMovingPiston(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return this.get(FACING, BlockFace.class);
+    }
+
+    @Override
+    public void setFacing(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        Preconditions.checkArgument(blockFace.isCartesian(), "Invalid face, only cartesian face are allowed for this property!");
+        this.set(FACING, blockFace);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        return this.getValues(FACING, BlockFace.class);
+    }
+
+    @Override
+    public TechnicalPiston.Type getType() {
+        return this.get(TYPE, TechnicalPiston.Type.class);
+    }
+
+    @Override
+    public void setType(final TechnicalPiston.Type type) {
+        Preconditions.checkArgument(type != null, "type cannot be null!");
+        this.set(TYPE, type);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMultiface.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import net.minecraft.world.level.block.MultifaceBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.ResinClump;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMultiface extends CraftBlockData implements ResinClump {
+    private static final BooleanProperty WATERLOGGED = MultifaceBlock.WATERLOGGED;
+
+    private static final Map<BlockFace, BooleanProperty> PROPERTY_BY_DIRECTION = Map.of(
+        BlockFace.DOWN, BlockStateProperties.DOWN,
+        BlockFace.UP, BlockStateProperties.UP,
+        BlockFace.NORTH, BlockStateProperties.NORTH,
+        BlockFace.SOUTH, BlockStateProperties.SOUTH,
+        BlockFace.WEST, BlockStateProperties.WEST,
+        BlockFace.EAST, BlockStateProperties.EAST
+    );
+
+    public CraftMultiface(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return this.get(WATERLOGGED);
+    }
+
+    @Override
+    public void setWaterlogged(final boolean waterlogged) {
+        this.set(WATERLOGGED, waterlogged);
+    }
+
+    @Override
+    public boolean hasFace(final BlockFace blockFace) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        return this.get(property);
+    }
+
+    @Override
+    public void setFace(final BlockFace blockFace, final boolean face) {
+        Preconditions.checkArgument(blockFace != null, "blockFace cannot be null!");
+        BooleanProperty property = PROPERTY_BY_DIRECTION.get(blockFace);
+        Preconditions.checkArgument(property != null, "Invalid blockFace, only %s are allowed!", PROPERTY_BY_DIRECTION.keySet().stream().map(Enum::name).collect(Collectors.joining(", ")));
+        this.set(property, face);
+    }
+
+    @Override
+    public Set<BlockFace> getFaces() {
+        ImmutableSet.Builder<BlockFace> faces = ImmutableSet.builder();
+        for (Map.Entry<BlockFace, BooleanProperty> entry : PROPERTY_BY_DIRECTION.entrySet()) {
+            if (this.get(entry.getValue())) {
+                faces.add(entry.getKey());
+            }
+        }
+        return faces.build();
+    }
+
+    @Override
+    public Set<BlockFace> getAllowedFaces() {
+        return Collections.unmodifiableSet(PROPERTY_BY_DIRECTION.keySet());
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftMycelium.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.MyceliumBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import org.bukkit.block.data.Snowable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftMycelium extends CraftBlockData implements Snowable {
+    private static final BooleanProperty SNOWY = MyceliumBlock.SNOWY;
+
+    public CraftMycelium(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public boolean isSnowy() {
+        return this.get(SNOWY);
+    }
+
+    @Override
+    public void setSnowy(final boolean snowy) {
+        this.set(SNOWY, snowy);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftNetherPortal.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import com.google.common.base.Preconditions;
+import io.papermc.paper.generated.GeneratedFrom;
+import java.util.Set;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.NetherPortalBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import org.bukkit.Axis;
+import org.bukkit.block.data.Orientable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftNetherPortal extends CraftBlockData implements Orientable {
+    private static final EnumProperty<Direction.Axis> AXIS = NetherPortalBlock.AXIS;
+
+    public CraftNetherPortal(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public Axis getAxis() {
+        return this.get(AXIS, Axis.class);
+    }
+
+    @Override
+    public void setAxis(final Axis axis) {
+        Preconditions.checkArgument(axis != null, "axis cannot be null!");
+        Preconditions.checkArgument(axis == Axis.X || axis == Axis.Z, "Invalid axis, only horizontal axis are allowed for this property!");
+        this.set(AXIS, axis);
+    }
+
+    @Override
+    public Set<Axis> getAxes() {
+        return this.getValues(AXIS, Axis.class);
+    }
+}

paper-server/src/generated/java/org/bukkit/craftbukkit/block/impl/CraftNetherWart.java

@@ -0,0 +1,32 @@
+package org.bukkit.craftbukkit.block.impl;
+
+import io.papermc.paper.generated.GeneratedFrom;
+import net.minecraft.world.level.block.NetherWartBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+
+@GeneratedFrom("1.21.5")
+public class CraftNetherWart extends CraftBlockData implements Ageable {
+    private static final IntegerProperty AGE = NetherWartBlock.AGE;
+
+    public CraftNetherWart(BlockState state) {
+        super(state);
+    }
+
+    @Override
+    public int getAge() {
+        return this.get(AGE);
+    }
+
+    @Override
+    public void setAge(final int age) {
+        this.set(AGE, age);
+    }
+
+    @Override
+    public int getMaximumAge() {
+        return AGE.max;
+    }
+}