diff --git a/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventFactory.java b/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventFactory.java
index 5c3f408..e12de0f 100644
--- a/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventFactory.java
+++ b/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventFactory.java
@@ -3,36 +3,19 @@ package org.patchbukkit.events;
 import com.google.protobuf.InvalidProtocolBufferException;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
-import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
 import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import patchbukkit.common.UUID;
-import patchbukkit.events.BlockBreakEvent;
-import patchbukkit.events.BlockDamageEvent;
-import patchbukkit.events.BlockPlaceEvent;
-import patchbukkit.events.Event;
-import patchbukkit.events.FireEventResponse;
-import patchbukkit.events.PlayerChatEvent;
-import patchbukkit.events.PlayerGameModeChangeEvent;
-import patchbukkit.events.PlayerInteractEvent;
-import patchbukkit.events.PlayerJoinEvent;
-import patchbukkit.events.PlayerInteractEntityEvent;
-import patchbukkit.events.PlayerMoveEvent;
-import patchbukkit.events.PlayerQuitEvent;
-import patchbukkit.events.PlayerToggleFlightEvent;
-import patchbukkit.events.PlayerToggleSneakEvent;
-import patchbukkit.events.PlayerToggleSprintEvent;
-import patchbukkit.events.PluginDisableEvent;
-import patchbukkit.events.PluginEnableEvent;
-import patchbukkit.events.BlockFadeEvent;
-import patchbukkit.events.BlockFormEvent;
-import patchbukkit.events.BlockGrowEvent;
-import patchbukkit.events.BlockIgniteEvent;
-import patchbukkit.events.ServerCommandEvent;
-import patchbukkit.events.SignChangeEvent;
+import patchbukkit.events.*;
 
+import java.lang.reflect.Constructor;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -67,216 +50,1139 @@ public class PatchBukkitEventFactory {
             Event.DataCase dataCase = event.getDataCase();
 
             return switch (dataCase) {
-            case PLAYER_JOIN -> {
-                PlayerJoinEvent joinEvent = event.getPlayerJoin();
-                Player player = getPlayer(joinEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-
-                Component joinMessage = GsonComponentSerializer.gson().deserialize(joinEvent.getJoinMessage());
-                yield new org.bukkit.event.player.PlayerJoinEvent(player, joinMessage);
+            case ASYNC_STRUCTURE_GENERATE -> {
+                var ev = event.getAsyncStructureGenerate();
+                yield createGenericBukkitEvent("org.bukkit.event.world.AsyncStructureGenerateEvent", ev);
             }
-            case PLAYER_QUIT -> {
-                PlayerQuitEvent quitEvent = event.getPlayerQuit();
-                Player player = getPlayer(quitEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-
-                Component quitMessage = quitEvent.getQuitMessage().isEmpty() ? Component.empty() : GsonComponentSerializer.gson().deserialize(quitEvent.getQuitMessage());
-                yield new org.bukkit.event.player.PlayerQuitEvent(player, quitMessage);
+            case ASYNC_STRUCTURE_SPAWN -> {
+                var ev = event.getAsyncStructureSpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.world.AsyncStructureSpawnEvent", ev);
             }
-            case PLAYER_GAMEMODE_CHANGE -> {
-                PlayerGameModeChangeEvent gmEvent = event.getPlayerGamemodeChange();
-                Player player = getPlayer(gmEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-
-                org.bukkit.GameMode newGamemode;
-                try {
-                    newGamemode = org.bukkit.GameMode.valueOf(gmEvent.getNewGamemode().toUpperCase());
-                } catch (IllegalArgumentException e) {
-                    newGamemode = org.bukkit.GameMode.SURVIVAL;
-                }
-                yield new org.bukkit.event.player.PlayerGameModeChangeEvent(player, newGamemode);
+            case CHUNK_LOAD -> {
+                var ev = event.getChunkLoad();
+                yield createGenericBukkitEvent("org.bukkit.event.world.ChunkLoadEvent", ev);
             }
-            case PLAYER_INTERACT -> {
-                PlayerInteractEvent interactEvent = event.getPlayerInteract();
-                Player player = getPlayer(interactEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-
-                org.bukkit.event.block.Action action;
-                try {
-                    action = org.bukkit.event.block.Action.valueOf(interactEvent.getAction());
-                } catch (IllegalArgumentException e) {
-                    action = org.bukkit.event.block.Action.RIGHT_CLICK_AIR;
-                }
-
-                org.bukkit.inventory.EquipmentSlot hand;
-                try {
-                    hand = org.bukkit.inventory.EquipmentSlot.valueOf(interactEvent.getHand());
-                } catch (IllegalArgumentException e) {
-                    hand = org.bukkit.inventory.EquipmentSlot.HAND;
-                }
-
-                org.bukkit.block.Block clickedBlock = player.getWorld().getBlockAt(
-                    interactEvent.getClickedX(),
-                    interactEvent.getClickedY(),
-                    interactEvent.getClickedZ()
-                );
-
-                yield new org.bukkit.event.player.PlayerInteractEvent(
-                    player,
-                    action,
-                    player.getInventory().getItemInMainHand(),
-                    clickedBlock,
-                    org.bukkit.block.BlockFace.SELF,
-                    hand
-                );
+            case CHUNK_POPULATE -> {
+                var ev = event.getChunkPopulate();
+                yield createGenericBukkitEvent("org.bukkit.event.world.ChunkPopulateEvent", ev);
+            }
+            case CHUNK_SAVE -> {
+                var ev = event.getChunkSave();
+                yield createGenericBukkitEvent("org.bukkit.event.world.ChunkUnloadEvent", ev);
+            }
+            case CHUNK_SEND -> {
+                var ev = event.getChunkSend();
+                yield createGenericBukkitEvent("org.bukkit.event.world.ChunkLoadEvent", ev);
+            }
+            case CHUNK_UNLOAD -> {
+                var ev = event.getChunkUnload();
+                yield createGenericBukkitEvent("org.bukkit.event.world.ChunkUnloadEvent", ev);
+            }
+            case ENTITIES_LOAD -> {
+                var ev = event.getEntitiesLoad();
+                yield createGenericBukkitEvent("org.bukkit.event.world.EntitiesLoadEvent", ev);
+            }
+            case ENTITIES_UNLOAD -> {
+                var ev = event.getEntitiesUnload();
+                yield createGenericBukkitEvent("org.bukkit.event.world.EntitiesUnloadEvent", ev);
+            }
+            case GENERIC_GAME -> {
+                var ev = event.getGenericGame();
+                yield createGenericBukkitEvent("org.bukkit.event.world.GenericGameEvent", ev);
+            }
+            case LIGHTNING_STRIKE -> {
+                var ev = event.getLightningStrike();
+                yield createGenericBukkitEvent("org.bukkit.event.weather.LightningStrikeEvent", ev);
+            }
+            case LOOT_GENERATE -> {
+                var ev = event.getLootGenerate();
+                yield createGenericBukkitEvent("org.bukkit.event.world.LootGenerateEvent", ev);
+            }
+            case PORTAL_CREATE -> {
+                var ev = event.getPortalCreate();
+                yield createGenericBukkitEvent("org.bukkit.event.world.PortalCreateEvent", ev);
+            }
+            case SPAWN_CHANGE -> {
+                var ev = event.getSpawnChange();
+                yield createGenericBukkitEvent("org.bukkit.event.world.SpawnChangeEvent", ev);
+            }
+            case STRUCTURE_GROW -> {
+                var ev = event.getStructureGrow();
+                yield createGenericBukkitEvent("org.bukkit.event.world.StructureGrowEvent", ev);
+            }
+            case TIME_SKIP -> {
+                var ev = event.getTimeSkip();
+                yield createGenericBukkitEvent("org.bukkit.event.world.TimeSkipEvent", ev);
+            }
+            case WEATHER_CHANGE -> {
+                var ev = event.getWeatherChange();
+                yield createGenericBukkitEvent("org.bukkit.event.weather.WeatherChangeEvent", ev);
+            }
+            case THUNDER_CHANGE -> {
+                var ev = event.getThunderChange();
+                yield createGenericBukkitEvent("org.bukkit.event.weather.ThunderChangeEvent", ev);
+            }
+            case WORLD_INIT -> {
+                var ev = event.getWorldInit();
+                yield createGenericBukkitEvent("org.bukkit.event.world.WorldInitEvent", ev);
+            }
+            case WORLD_LOAD -> {
+                var ev = event.getWorldLoad();
+                yield createGenericBukkitEvent("org.bukkit.event.world.WorldLoadEvent", ev);
+            }
+            case WORLD_UNLOAD -> {
+                var ev = event.getWorldUnload();
+                yield createGenericBukkitEvent("org.bukkit.event.world.WorldUnloadEvent", ev);
+            }
+            case WORLD_SAVE -> {
+                var ev = event.getWorldSave();
+                yield createGenericBukkitEvent("org.bukkit.event.world.WorldSaveEvent", ev);
+            }
+            case SERVER_LIST_PING -> {
+                var ev = event.getServerListPing();
+                yield createGenericBukkitEvent("org.bukkit.event.server.ServerListPingEvent", ev);
+            }
+            case MAP_INITIALIZE -> {
+                var ev = event.getMapInitialize();
+                yield createGenericBukkitEvent("org.bukkit.event.server.MapInitializeEvent", ev);
+            }
+            case PACKET_RECEIVED -> null;
+            case PACKET_SENT -> null;
+            case PLUGIN_DISABLE -> {
+                var ev = event.getPluginDisable();
+                var plugin = Bukkit.getPluginManager().getPlugin(ev.getPluginName());
+                yield plugin != null ? new org.bukkit.event.server.PluginDisableEvent(plugin) : null;
             }
             case PLUGIN_ENABLE -> {
-                PluginEnableEvent enableEvent = event.getPluginEnable();
-                org.bukkit.plugin.Plugin plugin = Bukkit.getPluginManager().getPlugin(enableEvent.getPluginName());
-                if (plugin == null) yield null;
-                yield new org.bukkit.event.server.PluginEnableEvent(plugin);
+                var ev = event.getPluginEnable();
+                var plugin = Bukkit.getPluginManager().getPlugin(ev.getPluginName());
+                yield plugin != null ? new org.bukkit.event.server.PluginEnableEvent(plugin) : null;
             }
-            case PLUGIN_DISABLE -> {
-                PluginDisableEvent disableEvent = event.getPluginDisable();
-                org.bukkit.plugin.Plugin plugin = Bukkit.getPluginManager().getPlugin(disableEvent.getPluginName());
-                if (plugin == null) yield null;
-                yield new org.bukkit.event.server.PluginDisableEvent(plugin);
+            case REMOTE_SERVER_COMMAND -> {
+                var ev = event.getRemoteServerCommand();
+                yield createGenericBukkitEvent("org.bukkit.event.server.RemoteServerCommandEvent", ev);
             }
-            case BLOCK_BREAK -> {
-                BlockBreakEvent breakEvent = event.getBlockBreak();
-                Player player = breakEvent.hasPlayerUuid() ? getPlayer(breakEvent.getPlayerUuid().getValue()) : null;
-                if (player == null) yield null;
-                org.bukkit.World world = player.getWorld();
-                org.bukkit.block.Block block = world.getBlockAt(breakEvent.getBlockX(), breakEvent.getBlockY(), breakEvent.getBlockZ());
-                yield new org.bukkit.event.block.BlockBreakEvent(block, player);
-            }
-            case BLOCK_PLACE -> {
-                BlockPlaceEvent placeEvent = event.getBlockPlace();
-                Player player = getPlayer(placeEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                org.bukkit.block.Block block = player.getWorld().getBlockAt(placeEvent.getBlockX(), placeEvent.getBlockY(), placeEvent.getBlockZ());
-                org.bukkit.block.BlockState blockState = block.getState();
-                yield new org.bukkit.event.block.BlockPlaceEvent(block, blockState, block, player.getInventory().getItemInMainHand(), player, placeEvent.getCanBuild(), org.bukkit.inventory.EquipmentSlot.HAND);
-            }
-            case SIGN_CHANGE -> {
-                SignChangeEvent signEvent = event.getSignChange();
-                Player player = getPlayer(signEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                org.bukkit.block.Block block = player.getWorld().getBlockAt(
-                    signEvent.getBlockX(),
-                    signEvent.getBlockY(),
-                    signEvent.getBlockZ()
-                );
-                String[] lines = signEvent.getLinesList().toArray(new String[0]);
-                yield new org.bukkit.event.block.SignChangeEvent(block, player, lines);
-            }
-            case BLOCK_DAMAGE -> {
-                BlockDamageEvent damageEvent = event.getBlockDamage();
-                Player player = getPlayer(damageEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                org.bukkit.block.Block block = player.getWorld().getBlockAt(
-                    damageEvent.getBlockX(),
-                    damageEvent.getBlockY(),
-                    damageEvent.getBlockZ()
-                );
-                yield new org.bukkit.event.block.BlockDamageEvent(
-                    player, block, player.getInventory().getItemInMainHand(), damageEvent.getInstaBreak()
-                );
+            case SERVER_BROADCAST -> {
+                var ev = event.getServerBroadcast();
+                yield createGenericBukkitEvent("org.bukkit.event.server.BroadcastMessageEvent", ev);
             }
             case SERVER_COMMAND -> {
-                ServerCommandEvent cmdEvent = event.getServerCommand();
-                yield new org.bukkit.event.server.ServerCommandEvent(
-                    Bukkit.getConsoleSender(),
-                    cmdEvent.getCommand()
-                );
+                var ev = event.getServerCommand();
+                yield new org.bukkit.event.server.ServerCommandEvent(Bukkit.getConsoleSender(), ev.getCommand());
             }
-            case BLOCK_IGNITE -> {
-                BlockIgniteEvent igniteEvent = event.getBlockIgnite();
-                Player player = igniteEvent.hasPlayerUuid() ? getPlayer(igniteEvent.getPlayerUuid().getValue()) : null;
-                org.bukkit.World world = Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
-                if (world == null) yield null;
-                org.bukkit.block.Block block = world.getBlockAt(igniteEvent.getBlockX(), igniteEvent.getBlockY(), igniteEvent.getBlockZ());
-                org.bukkit.event.block.BlockIgniteEvent.IgniteCause cause = org.bukkit.event.block.BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL;
-                yield new org.bukkit.event.block.BlockIgniteEvent(block, cause, player);
+            case SERVER_LOAD -> {
+                var ev = event.getServerLoad();
+                yield createGenericBukkitEvent("org.bukkit.event.server.ServerLoadEvent", ev);
             }
-            case BLOCK_GROW -> {
-                BlockGrowEvent growEvent = event.getBlockGrow();
-                org.bukkit.World world = Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
-                if (world == null) yield null;
-                org.bukkit.block.Block block = world.getBlockAt(growEvent.getBlockX(), growEvent.getBlockY(), growEvent.getBlockZ());
-                yield new org.bukkit.event.block.BlockGrowEvent(block, block.getState());
+            case SERVER_TICK_END -> {
+                var ev = event.getServerTickEnd();
+                yield createGenericBukkitEvent("com.destroystokyo.paper.event.server.ServerTickEndEvent", ev);
             }
-            case BLOCK_FORM -> {
-                BlockFormEvent formEvent = event.getBlockForm();
-                org.bukkit.World world = Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
-                if (world == null) yield null;
-                org.bukkit.block.Block block = world.getBlockAt(formEvent.getBlockX(), formEvent.getBlockY(), formEvent.getBlockZ());
-                yield new org.bukkit.event.block.BlockFormEvent(block, block.getState());
+            case SERVER_TICK_START -> {
+                var ev = event.getServerTickStart();
+                yield createGenericBukkitEvent("com.destroystokyo.paper.event.server.ServerTickStartEvent", ev);
+            }
+            case SERVICE_REGISTER -> {
+                var ev = event.getServiceRegister();
+                yield createGenericBukkitEvent("org.bukkit.event.server.ServiceRegisterEvent", ev);
+            }
+            case SERVICE_UNREGISTER -> {
+                var ev = event.getServiceUnregister();
+                yield createGenericBukkitEvent("org.bukkit.event.server.ServiceUnregisterEvent", ev);
+            }
+            case TAB_COMPLETE -> {
+                var ev = event.getTabComplete();
+                yield createGenericBukkitEvent("org.bukkit.event.server.TabCompleteEvent", ev);
+            }
+            case VEHICLE_BLOCK_COLLISION -> {
+                var ev = event.getVehicleBlockCollision();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleBlockCollisionEvent", ev);
+            }
+            case VEHICLE_COLLISION -> {
+                var ev = event.getVehicleCollision();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleCollisionEvent", ev);
+            }
+            case VEHICLE_CREATE -> {
+                var ev = event.getVehicleCreate();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleCreateEvent", ev);
+            }
+            case VEHICLE_DAMAGE -> {
+                var ev = event.getVehicleDamage();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleDamageEvent", ev);
+            }
+            case VEHICLE_DESTROY -> {
+                var ev = event.getVehicleDestroy();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleDestroyEvent", ev);
+            }
+            case VEHICLE_ENTER -> {
+                var ev = event.getVehicleEnter();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleEnterEvent", ev);
+            }
+            case VEHICLE_ENTITY_COLLISION -> {
+                var ev = event.getVehicleEntityCollision();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleEntityCollisionEvent", ev);
+            }
+            case VEHICLE_EXIT -> {
+                var ev = event.getVehicleExit();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleExitEvent", ev);
+            }
+            case VEHICLE_MOVE -> {
+                var ev = event.getVehicleMove();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleMoveEvent", ev);
+            }
+            case VEHICLE_UPDATE -> {
+                var ev = event.getVehicleUpdate();
+                yield createGenericBukkitEvent("org.bukkit.event.vehicle.VehicleUpdateEvent", ev);
+            }
+            case BREW -> {
+                var ev = event.getBrew();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.BrewEvent", ev);
+            }
+            case BREWING_STAND_FUEL -> {
+                var ev = event.getBrewingStandFuel();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.BrewingStandFuelEvent", ev);
+            }
+            case CRAFT_ITEM -> {
+                var ev = event.getCraftItem();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.CraftItemEvent", ev);
+            }
+            case FURNACE_BURN -> {
+                var ev = event.getFurnaceBurn();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.FurnaceBurnEvent", ev);
+            }
+            case FURNACE_EXTRACT -> {
+                var ev = event.getFurnaceExtract();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.FurnaceExtractEvent", ev);
+            }
+            case FURNACE_SMELT -> {
+                var ev = event.getFurnaceSmelt();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.FurnaceSmeltEvent", ev);
+            }
+            case FURNACE_START_SMELT -> {
+                var ev = event.getFurnaceStartSmelt();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.FurnaceStartSmeltEvent", ev);
+            }
+            case HOPPER_INVENTORY_SEARCH -> {
+                var ev = event.getHopperInventorySearch();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.HopperInventorySearchEvent", ev);
+            }
+            case INVENTORY_CREATIVE -> {
+                var ev = event.getInventoryCreative();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryCreativeEvent", ev);
+            }
+            case INVENTORY_DRAG -> {
+                var ev = event.getInventoryDrag();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryDragEvent", ev);
+            }
+            case INVENTORY_INTERACT -> {
+                var ev = event.getInventoryInteract();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryInteractEvent", ev);
+            }
+            case INVENTORY_MOVE_ITEM -> {
+                var ev = event.getInventoryMoveItem();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryMoveItemEvent", ev);
+            }
+            case INVENTORY_OPEN -> {
+                var ev = event.getInventoryOpen();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryOpenEvent", ev);
+            }
+            case INVENTORY_PICKUP_ITEM -> {
+                var ev = event.getInventoryPickupItem();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryPickupItemEvent", ev);
+            }
+            case PREPARE_ANVIL -> {
+                var ev = event.getPrepareAnvil();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.PrepareAnvilEvent", ev);
+            }
+            case PREPARE_GRINDSTONE -> {
+                var ev = event.getPrepareGrindstone();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.PrepareGrindstoneEvent", ev);
+            }
+            case PREPARE_INVENTORY_RESULT -> {
+                var ev = event.getPrepareInventoryResult();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.PrepareInventoryResultEvent", ev);
+            }
+            case PREPARE_ITEM_CRAFT -> {
+                var ev = event.getPrepareItemCraft();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.PrepareItemCraftEvent", ev);
+            }
+            case PREPARE_SMITHING -> {
+                var ev = event.getPrepareSmithing();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.PrepareSmithingEvent", ev);
+            }
+            case SMITH_ITEM -> {
+                var ev = event.getSmithItem();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.SmithItemEvent", ev);
+            }
+            case TRADE_SELECT -> {
+                var ev = event.getTradeSelect();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.TradeSelectEvent", ev);
+            }
+            case BELL_RESONATE -> {
+                var ev = event.getBellResonate();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BellResonateEvent", ev);
+            }
+            case BELL_RING -> {
+                var ev = event.getBellRing();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BellRingEvent", ev);
+            }
+            case BLOCK_BREAK -> {
+                var ev = event.getBlockBreak();
+                Player player = ev.hasPlayerUuid() ? getPlayer(ev.getPlayerUuid().getValue()) : null;
+                if (player == null) yield null;
+                Block b = player.getWorld().getBlockAt(ev.getBlockX(), ev.getBlockY(), ev.getBlockZ());
+                yield new org.bukkit.event.block.BlockBreakEvent(b, player);
+            }
+            case BLOCK_BRUSH -> null;
+            case BLOCK_BURN -> {
+                var ev = event.getBlockBurn();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockBurnEvent", ev);
+            }
+            case BLOCK_CAN_BUILD -> {
+                var ev = event.getBlockCanBuild();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockCanBuildEvent", ev);
+            }
+            case BLOCK_COOK -> {
+                var ev = event.getBlockCook();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockCookEvent", ev);
+            }
+            case BLOCK_DAMAGE -> {
+                var ev = event.getBlockDamage();
+                Player player = ev.hasPlayerUuid() ? getPlayer(ev.getPlayerUuid().getValue()) : null;
+                if (player == null) yield null;
+                Block b = player.getWorld().getBlockAt(ev.getBlockX(), ev.getBlockY(), ev.getBlockZ());
+                yield new org.bukkit.event.block.BlockDamageEvent(player, b, player.getInventory().getItemInMainHand(), ev.getInstaBreak());
+            }
+            case BLOCK_DAMAGE_ABORT -> {
+                var ev = event.getBlockDamageAbort();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockDamageAbortEvent", ev);
+            }
+            case BLOCK_DISPENSE -> {
+                var ev = event.getBlockDispense();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockDispenseEvent", ev);
+            }
+            case BLOCK_DISPENSE_ARMOR -> {
+                var ev = event.getBlockDispenseArmor();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockDispenseArmorEvent", ev);
+            }
+            case BLOCK_DISPENSE_LOOT -> {
+                var ev = event.getBlockDispenseLoot();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockDispenseLootEvent", ev);
+            }
+            case BLOCK_DROP_ITEM -> {
+                var ev = event.getBlockDropItem();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockDropItemEvent", ev);
+            }
+            case BLOCK_EXP -> {
+                var ev = event.getBlockExp();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockExpEvent", ev);
+            }
+            case BLOCK_EXPLODE -> {
+                var ev = event.getBlockExplode();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockExplodeEvent", ev);
             }
             case BLOCK_FADE -> {
-                BlockFadeEvent fadeEvent = event.getBlockFade();
-                org.bukkit.World world = Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
-                if (world == null) yield null;
-                org.bukkit.block.Block block = world.getBlockAt(fadeEvent.getBlockX(), fadeEvent.getBlockY(), fadeEvent.getBlockZ());
-                yield new org.bukkit.event.block.BlockFadeEvent(block, block.getState());
+                var ev = event.getBlockFade();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockFadeEvent", ev);
             }
-            case PLAYER_TOGGLE_SNEAK -> {
-                PlayerToggleSneakEvent sneakEvent = event.getPlayerToggleSneak();
-                Player player = getPlayer(sneakEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                yield new org.bukkit.event.player.PlayerToggleSneakEvent(player, sneakEvent.getIsSneaking());
+            case BLOCK_FERTILIZE -> {
+                var ev = event.getBlockFertilize();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockFertilizeEvent", ev);
             }
-            case PLAYER_TOGGLE_SPRINT -> {
-                PlayerToggleSprintEvent sprintEvent = event.getPlayerToggleSprint();
-                Player player = getPlayer(sprintEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                yield new org.bukkit.event.player.PlayerToggleSprintEvent(player, sprintEvent.getIsSprinting());
+            case BLOCK_FORM -> {
+                var ev = event.getBlockForm();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockFormEvent", ev);
             }
-            case PLAYER_TOGGLE_FLIGHT -> {
-                PlayerToggleFlightEvent flightEvent = event.getPlayerToggleFlight();
-                Player player = getPlayer(flightEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                yield new org.bukkit.event.player.PlayerToggleFlightEvent(player, flightEvent.getIsFlying());
+            case BLOCK_FROM_TO -> {
+                var ev = event.getBlockFromTo();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockFromToEvent", ev);
             }
-            case PLAYER_MOVE -> {
-                PlayerMoveEvent moveEvent = event.getPlayerMove();
-                Player player = getPlayer(moveEvent.getPlayerUuid().getValue());
-                if (player == null) yield null;
-                org.bukkit.Location from = org.patchbukkit.bridge.BridgeUtils.convertLocation(moveEvent.getFrom());
-                org.bukkit.Location to = org.patchbukkit.bridge.BridgeUtils.convertLocation(moveEvent.getTo());
-                yield new org.bukkit.event.player.PlayerMoveEvent(player, from, to);
+            case BLOCK_GROW -> {
+                var ev = event.getBlockGrow();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockGrowEvent", ev);
             }
-            case PLAYER_INTERACT_ENTITY -> {
-                PlayerInteractEntityEvent interactEvent = event.getPlayerInteractEntity();
-                Player player = getPlayer(interactEvent.getPlayerUuid().getValue());
+            case BLOCK_IGNITE -> {
+                var ev = event.getBlockIgnite();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockIgniteEvent", ev);
+            }
+            case BLOCK_MULTI_PLACE -> {
+                var ev = event.getBlockMultiPlace();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockMultiPlaceEvent", ev);
+            }
+            case BLOCK_PHYSICS -> {
+                var ev = event.getBlockPhysics();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockPhysicsEvent", ev);
+            }
+            case BLOCK_PISTON_EXTEND -> {
+                var ev = event.getBlockPistonExtend();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockPistonExtendEvent", ev);
+            }
+            case BLOCK_PISTON_RETRACT -> {
+                var ev = event.getBlockPistonRetract();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockPistonRetractEvent", ev);
+            }
+            case BLOCK_PLACE -> {
+                var ev = event.getBlockPlace();
+                Player player = ev.hasPlayerUuid() ? getPlayer(ev.getPlayerUuid().getValue()) : null;
                 if (player == null) yield null;
-                java.util.UUID targetUuid = org.patchbukkit.bridge.BridgeUtils.convertUuid(interactEvent.getTargetUuid());
-                org.bukkit.entity.Entity target = Bukkit.getPlayer(targetUuid);
-                if (target == null) target = Bukkit.getEntity(targetUuid);
-                if (target == null) yield null;
-                if ("ATTACK".equals(interactEvent.getAction())) {
-                    yield new org.bukkit.event.entity.EntityDamageByEntityEvent(
-                        player, target, org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, 1.0
-                    );
-                } else {
-                    yield new org.bukkit.event.player.PlayerInteractEntityEvent(player, target);
-                }
+                Block b = player.getWorld().getBlockAt(ev.getBlockX(), ev.getBlockY(), ev.getBlockZ());
+                yield new org.bukkit.event.block.BlockPlaceEvent(b, b.getState(), b, player.getInventory().getItemInMainHand(), player, ev.getCanBuild(), org.bukkit.inventory.EquipmentSlot.HAND);
+            }
+            case BLOCK_RECEIVE_GAME -> {
+                var ev = event.getBlockReceiveGame();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockReceiveGameEvent", ev);
+            }
+            case BLOCK_REDSTONE -> {
+                var ev = event.getBlockRedstone();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockRedstoneEvent", ev);
+            }
+            case BLOCK_SHEAR_ENTITY -> {
+                var ev = event.getBlockShearEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockShearEntityEvent", ev);
+            }
+            case BLOCK_SPREAD -> {
+                var ev = event.getBlockSpread();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BlockSpreadEvent", ev);
+            }
+            case BREWING_START -> {
+                var ev = event.getBrewingStart();
+                yield createGenericBukkitEvent("org.bukkit.event.block.BrewingStartEvent", ev);
+            }
+            case CAMPFIRE_START -> {
+                var ev = event.getCampfireStart();
+                yield createGenericBukkitEvent("org.bukkit.event.block.CampfireStartEvent", ev);
+            }
+            case CAULDRON_LEVEL_CHANGE -> {
+                var ev = event.getCauldronLevelChange();
+                yield createGenericBukkitEvent("org.bukkit.event.block.CauldronLevelChangeEvent", ev);
+            }
+            case CRAFTER_CRAFT -> {
+                var ev = event.getCrafterCraft();
+                yield createGenericBukkitEvent("org.bukkit.event.block.CrafterCraftEvent", ev);
+            }
+            case ENTITY_BLOCK_FORM -> {
+                var ev = event.getEntityBlockForm();
+                yield createGenericBukkitEvent("org.bukkit.event.block.EntityBlockFormEvent", ev);
+            }
+            case FLUID_LEVEL_CHANGE -> {
+                var ev = event.getFluidLevelChange();
+                yield createGenericBukkitEvent("org.bukkit.event.block.FluidLevelChangeEvent", ev);
+            }
+            case INVENTORY_BLOCK_START -> {
+                var ev = event.getInventoryBlockStart();
+                yield createGenericBukkitEvent("org.bukkit.event.block.InventoryBlockStartEvent", ev);
+            }
+            case LEAVES_DECAY -> {
+                var ev = event.getLeavesDecay();
+                yield createGenericBukkitEvent("org.bukkit.event.block.LeavesDecayEvent", ev);
+            }
+            case MOISTURE_CHANGE -> {
+                var ev = event.getMoistureChange();
+                yield createGenericBukkitEvent("org.bukkit.event.block.MoistureChangeEvent", ev);
+            }
+            case NOTE_PLAY -> {
+                var ev = event.getNotePlay();
+                yield createGenericBukkitEvent("org.bukkit.event.block.NotePlayEvent", ev);
+            }
+            case SCULK_BLOOM -> {
+                var ev = event.getSculkBloom();
+                yield createGenericBukkitEvent("org.bukkit.event.block.SculkBloomEvent", ev);
+            }
+            case SIGN_CHANGE -> {
+                var ev = event.getSignChange();
+                Player player = ev.hasPlayerUuid() ? getPlayer(ev.getPlayerUuid().getValue()) : null;
+                if (player == null) yield null;
+                Block b = player.getWorld().getBlockAt(ev.getBlockX(), ev.getBlockY(), ev.getBlockZ());
+                yield new org.bukkit.event.block.SignChangeEvent(b, player, ev.getLinesList().toArray(new String[0]));
+            }
+            case SPONGE_ABSORB -> {
+                var ev = event.getSpongeAbsorb();
+                yield createGenericBukkitEvent("org.bukkit.event.block.SpongeAbsorbEvent", ev);
+            }
+            case TNT_PRIME -> {
+                var ev = event.getTntPrime();
+                yield createGenericBukkitEvent("org.bukkit.event.block.TNTPrimeEvent", ev);
+            }
+            case VAULT_DISPLAY_ITEM -> {
+                var ev = event.getVaultDisplayItem();
+                yield createGenericBukkitEvent("org.bukkit.event.block.VaultDisplayItemEvent", ev);
+            }
+            case DIALOG_CLEAR -> null;
+            case DIALOG_CLICK_ACTION -> null;
+            case DIALOG_SHOW -> null;
+            case ASYNC_PLAYER_CHAT -> {
+                var ev = event.getAsyncPlayerChat();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                yield new org.bukkit.event.player.AsyncPlayerChatEvent(true, player, ev.getMessage(), new java.util.HashSet<>(Bukkit.getOnlinePlayers()));
+            }
+            case ASYNC_PLAYER_PRE_LOGIN -> {
+                var ev = event.getAsyncPlayerPreLogin();
+                yield createGenericBukkitEvent("org.bukkit.event.player.AsyncPlayerPreLoginEvent", ev);
+            }
+            case BEDROCK_FORM_RESPONSE -> null;
+            case PLAYER_CHANGED_MAIN_HAND -> {
+                var ev = event.getPlayerChangedMainHand();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerChangedMainHandEvent", ev);
+            }
+            case PLAYER_EGG_THROW -> {
+                var ev = event.getPlayerEggThrow();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerEggThrowEvent", ev);
+            }
+            case PLAYER_EXP_CHANGE -> {
+                var ev = event.getPlayerExpChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerExpChangeEvent", ev);
+            }
+            case PLAYER_FISH -> {
+                var ev = event.getPlayerFish();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerFishEvent", ev);
+            }
+            case INVENTORY_CLOSE -> {
+                var ev = event.getInventoryClose();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryCloseEvent", ev);
+            }
+            case INVENTORY_CLICK -> {
+                var ev = event.getInventoryClick();
+                yield createGenericBukkitEvent("org.bukkit.event.inventory.InventoryClickEvent", ev);
+            }
+            case PLAYER_ITEM_HELD -> {
+                var ev = event.getPlayerItemHeld();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerItemHeldEvent", ev);
+            }
+            case PLAYER_ADVANCEMENT_DONE -> {
+                var ev = event.getPlayerAdvancementDone();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerAdvancementDoneEvent", ev);
+            }
+            case PLAYER_ANIMATION -> {
+                var ev = event.getPlayerAnimation();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerAnimationEvent", ev);
+            }
+            case PLAYER_ARMOR_STAND_MANIPULATE -> {
+                var ev = event.getPlayerArmorStandManipulate();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerArmorStandManipulateEvent", ev);
+            }
+            case PLAYER_BED_ENTER -> {
+                var ev = event.getPlayerBedEnter();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerBedEnterEvent", ev);
+            }
+            case PLAYER_BED_LEAVE -> {
+                var ev = event.getPlayerBedLeave();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerBedLeaveEvent", ev);
+            }
+            case PLAYER_BUCKET_EMPTY -> {
+                var ev = event.getPlayerBucketEmpty();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerBucketEmptyEvent", ev);
+            }
+            case PLAYER_BUCKET_FILL -> {
+                var ev = event.getPlayerBucketFill();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerBucketFillEvent", ev);
+            }
+            case PLAYER_BUCKET_ENTITY -> {
+                var ev = event.getPlayerBucketEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerBucketEntityEvent", ev);
+            }
+            case PLAYER_CHANGE_WORLD -> null;
+            case PLAYER_CHANGED_WORLD -> {
+                var ev = event.getPlayerChangedWorld();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerChangedWorldEvent", ev);
+            }
+            case PLAYER_CHANNEL -> {
+                var ev = event.getPlayerChannel();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerChannelEvent", ev);
             }
             case PLAYER_CHAT -> {
-                PlayerChatEvent chatEvent = event.getPlayerChat();
-                Player player = getPlayer(chatEvent.getPlayerUuid().getValue());
+                var ev = event.getPlayerChat();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
                 if (player == null) yield null;
-                yield new org.bukkit.event.player.AsyncPlayerChatEvent(true, player, chatEvent.getMessage(), new java.util.HashSet<>(Bukkit.getOnlinePlayers()));
+                yield new org.bukkit.event.player.AsyncPlayerChatEvent(true, player, ev.getMessage(), new java.util.HashSet<>(Bukkit.getOnlinePlayers()));
             }
-            case DATA_NOT_SET -> {
-                LOGGER.warning("EventFactory: Received Event with no data");
-                yield null;
+            case PLAYER_COMMAND_PREPROCESS -> {
+                var ev = event.getPlayerCommandPreprocess();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerCommandPreprocessEvent", ev);
             }
+            case PLAYER_COMMAND_SEND -> {
+                var ev = event.getPlayerCommandSend();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerCommandSendEvent", ev);
+            }
+            case PLAYER_CUSTOM_PAYLOAD -> null;
+            case PLAYER_DROP_ITEM -> {
+                var ev = event.getPlayerDropItem();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerDropItemEvent", ev);
+            }
+            case PLAYER_EDIT_BOOK -> {
+                var ev = event.getPlayerEditBook();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerEditBookEvent", ev);
+            }
+            case PLAYER_ELYTRA_BOOST -> {
+                var ev = event.getPlayerElytraBoost();
+                yield createGenericBukkitEvent("com.destroystokyo.paper.event.player.PlayerElytraBoostEvent", ev);
+            }
+            case PLAYER_EXP_COOLDOWN_CHANGE -> {
+                var ev = event.getPlayerExpCooldownChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerExpCooldownChangeEvent", ev);
+            }
+            case PLAYER_GAMEMODE_CHANGE -> {
+                var ev = event.getPlayerGamemodeChange();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                org.bukkit.GameMode gm;
+                try {
+                    gm = org.bukkit.GameMode.valueOf(ev.getNewGamemode().toUpperCase());
+                } catch (Exception ex) {
+                    gm = org.bukkit.GameMode.SURVIVAL;
+                }
+                yield new org.bukkit.event.player.PlayerGameModeChangeEvent(player, gm);
+            }
+            case PLAYER_HARVEST_BLOCK -> {
+                var ev = event.getPlayerHarvestBlock();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerHarvestBlockEvent", ev);
+            }
+            case PLAYER_HIDE_ENTITY -> {
+                var ev = event.getPlayerHideEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerHideEntityEvent", ev);
+            }
+            case PLAYER_INPUT -> {
+                var ev = event.getPlayerInput();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerInputEvent", ev);
+            }
+            case PLAYER_INTERACT_AT_ENTITY -> {
+                var ev = event.getPlayerInteractAtEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerInteractAtEntityEvent", ev);
+            }
+            case PLAYER_INTERACT_ENTITY -> {
+                var ev = event.getPlayerInteractEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerInteractEntityEvent", ev);
+            }
+            case PLAYER_INTERACT -> {
+                var ev = event.getPlayerInteract();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                org.bukkit.event.block.Action act;
+                try {
+                    act = org.bukkit.event.block.Action.valueOf(ev.getAction());
+                } catch (Exception ex) {
+                    act = org.bukkit.event.block.Action.RIGHT_CLICK_AIR;
+                }
+                org.bukkit.block.Block b = player.getWorld().getBlockAt(ev.getClickedPosX(), ev.getClickedPosY(), ev.getClickedPosZ());
+                yield new org.bukkit.event.player.PlayerInteractEvent(player, act, player.getInventory().getItemInMainHand(), b, org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
+            }
+            case PLAYER_INTERACT_UNKNOWN_ENTITY -> null;
+            case PLAYER_ITEM_BREAK -> {
+                var ev = event.getPlayerItemBreak();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerItemBreakEvent", ev);
+            }
+            case PLAYER_ITEM_CONSUME -> {
+                var ev = event.getPlayerItemConsume();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerItemConsumeEvent", ev);
+            }
+            case PLAYER_ITEM_DAMAGE -> {
+                var ev = event.getPlayerItemDamage();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerItemDamageEvent", ev);
+            }
+            case PLAYER_ITEM_MEND -> {
+                var ev = event.getPlayerItemMend();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerItemMendEvent", ev);
+            }
+            case PLAYER_JOIN -> {
+                var ev = event.getPlayerJoin();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                Component msg = ev.getJoinMessage().isEmpty() ? Component.empty() : GsonComponentSerializer.gson().deserialize(ev.getJoinMessage());
+                yield new org.bukkit.event.player.PlayerJoinEvent(player, msg);
+            }
+            case PLAYER_KICK -> {
+                var ev = event.getPlayerKick();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerKickEvent", ev);
+            }
+            case PLAYER_LEASH_ENTITY -> {
+                var ev = event.getPlayerLeashEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PlayerLeashEntityEvent", ev);
+            }
+            case PLAYER_LEAVE -> {
+                var ev = event.getPlayerLeave();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                Component msg = ev.getLeaveMessage().isEmpty() ? Component.empty() : GsonComponentSerializer.gson().deserialize(ev.getLeaveMessage());
+                yield new org.bukkit.event.player.PlayerQuitEvent(player, msg);
+            }
+            case PLAYER_LEVEL_CHANGE -> {
+                var ev = event.getPlayerLevelChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerLevelChangeEvent", ev);
+            }
+            case PLAYER_LINKS_SEND -> {
+                var ev = event.getPlayerLinksSend();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerLinksSendEvent", ev);
+            }
+            case PLAYER_LOCALE_CHANGE -> {
+                var ev = event.getPlayerLocaleChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerLocaleChangeEvent", ev);
+            }
+            case PLAYER_LOGIN -> {
+                var ev = event.getPlayerLogin();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerLoginEvent", ev);
+            }
+            case PLAYER_MOVE -> {
+                var ev = event.getPlayerMove();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                Location from = new Location(player.getWorld(), ev.getFromX(), ev.getFromY(), ev.getFromZ());
+                Location to = new Location(player.getWorld(), ev.getToX(), ev.getToY(), ev.getToZ());
+                yield new org.bukkit.event.player.PlayerMoveEvent(player, from, to);
+            }
+            case PLAYER_NAME_ENTITY -> {
+                var ev = event.getPlayerNameEntity();
+                yield createGenericBukkitEvent("io.papermc.paper.event.player.PlayerNameEntityEvent", ev);
+            }
+            case PLAYER_OPEN_SIGN -> {
+                var ev = event.getPlayerOpenSign();
+                yield createGenericBukkitEvent("io.papermc.paper.event.player.PlayerOpenSignEvent", ev);
+            }
+            case PLAYER_PERMISSION_CHECK -> null;
+            case PLAYER_PICKUP_ARROW -> {
+                var ev = event.getPlayerPickupArrow();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerPickupArrowEvent", ev);
+            }
+            case PLAYER_PORTAL -> {
+                var ev = event.getPlayerPortal();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerPortalEvent", ev);
+            }
+            case PLAYER_PRE_LOGIN -> {
+                var ev = event.getPlayerPreLogin();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerPreLoginEvent", ev);
+            }
+            case PLAYER_RECIPE_BOOK_CLICK -> {
+                var ev = event.getPlayerRecipeBookClick();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRecipeBookClickEvent", ev);
+            }
+            case PLAYER_RECIPE_BOOK_SETTINGS_CHANGE -> {
+                var ev = event.getPlayerRecipeBookSettingsChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRecipeBookSettingsChangeEvent", ev);
+            }
+            case PLAYER_RECIPE_DISCOVER -> {
+                var ev = event.getPlayerRecipeDiscover();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRecipeDiscoverEvent", ev);
+            }
+            case PLAYER_REGISTER_CHANNEL -> {
+                var ev = event.getPlayerRegisterChannel();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRegisterChannelEvent", ev);
+            }
+            case PLAYER_RESOURCE_PACK_STATUS -> {
+                var ev = event.getPlayerResourcePackStatus();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerResourcePackStatusEvent", ev);
+            }
+            case PLAYER_RESPAWN -> {
+                var ev = event.getPlayerRespawn();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRespawnEvent", ev);
+            }
+            case PLAYER_RIPTIDE -> {
+                var ev = event.getPlayerRiptide();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerRiptideEvent", ev);
+            }
+            case PLAYER_SHEAR_ENTITY -> {
+                var ev = event.getPlayerShearEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerShearEntityEvent", ev);
+            }
+            case PLAYER_SHOW_ENTITY -> {
+                var ev = event.getPlayerShowEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerShowEntityEvent", ev);
+            }
+            case PLAYER_SPAWN_CHANGE -> {
+                var ev = event.getPlayerSpawnChange();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerSpawnChangeEvent", ev);
+            }
+            case PLAYER_SPAWN_LOCATION -> {
+                var ev = event.getPlayerSpawnLocation();
+                yield createGenericBukkitEvent("org.spigotmc.event.player.PlayerSpawnLocationEvent", ev);
+            }
+            case PLAYER_STATISTIC_INCREMENT -> {
+                var ev = event.getPlayerStatisticIncrement();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerStatisticIncrementEvent", ev);
+            }
+            case PLAYER_SWAP_HAND_ITEMS -> {
+                var ev = event.getPlayerSwapHandItems();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerSwapHandItemsEvent", ev);
+            }
+            case PLAYER_TAKE_LECTERN_BOOK -> {
+                var ev = event.getPlayerTakeLecternBook();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerTakeLecternBookEvent", ev);
+            }
+            case PLAYER_TELEPORT -> {
+                var ev = event.getPlayerTeleport();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerTeleportEvent", ev);
+            }
+            case PLAYER_TOGGLE_FLIGHT -> {
+                var ev = event.getPlayerToggleFlight();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                yield new org.bukkit.event.player.PlayerToggleFlightEvent(player, ev.getIsFlying());
+            }
+            case PLAYER_TOGGLE_SNEAK -> {
+                var ev = event.getPlayerToggleSneak();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                yield new org.bukkit.event.player.PlayerToggleSneakEvent(player, ev.getIsSneaking());
+            }
+            case PLAYER_TOGGLE_SPRINT -> {
+                var ev = event.getPlayerToggleSprint();
+                Player player = getPlayer(ev.getPlayerUuid().getValue());
+                if (player == null) yield null;
+                yield new org.bukkit.event.player.PlayerToggleSprintEvent(player, ev.getIsSprinting());
+            }
+            case PLAYER_UNLEASH_ENTITY -> {
+                var ev = event.getPlayerUnleashEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerUnleashEntityEvent", ev);
+            }
+            case PLAYER_UNREGISTER_CHANNEL -> {
+                var ev = event.getPlayerUnregisterChannel();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerUnregisterChannelEvent", ev);
+            }
+            case PLAYER_VELOCITY -> {
+                var ev = event.getPlayerVelocity();
+                yield createGenericBukkitEvent("org.bukkit.event.player.PlayerVelocityEvent", ev);
+            }
+            case HANGING_BREAK -> {
+                var ev = event.getHangingBreak();
+                yield createGenericBukkitEvent("org.bukkit.event.hanging.HangingBreakEvent", ev);
+            }
+            case HANGING_BREAK_BY_ENTITY -> {
+                var ev = event.getHangingBreakByEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.hanging.HangingBreakByEntityEvent", ev);
+            }
+            case HANGING_PLACE -> {
+                var ev = event.getHangingPlace();
+                yield createGenericBukkitEvent("org.bukkit.event.hanging.HangingPlaceEvent", ev);
+            }
+            case AREA_EFFECT_CLOUD_APPLY -> {
+                var ev = event.getAreaEffectCloudApply();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.AreaEffectCloudApplyEvent", ev);
+            }
+            case ARROW_BODY_COUNT_CHANGE -> {
+                var ev = event.getArrowBodyCountChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ArrowBodyCountChangeEvent", ev);
+            }
+            case BAT_TOGGLE_SLEEP -> {
+                var ev = event.getBatToggleSleep();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.BatToggleSleepEvent", ev);
+            }
+            case CREATURE_SPAWN -> {
+                var ev = event.getCreatureSpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.CreatureSpawnEvent", ev);
+            }
+            case CREEPER_POWER -> {
+                var ev = event.getCreeperPower();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.CreeperPowerEvent", ev);
+            }
+            case ENDER_DRAGON_CHANGE_PHASE -> {
+                var ev = event.getEnderDragonChangePhase();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EnderDragonChangePhaseEvent", ev);
+            }
+            case ENTITY_AIR_CHANGE -> {
+                var ev = event.getEntityAirChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityAirChangeEvent", ev);
+            }
+            case ENTITY_BREAK_DOOR -> {
+                var ev = event.getEntityBreakDoor();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityBreakDoorEvent", ev);
+            }
+            case ENTITY_BREED -> {
+                var ev = event.getEntityBreed();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityBreedEvent", ev);
+            }
+            case ENTITY_CHANGE_BLOCK -> {
+                var ev = event.getEntityChangeBlock();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityChangeBlockEvent", ev);
+            }
+            case ENTITY_COMBUST -> {
+                var ev = event.getEntityCombust();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityCombustEvent", ev);
+            }
+            case ENTITY_COMBUST_BY_BLOCK -> {
+                var ev = event.getEntityCombustByBlock();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityCombustByBlockEvent", ev);
+            }
+            case ENTITY_COMBUST_BY_ENTITY -> {
+                var ev = event.getEntityCombustByEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityCombustByEntityEvent", ev);
+            }
+            case ENTITY_DAMAGE -> {
+                var ev = event.getEntityDamage();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDamageEvent", ev);
+            }
+            case ENTITY_DAMAGE_BY_BLOCK -> {
+                var ev = event.getEntityDamageByBlock();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDamageByBlockEvent", ev);
+            }
+            case ENTITY_DAMAGE_BY_ENTITY -> {
+                var ev = event.getEntityDamageByEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDamageByEntityEvent", ev);
+            }
+            case ENTITY_DEATH -> {
+                var ev = event.getEntityDeath();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDeathEvent", ev);
+            }
+            case PLAYER_DEATH -> {
+                var ev = event.getPlayerDeath();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PlayerDeathEvent", ev);
+            }
+            case ENTITY_DISMOUNT -> {
+                var ev = event.getEntityDismount();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDismountEvent", ev);
+            }
+            case ENTITY_DROP_ITEM -> {
+                var ev = event.getEntityDropItem();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityDropItemEvent", ev);
+            }
+            case ENTITY_DYE -> {
+                var ev = event.getEntityDye();
+                yield createGenericBukkitEvent("io.papermc.paper.event.entity.EntityDyeEvent", ev);
+            }
+            case ENTITY_ENTER_BLOCK -> {
+                var ev = event.getEntityEnterBlock();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityEnterBlockEvent", ev);
+            }
+            case ENTITY_ENTER_LOVE_MODE -> {
+                var ev = event.getEntityEnterLoveMode();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityEnterLoveModeEvent", ev);
+            }
+            case ENTITY_EXHAUSTION -> {
+                var ev = event.getEntityExhaustion();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityExhaustionEvent", ev);
+            }
+            case ENTITY_EXPLODE -> {
+                var ev = event.getEntityExplode();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityExplodeEvent", ev);
+            }
+            case ENTITY_INTERACT -> {
+                var ev = event.getEntityInteract();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityInteractEvent", ev);
+            }
+            case ENTITY_KNOCKBACK -> {
+                var ev = event.getEntityKnockback();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityKnockbackEvent", ev);
+            }
+            case ENTITY_KNOCKBACK_BY_ENTITY -> {
+                var ev = event.getEntityKnockbackByEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityKnockbackByEntityEvent", ev);
+            }
+            case ENTITY_MOUNT -> {
+                var ev = event.getEntityMount();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityMountEvent", ev);
+            }
+            case ENTITY_PICKUP_ITEM -> {
+                var ev = event.getEntityPickupItem();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPickupItemEvent", ev);
+            }
+            case ENTITY_PLACE -> {
+                var ev = event.getEntityPlace();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPlaceEvent", ev);
+            }
+            case ENTITY_PORTAL -> {
+                var ev = event.getEntityPortal();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPortalEvent", ev);
+            }
+            case ENTITY_PORTAL_ENTER -> {
+                var ev = event.getEntityPortalEnter();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPortalEnterEvent", ev);
+            }
+            case ENTITY_PORTAL_EXIT -> {
+                var ev = event.getEntityPortalExit();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPortalExitEvent", ev);
+            }
+            case ENTITY_POSE_CHANGE -> {
+                var ev = event.getEntityPoseChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPoseChangeEvent", ev);
+            }
+            case ENTITY_POTION_EFFECT -> {
+                var ev = event.getEntityPotionEffect();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityPotionEffectEvent", ev);
+            }
+            case ENTITY_REGAIN_HEALTH -> {
+                var ev = event.getEntityRegainHealth();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityRegainHealthEvent", ev);
+            }
+            case ENTITY_REMOVE -> {
+                var ev = event.getEntityRemove();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityRemoveEvent", ev);
+            }
+            case ENTITY_RESURRECT -> {
+                var ev = event.getEntityResurrect();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityResurrectEvent", ev);
+            }
+            case ENTITY_SHOOT_BOW -> {
+                var ev = event.getEntityShootBow();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityShootBowEvent", ev);
+            }
+            case ENTITY_SPAWN -> {
+                var ev = event.getEntitySpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntitySpawnEvent", ev);
+            }
+            case ENTITY_SPELL_CAST -> {
+                var ev = event.getEntitySpellCast();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntitySpellCastEvent", ev);
+            }
+            case ENTITY_TAME -> {
+                var ev = event.getEntityTame();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityTameEvent", ev);
+            }
+            case ENTITY_TARGET -> {
+                var ev = event.getEntityTarget();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityTargetEvent", ev);
+            }
+            case ENTITY_TARGET_BLOCK -> null;
+            case ENTITY_TARGET_LIVING_ENTITY -> {
+                var ev = event.getEntityTargetLivingEntity();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityTargetLivingEntityEvent", ev);
+            }
+            case ENTITY_TELEPORT -> {
+                var ev = event.getEntityTeleport();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityTeleportEvent", ev);
+            }
+            case ENTITY_TOGGLE_GLIDE -> {
+                var ev = event.getEntityToggleGlide();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityToggleGlideEvent", ev);
+            }
+            case ENTITY_TOGGLE_SWIM -> {
+                var ev = event.getEntityToggleSwim();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityToggleSwimEvent", ev);
+            }
+            case ENTITY_TRANSFORM -> {
+                var ev = event.getEntityTransform();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityTransformEvent", ev);
+            }
+            case ENTITY_UNLEASH -> {
+                var ev = event.getEntityUnleash();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.EntityUnleashEvent", ev);
+            }
+            case EXP_BOTTLE -> {
+                var ev = event.getExpBottle();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ExpBottleEvent", ev);
+            }
+            case EXPLOSION_PRIME -> {
+                var ev = event.getExplosionPrime();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ExplosionPrimeEvent", ev);
+            }
+            case FIREWORK_EXPLODE -> {
+                var ev = event.getFireworkExplode();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.FireworkExplodeEvent", ev);
+            }
+            case FOOD_LEVEL_CHANGE -> {
+                var ev = event.getFoodLevelChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.FoodLevelChangeEvent", ev);
+            }
+            case HORSE_JUMP -> {
+                var ev = event.getHorseJump();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.HorseJumpEvent", ev);
+            }
+            case ITEM_DESPAWN -> {
+                var ev = event.getItemDespawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ItemDespawnEvent", ev);
+            }
+            case ITEM_MERGE -> {
+                var ev = event.getItemMerge();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ItemMergeEvent", ev);
+            }
+            case ITEM_SPAWN -> {
+                var ev = event.getItemSpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ItemSpawnEvent", ev);
+            }
+            case LINGERING_POTION_SPLASH -> {
+                var ev = event.getLingeringPotionSplash();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.LingeringPotionSplashEvent", ev);
+            }
+            case PIG_ZAP -> {
+                var ev = event.getPigZap();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PigZapEvent", ev);
+            }
+            case PIG_ZOMBIE_ANGER -> {
+                var ev = event.getPigZombieAnger();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PigZombieAngerEvent", ev);
+            }
+            case PIGLIN_BARTER -> {
+                var ev = event.getPiglinBarter();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PiglinBarterEvent", ev);
+            }
+            case POTION_SPLASH -> {
+                var ev = event.getPotionSplash();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.PotionSplashEvent", ev);
+            }
+            case PROJECTILE_HIT -> {
+                var ev = event.getProjectileHit();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ProjectileHitEvent", ev);
+            }
+            case PROJECTILE_LAUNCH -> {
+                var ev = event.getProjectileLaunch();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.ProjectileLaunchEvent", ev);
+            }
+            case SHEEP_DYE_WOOL -> {
+                var ev = event.getSheepDyeWool();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.SheepDyeWoolEvent", ev);
+            }
+            case SHEEP_REGROW_WOOL -> {
+                var ev = event.getSheepRegrowWool();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.SheepRegrowWoolEvent", ev);
+            }
+            case SLIME_SPLIT -> {
+                var ev = event.getSlimeSplit();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.SlimeSplitEvent", ev);
+            }
+            case SPAWNER_SPAWN -> {
+                var ev = event.getSpawnerSpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.SpawnerSpawnEvent", ev);
+            }
+            case STRIDER_TEMPERATURE_CHANGE -> {
+                var ev = event.getStriderTemperatureChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.StriderTemperatureChangeEvent", ev);
+            }
+            case TRIAL_SPAWNER_SPAWN -> {
+                var ev = event.getTrialSpawnerSpawn();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.TrialSpawnerSpawnEvent", ev);
+            }
+            case VILLAGER_ACQUIRE_TRADE -> {
+                var ev = event.getVillagerAcquireTrade();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.VillagerAcquireTradeEvent", ev);
+            }
+            case VILLAGER_CAREER_CHANGE -> {
+                var ev = event.getVillagerCareerChange();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.VillagerCareerChangeEvent", ev);
+            }
+            case VILLAGER_REPLENISH_TRADE -> {
+                var ev = event.getVillagerReplenishTrade();
+                yield createGenericBukkitEvent("org.bukkit.event.entity.VillagerReplenishTradeEvent", ev);
+            }
+            case VILLAGER_REPUTATION_CHANGE -> null;
+            case WARDEN_ANGER_CHANGE -> {
+                var ev = event.getWardenAngerChange();
+                yield createGenericBukkitEvent("io.papermc.paper.event.entity.WardenAngerChangeEvent", ev);
+            }
+            case RAID_FINISH -> {
+                var ev = event.getRaidFinish();
+                yield createGenericBukkitEvent("org.bukkit.event.raid.RaidFinishEvent", ev);
+            }
+            case RAID_SPAWN_WAVE -> {
+                var ev = event.getRaidSpawnWave();
+                yield createGenericBukkitEvent("org.bukkit.event.raid.RaidSpawnWaveEvent", ev);
+            }
+            case RAID_STOP -> {
+                var ev = event.getRaidStop();
+                yield createGenericBukkitEvent("org.bukkit.event.raid.RaidStopEvent", ev);
+            }
+            case RAID_TRIGGER -> {
+                var ev = event.getRaidTrigger();
+                yield createGenericBukkitEvent("org.bukkit.event.raid.RaidTriggerEvent", ev);
+            }
+            case ENCHANT_ITEM -> {
+                var ev = event.getEnchantItem();
+                yield createGenericBukkitEvent("org.bukkit.event.enchantment.EnchantItemEvent", ev);
+            }
+            case PREPARE_ITEM_ENCHANT -> {
+                var ev = event.getPrepareItemEnchant();
+                yield createGenericBukkitEvent("org.bukkit.event.enchantment.PrepareItemEnchantEvent", ev);
+            }
+            case DATA_NOT_SET -> null;
             default -> null;
         };
         } catch (Throwable t) {
-            LOGGER.log(java.util.logging.Level.SEVERE, "Exception in createEvent for " + event.getDataCase() + ": " + t.getMessage(), t);
-            t.printStackTrace();
+            LOGGER.log(Level.SEVERE, "Exception in createEvent for " + event.getDataCase() + ": " + t.getMessage(), t);
             return null;
         }
     }
@@ -285,156 +1191,104 @@ public class PatchBukkitEventFactory {
     public static byte[] toFireEventResponse(@NotNull org.bukkit.event.Event event) {
         try {
             boolean cancelled = event instanceof org.bukkit.event.Cancellable c && c.isCancelled();
-
-            FireEventResponse.Builder builder = FireEventResponse.newBuilder()
-                .setCancelled(cancelled);
-
-            Event.Builder eventBuilder = Event.newBuilder();
-
-        if (event instanceof org.bukkit.event.player.PlayerJoinEvent joinEvent) {
-            String joinMessage = GsonComponentSerializer.gson().serialize(joinEvent.joinMessage());
-
-            eventBuilder.setPlayerJoin(
-                PlayerJoinEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder()
-                        .setValue(joinEvent.getPlayer().getUniqueId().toString())
-                        .build())
-                    .setJoinMessage(joinMessage)
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerQuitEvent quitEvent) {
-            String quitMessage = quitEvent.quitMessage() != null ? GsonComponentSerializer.gson().serialize(quitEvent.quitMessage()) : "";
-
-            eventBuilder.setPlayerQuit(
-                PlayerQuitEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder()
-                        .setValue(quitEvent.getPlayer().getUniqueId().toString())
-                        .build())
-                    .setQuitMessage(quitMessage)
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerGameModeChangeEvent gmEvent) {
-            eventBuilder.setPlayerGamemodeChange(
-                PlayerGameModeChangeEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder()
-                        .setValue(gmEvent.getPlayer().getUniqueId().toString())
-                        .build())
-                    .setNewGamemode(gmEvent.getNewGameMode().name())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerInteractEvent interactEvent) {
-            var block = interactEvent.getClickedBlock();
-            int x = block != null ? block.getX() : 0;
-            int y = block != null ? block.getY() : 0;
-            int z = block != null ? block.getZ() : 0;
-
-            eventBuilder.setPlayerInteract(
-                PlayerInteractEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder()
-                        .setValue(interactEvent.getPlayer().getUniqueId().toString())
-                        .build())
-                    .setAction(interactEvent.getAction().name())
-                    .setClickedX(x)
-                    .setClickedY(y)
-                    .setClickedZ(z)
-                    .setBlockFace(interactEvent.getBlockFace().name())
-                    .setHand(interactEvent.getHand() != null ? interactEvent.getHand().name() : "HAND")
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.server.PluginEnableEvent enableEvent) {
-            eventBuilder.setPluginEnable(
-                PluginEnableEvent.newBuilder()
-                    .setPluginName(enableEvent.getPlugin().getName())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.server.PluginDisableEvent disableEvent) {
-            eventBuilder.setPluginDisable(
-                PluginDisableEvent.newBuilder()
-                    .setPluginName(disableEvent.getPlugin().getName())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.block.BlockBreakEvent breakEvent) {
-            var b = breakEvent.getBlock();
-            var bBuilder = BlockBreakEvent.newBuilder()
-                .setBlockX(b.getX())
-                .setBlockY(b.getY())
-                .setBlockZ(b.getZ())
-                .setBlockType(b.getType().name())
-                .setExp(breakEvent.getExpToDrop())
-                .setDropItems(breakEvent.isDropItems());
-            if (breakEvent.getPlayer() != null) {
-                bBuilder.setPlayerUuid(UUID.newBuilder().setValue(breakEvent.getPlayer().getUniqueId().toString()).build());
-            }
-            eventBuilder.setBlockBreak(bBuilder.build());
-        } else if (event instanceof org.bukkit.event.block.BlockPlaceEvent placeEvent) {
-            var b = placeEvent.getBlockPlaced();
-            var against = placeEvent.getBlockAgainst();
-            eventBuilder.setBlockPlace(
-                BlockPlaceEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(placeEvent.getPlayer().getUniqueId().toString()).build())
-                    .setBlockX(b.getX())
-                    .setBlockY(b.getY())
-                    .setBlockZ(b.getZ())
-                    .setBlockPlacedType(b.getType().name())
-                    .setBlockAgainstType(against.getType().name())
-                    .setCanBuild(placeEvent.canBuild())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerToggleSneakEvent sneakEvent) {
-            eventBuilder.setPlayerToggleSneak(
-                PlayerToggleSneakEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(sneakEvent.getPlayer().getUniqueId().toString()).build())
-                    .setIsSneaking(sneakEvent.isSneaking())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerToggleSprintEvent sprintEvent) {
-            eventBuilder.setPlayerToggleSprint(
-                PlayerToggleSprintEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(sprintEvent.getPlayer().getUniqueId().toString()).build())
-                    .setIsSprinting(sprintEvent.isSprinting())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerToggleFlightEvent flightEvent) {
-            eventBuilder.setPlayerToggleFlight(
-                PlayerToggleFlightEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(flightEvent.getPlayer().getUniqueId().toString()).build())
-                    .setIsFlying(flightEvent.isFlying())
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.PlayerMoveEvent moveEvent) {
-            eventBuilder.setPlayerMove(
-                PlayerMoveEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(moveEvent.getPlayer().getUniqueId().toString()).build())
-                    .setFrom(org.patchbukkit.bridge.BridgeUtils.convertLocation(moveEvent.getFrom()))
-                    .setTo(org.patchbukkit.bridge.BridgeUtils.convertLocation(moveEvent.getTo()))
-                    .build()
-            );
-        } else if (event instanceof org.bukkit.event.player.AsyncPlayerChatEvent chatEvent) {
-            eventBuilder.setPlayerChat(
-                PlayerChatEvent.newBuilder()
-                    .setPlayerUuid(UUID.newBuilder().setValue(chatEvent.getPlayer().getUniqueId().toString()).build())
-                    .setMessage(chatEvent.getMessage())
-                    .setFormat(chatEvent.getFormat())
-                    .build()
-            );
-        }
-
-        builder.setData(eventBuilder.build());
-
-        return builder.build().toByteArray();
+            return FireEventResponse.newBuilder()
+                .setCancelled(cancelled)
+                .build()
+                .toByteArray();
         } catch (Throwable t) {
-            LOGGER.log(java.util.logging.Level.SEVERE, "Exception serializing event response for " + event.getEventName() + ": " + t.getMessage(), t);
-            t.printStackTrace();
+            LOGGER.log(Level.SEVERE, "Exception serializing event response: " + t.getMessage(), t);
             return FireEventResponse.newBuilder().setCancelled(false).build().toByteArray();
         }
     }
 
-    public static boolean isCancellable(@NotNull org.bukkit.event.Event event) {
-        return event instanceof org.bukkit.event.Cancellable;
+    @Nullable
+    private static org.bukkit.event.Event createGenericBukkitEvent(String className, com.google.protobuf.Message protoMsg) {
+        try {
+            Class<?> clazz = Class.forName(className);
+            java.util.List<Object> argsList = new java.util.ArrayList<>();
+            World defaultWorld = Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
+
+            for (var desc : protoMsg.getDescriptorForType().getFields()) {
+                Object val = protoMsg.getField(desc);
+                String name = desc.getName();
+                if (name.contains("player_uuid") && val instanceof patchbukkit.common.UUID u) {
+                    Player p = getPlayer(u.getValue());
+                    if (p != null) argsList.add(p);
+                } else if (name.contains("entity_id") && val instanceof Integer eid) {
+                    Entity ent = getEntity(eid);
+                    if (ent != null) argsList.add(ent);
+                } else if (name.contains("world_uuid") && val instanceof patchbukkit.common.UUID u) {
+                    World w = getWorld(u.getValue());
+                    if (w != null) argsList.add(w);
+                } else if (name.endsWith("_x") && val instanceof Number xNum) {
+                    int x = xNum.intValue();
+                    int y = 64;
+                    int z = 0;
+                    var yDesc = protoMsg.getDescriptorForType().findFieldByName(name.substring(0, name.length() - 2) + "_y");
+                    var zDesc = protoMsg.getDescriptorForType().findFieldByName(name.substring(0, name.length() - 2) + "_z");
+                    if (yDesc != null && protoMsg.getField(yDesc) instanceof Number yn) y = yn.intValue();
+                    if (zDesc != null && protoMsg.getField(zDesc) instanceof Number zn) z = zn.intValue();
+                    if (defaultWorld != null) {
+                        Block b = defaultWorld.getBlockAt(x, y, z);
+                        argsList.add(b);
+                        argsList.add(b.getState());
+                        argsList.add(new Location(defaultWorld, x, y, z));
+                    }
+                } else {
+                    argsList.add(val);
+                }
+            }
+            if (defaultWorld != null) {
+                argsList.add(defaultWorld);
+            }
+            return instantiateBukkitEvent(clazz, argsList.toArray());
+        } catch (Throwable t) {
+            return null;
+        }
     }
 
     @Nullable
-    private static Player getPlayer(@NotNull String uuidStr) {
+    private static org.bukkit.event.Event instantiateBukkitEvent(Class<?> clazz, Object... args) {
+        for (Constructor<?> ctor : clazz.getConstructors()) {
+            Class<?>[] paramTypes = ctor.getParameterTypes();
+            Object[] matchedArgs = new Object[paramTypes.length];
+            boolean match = true;
+            for (int i = 0; i < paramTypes.length; i++) {
+                Class<?> pt = paramTypes[i];
+                Object found = null;
+                for (Object a : args) {
+                    if (a != null && pt.isAssignableFrom(a.getClass())) {
+                        found = a;
+                        break;
+                    }
+                }
+                if (found != null) {
+                    matchedArgs[i] = found;
+                } else if (pt == boolean.class) {
+                    matchedArgs[i] = false;
+                } else if (pt == int.class) {
+                    matchedArgs[i] = 0;
+                } else if (pt == double.class) {
+                    matchedArgs[i] = 0.0;
+                } else if (pt == float.class) {
+                    matchedArgs[i] = 0.0f;
+                } else if (pt == long.class) {
+                    matchedArgs[i] = 0L;
+                } else if (pt == String.class) {
+                    matchedArgs[i] = "";
+                } else {
+                    matchedArgs[i] = null;
+                }
+            }
+            try {
+                return (org.bukkit.event.Event) ctor.newInstance(matchedArgs);
+            } catch (Throwable ignored) {}
+        }
+        return null;
+    }
+
+    @Nullable
+    public static Player getPlayer(@NotNull String uuidStr) {
         try {
             java.util.UUID uuid = java.util.UUID.fromString(uuidStr);
             Player player = Bukkit.getServer().getPlayer(uuid);
@@ -446,8 +1300,22 @@ public class PatchBukkitEventFactory {
             }
             return player;
         } catch (IllegalArgumentException e) {
-            LOGGER.severe("EventFactory: Invalid UUID string: " + uuidStr);
             return null;
         }
     }
+
+    @NotNull
+    public static Entity getEntity(int entityId) {
+        return new org.patchbukkit.entity.PatchBukkitEntity(new java.util.UUID(0, entityId), "Entity-" + entityId);
+    }
+
+    @Nullable
+    public static World getWorld(@NotNull String uuidStr) {
+        try {
+            java.util.UUID uuid = java.util.UUID.fromString(uuidStr);
+            return Bukkit.getWorld(uuid);
+        } catch (Exception e) {
+            return Bukkit.getWorlds().isEmpty() ? null : Bukkit.getWorlds().get(0);
+        }
+    }
 }
diff --git a/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventManager.java b/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventManager.java
index 02caa92..83306c1 100644
--- a/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventManager.java
+++ b/java/patchbukkit/src/main/java/org/patchbukkit/events/PatchBukkitEventManager.java
@@ -20,21 +20,7 @@ import co.aikar.timings.TimedEventExecutor;
 
 import org.jetbrains.annotations.NotNull;
 import patchbukkit.bridge.NativeBridgeFfi;
-import patchbukkit.events.BlockBreakEvent;
-import patchbukkit.events.BlockPlaceEvent;
 import patchbukkit.events.CallEventRequest;
-import patchbukkit.events.PlayerChatEvent;
-import patchbukkit.events.PlayerGameModeChangeEvent;
-import patchbukkit.events.PlayerInteractEvent;
-import patchbukkit.events.PlayerJoinEvent;
-import patchbukkit.events.PlayerInteractEntityEvent;
-import patchbukkit.events.PlayerMoveEvent;
-import patchbukkit.events.PlayerQuitEvent;
-import patchbukkit.events.PlayerToggleFlightEvent;
-import patchbukkit.events.PlayerToggleSneakEvent;
-import patchbukkit.events.PlayerToggleSprintEvent;
-import patchbukkit.events.PluginDisableEvent;
-import patchbukkit.events.PluginEnableEvent;
 import patchbukkit.events.RegisterEventRequest;
 
 import java.lang.reflect.Method;
diff --git a/proto/patchbukkit/events/block_events.proto b/proto/patchbukkit/events/block_events.proto
index 98b6206..7d1d552 100644
--- a/proto/patchbukkit/events/block_events.proto
+++ b/proto/patchbukkit/events/block_events.proto
@@ -6,24 +6,353 @@ import "patchbukkit/common/types.proto";
 option java_multiple_files = true;
 option java_package = "patchbukkit.events";
 
+message BellResonateEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+}
+
+message BellRingEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID entity_uuid = 5;
+}
+
 message BlockBreakEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string block = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+  uint32 exp = 6;
+  bool drop = 7;
+}
+
+message BlockBrushEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID player_uuid = 5;
+  string item_name = 6;
+  int32 item_count = 7;
+}
+
+message BlockBurnEvent {
+  string igniting_block = 1;
+  string block = 2;
+}
+
+message BlockCanBuildEvent {
+  string block_to_build = 1;
+  bool buildable = 2;
+  patchbukkit.common.UUID player_uuid = 3;
+  string block = 4;
+}
+
+message BlockCookEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  string source_name = 5;
+  int32 source_count = 6;
+  string result_name = 7;
+  int32 result_count = 8;
+}
+
+message BlockDamageEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string block = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+  bool insta_break = 6;
+}
+
+message BlockDamageAbortEvent {
   patchbukkit.common.UUID player_uuid = 1;
   int32 block_x = 2;
   int32 block_y = 3;
   int32 block_z = 4;
-  string block_type = 5;
-  uint32 exp = 6;
-  bool drop_items = 7;
+  patchbukkit.common.UUID world_uuid = 5;
+  string item_in_hand_name = 6;
+  int32 item_in_hand_count = 7;
+}
+
+message BlockDispenseEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string item_name = 4;
+}
+
+message BlockDispenseArmorEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID target_uuid = 5;
+  string item_name = 6;
+  int32 item_count = 7;
+}
+
+message BlockDispenseLootEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  repeated string items_names = 5;
+}
+
+message BlockDropItemEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID player_uuid = 5;
+  repeated string items_names = 6;
+}
+
+message BlockExpEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 exp = 5;
+}
+
+message BlockExplodeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  float yield_rate = 4;
+}
+
+message BlockFadeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string block = 4;
+}
+
+message BlockFertilizeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID player_uuid = 5;
+}
+
+message BlockFormEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string block = 4;
+}
+
+message BlockFromToEvent {
+  int32 from_pos_x = 1;
+  int32 from_pos_y = 2;
+  int32 from_pos_z = 3;
+  int32 to_pos_x = 4;
+  int32 to_pos_y = 5;
+  int32 to_pos_z = 6;
+  string block = 7;
+}
+
+message BlockGrowEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+  string old_block = 2;
+  int32 old_state_id = 3;
+  string new_block = 4;
+  int32 new_state_id = 5;
+  int32 block_x = 6;
+  int32 block_y = 7;
+  int32 block_z = 8;
+}
+
+message BlockIgniteEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string igniting_block = 4;
+  patchbukkit.common.UUID player_uuid = 5;
+}
+
+message BlockMultiPlaceEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID world_uuid = 2;
+}
+
+message BlockPhysicsEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  int32 changed_pos_x = 4;
+  int32 changed_pos_y = 5;
+  int32 changed_pos_z = 6;
+}
+
+message BlockPistonExtendEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string direction = 4;
+}
+
+message BlockPistonRetractEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string direction = 4;
 }
 
 message BlockPlaceEvent {
   patchbukkit.common.UUID player_uuid = 1;
+  string block_placed = 2;
+  string block_placed_against = 3;
+  int32 block_x = 4;
+  int32 block_y = 5;
+  int32 block_z = 6;
+  bool can_build = 7;
+}
+
+message BlockReceiveGameEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  string game_event = 5;
+  patchbukkit.common.UUID source_entity_uuid = 6;
+}
+
+message BlockRedstoneEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+  int32 block_state_id = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+  int32 old_current = 6;
+  int32 new_current = 7;
+}
+
+message BlockShearEntityEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  patchbukkit.common.UUID target_uuid = 5;
+  string item_name = 6;
+  int32 item_count = 7;
+}
+
+message BlockSpreadEvent {
+  int32 source_pos_x = 1;
+  int32 source_pos_y = 2;
+  int32 source_pos_z = 3;
+  int32 target_pos_x = 4;
+  int32 target_pos_y = 5;
+  int32 target_pos_z = 6;
+  patchbukkit.common.UUID world_uuid = 7;
+  int32 new_state_id = 8;
+}
+
+message BrewingStartEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 brewing_time = 5;
+}
+
+message CampfireStartEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  string item_name = 5;
+  int32 item_count = 6;
+  uint32 slot = 7;
+  int32 cooking_time = 8;
+}
+
+message CauldronLevelChangeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 old_level = 5;
+  int32 new_level = 6;
+  string reason = 7;
+  patchbukkit.common.UUID entity_uuid = 8;
+}
+
+message CrafterCraftEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  string result_name = 5;
+  int32 result_count = 6;
+}
+
+message EntityBlockFormEvent {
+  patchbukkit.common.UUID entity_uuid = 1;
   int32 block_x = 2;
   int32 block_y = 3;
   int32 block_z = 4;
-  string block_placed_type = 5;
-  string block_against_type = 6;
-  bool can_build = 7;
+  patchbukkit.common.UUID world_uuid = 5;
+  int32 new_state_id = 6;
+}
+
+message FluidLevelChangeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 new_state_id = 5;
+}
+
+message InventoryBlockStartEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+}
+
+message LeavesDecayEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+}
+
+message MoistureChangeEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 new_moisture = 5;
+}
+
+message NotePlayEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string instrument = 4;
+  uint32 note = 5;
+}
+
+message SculkBloomEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  patchbukkit.common.UUID world_uuid = 4;
+  int32 charge = 5;
 }
 
 message SignChangeEvent {
@@ -34,39 +363,24 @@ message SignChangeEvent {
   repeated string lines = 5;
 }
 
-message BlockDamageEvent {
-  patchbukkit.common.UUID player_uuid = 1;
-  int32 block_x = 2;
-  int32 block_y = 3;
-  int32 block_z = 4;
-  bool insta_break = 5;
-}
-
-message BlockIgniteEvent {
-  patchbukkit.common.UUID player_uuid = 1;
-  int32 block_x = 2;
-  int32 block_y = 3;
-  int32 block_z = 4;
-  string ignite_cause = 5;
-}
-
-message BlockGrowEvent {
+message SpongeAbsorbEvent {
   int32 block_x = 1;
   int32 block_y = 2;
   int32 block_z = 3;
-  string new_block_type = 4;
 }
 
-message BlockFormEvent {
+message TNTPrimeEvent {
   int32 block_x = 1;
   int32 block_y = 2;
   int32 block_z = 3;
-  string new_block_type = 4;
+  string prime_reason = 4;
 }
 
-message BlockFadeEvent {
+message VaultDisplayItemEvent {
   int32 block_x = 1;
   int32 block_y = 2;
   int32 block_z = 3;
-  string new_block_type = 4;
+  patchbukkit.common.UUID world_uuid = 4;
+  string item_name = 5;
+  int32 item_count = 6;
 }
diff --git a/proto/patchbukkit/events/dialog_events.proto b/proto/patchbukkit/events/dialog_events.proto
new file mode 100644
index 0000000..75e6a8b
--- /dev/null
+++ b/proto/patchbukkit/events/dialog_events.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message DialogClearEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message DialogClickActionEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string id = 2;
+  bytes payload = 3;
+}
+
+message DialogShowEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
diff --git a/proto/patchbukkit/events/enchantment_events.proto b/proto/patchbukkit/events/enchantment_events.proto
new file mode 100644
index 0000000..5fced88
--- /dev/null
+++ b/proto/patchbukkit/events/enchantment_events.proto
@@ -0,0 +1,25 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message EnchantItemEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+  int32 item_count = 3;
+  int32 option = 4;
+  int32 exp_level_cost = 5;
+}
+
+message PrepareItemEnchantEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+  int32 item_count = 3;
+  repeated int32 level_requirements = 4;
+  repeated int32 enchantment_id = 5;
+  repeated int32 enchantment_level = 6;
+  int32 bookshelf_count = 7;
+}
diff --git a/proto/patchbukkit/events/entity_events.proto b/proto/patchbukkit/events/entity_events.proto
new file mode 100644
index 0000000..8600099
--- /dev/null
+++ b/proto/patchbukkit/events/entity_events.proto
@@ -0,0 +1,482 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message AreaEffectCloudApplyEvent {
+  int32 entity_id = 1;
+  repeated int32 affected_entities = 2;
+}
+
+message ArrowBodyCountChangeEvent {
+  int32 entity_id = 1;
+  uint32 old_amount = 2;
+  uint32 new_amount = 3;
+}
+
+message BatToggleSleepEvent {
+  int32 entity_id = 1;
+  bool is_awake = 2;
+}
+
+message CreatureSpawnEvent {
+  int32 entity_id = 1;
+  string entity_type = 2;
+  double pos_x = 3;
+  double pos_y = 4;
+  double pos_z = 5;
+  patchbukkit.common.UUID world_uuid = 6;
+  string spawn_reason = 7;
+}
+
+message CreeperPowerEvent {
+  int32 entity_id = 1;
+  string cause = 2;
+}
+
+message EnderDragonChangePhaseEvent {
+  int32 entity_id = 1;
+  string current_phase = 2;
+  string new_phase = 3;
+}
+
+message EntityAirChangeEvent {
+  int32 entity_id = 1;
+  int32 amount = 2;
+}
+
+message EntityBreakDoorEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message EntityBreedEvent {
+  int32 father_id = 1;
+  int32 mother_id = 2;
+  int32 child_id = 3;
+}
+
+message EntityChangeBlockEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string new_block = 5;
+}
+
+message EntityCombustEvent {
+  int32 entity_id = 1;
+  float duration_secs = 2;
+}
+
+message EntityCombustByBlockEvent {
+  int32 entity_id = 1;
+  int32 combuster_x = 2;
+  int32 combuster_y = 3;
+  int32 combuster_z = 4;
+  float duration = 5;
+}
+
+message EntityCombustByEntityEvent {
+  int32 entity_id = 1;
+  int32 combuster_id = 2;
+  float duration = 3;
+}
+
+message EntityDamageEvent {
+  int32 entity_id = 1;
+  float damage = 2;
+  string damage_type = 3;
+}
+
+message EntityDamageByBlockEvent {
+  int32 entity_id = 1;
+  int32 damager_pos_x = 2;
+  int32 damager_pos_y = 3;
+  int32 damager_pos_z = 4;
+  float damage = 5;
+  string cause = 6;
+}
+
+message EntityDamageByEntityEvent {
+  int32 entity_id = 1;
+  int32 damager_id = 2;
+  float damage = 3;
+  string cause = 4;
+}
+
+message EntityDeathEvent {
+  int32 entity_id = 1;
+  int32 dropped_exp = 2;
+}
+
+message PlayerDeathEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string death_message = 2;
+  int32 dropped_exp = 3;
+  bool keep_inventory = 4;
+}
+
+message EntityDismountEvent {
+  int32 entity_id = 1;
+  int32 dismounted_id = 2;
+}
+
+message EntityDropItemEvent {
+  int32 entity_id = 1;
+  string item_name = 2;
+  uint32 count = 3;
+}
+
+message EntityDyeEvent {
+  int32 entity_id = 1;
+  string color = 2;
+  patchbukkit.common.UUID player_uuid = 3;
+}
+
+message EntityEnterBlockEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message EntityEnterLoveModeEvent {
+  int32 entity_id = 1;
+  int32 ticks_in_love = 2;
+}
+
+message EntityExhaustionEvent {
+  int32 entity_id = 1;
+  float exhaustion = 2;
+}
+
+message EntityExplodeEvent {
+  int32 entity_id = 1;
+  double pos_x = 2;
+  double pos_y = 3;
+  double pos_z = 4;
+  float yield_rate = 5;
+}
+
+message EntityInteractEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message EntityKnockbackEvent {
+  int32 entity_id = 1;
+  double knockback_x = 2;
+  double knockback_y = 3;
+  double knockback_z = 4;
+}
+
+message EntityKnockbackByEntityEvent {
+  int32 entity_id = 1;
+  int32 hit_by_id = 2;
+  double force = 3;
+  double x = 4;
+  double z = 5;
+}
+
+message EntityMountEvent {
+  int32 entity_id = 1;
+  int32 mount_id = 2;
+}
+
+message EntityPickupItemEvent {
+  int32 entity_id = 1;
+  string item_name = 2;
+  uint32 count = 3;
+}
+
+message EntityPlaceEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string block_name = 5;
+}
+
+message EntityPortalEvent {
+  int32 entity_id = 1;
+  int32 portal_pos_x = 2;
+  int32 portal_pos_y = 3;
+  int32 portal_pos_z = 4;
+}
+
+message EntityPortalEnterEvent {
+  int32 entity_id = 1;
+  int32 location_x = 2;
+  int32 location_y = 3;
+  int32 location_z = 4;
+}
+
+message EntityPortalExitEvent {
+  int32 entity_id = 1;
+  int32 from_pos_x = 2;
+  int32 from_pos_y = 3;
+  int32 from_pos_z = 4;
+  int32 to_pos_x = 5;
+  int32 to_pos_y = 6;
+  int32 to_pos_z = 7;
+}
+
+message EntityPoseChangeEvent {
+  int32 entity_id = 1;
+  string pose = 2;
+}
+
+message EntityPotionEffectEvent {
+  int32 entity_id = 1;
+  string effect_name = 2;
+  int32 duration = 3;
+  uint32 amplifier = 4;
+}
+
+message EntityRegainHealthEvent {
+  int32 entity_id = 1;
+  float amount = 2;
+}
+
+message EntityRemoveEvent {
+  int32 entity_id = 1;
+  string cause = 2;
+}
+
+message EntityResurrectEvent {
+  int32 entity_id = 1;
+}
+
+message EntityShootBowEvent {
+  int32 entity_id = 1;
+  string weapon_name = 2;
+  float force = 3;
+}
+
+message EntitySpawnEvent {
+  int32 entity_id = 1;
+  string entity_type = 2;
+  double pos_x = 3;
+  double pos_y = 4;
+  double pos_z = 5;
+  patchbukkit.common.UUID world_uuid = 6;
+}
+
+message EntitySpellCastEvent {
+  int32 entity_id = 1;
+  string spell = 2;
+}
+
+message EntityTameEvent {
+  int32 entity_id = 1;
+  patchbukkit.common.UUID owner_uuid = 2;
+}
+
+message EntityTargetEvent {
+  int32 entity_id = 1;
+}
+
+message EntityTargetBlockEvent {
+  int32 entity_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message EntityTargetLivingEntityEvent {
+  int32 entity_id = 1;
+  string reason = 2;
+}
+
+message EntityTeleportEvent {
+  int32 entity_id = 1;
+  double from_position_x = 2;
+  double from_position_y = 3;
+  double from_position_z = 4;
+  double to_position_x = 5;
+  double to_position_y = 6;
+  double to_position_z = 7;
+}
+
+message EntityToggleGlideEvent {
+  int32 entity_id = 1;
+  bool is_gliding = 2;
+}
+
+message EntityToggleSwimEvent {
+  int32 entity_id = 1;
+  bool is_swimming = 2;
+}
+
+message EntityTransformEvent {
+  int32 entity_id = 1;
+  int32 new_entity_id = 2;
+  string transform_reason = 3;
+}
+
+message EntityUnleashEvent {
+  int32 entity_id = 1;
+  string reason = 2;
+}
+
+message ExpBottleEvent {
+  int32 entity_id = 1;
+  int32 experience = 2;
+  int32 location_x = 3;
+  int32 location_y = 4;
+  int32 location_z = 5;
+  bool show_effect = 6;
+}
+
+message ExplosionPrimeEvent {
+  int32 entity_id = 1;
+  float radius = 2;
+  bool fire = 3;
+}
+
+message FireworkExplodeEvent {
+  int32 entity_id = 1;
+}
+
+message FoodLevelChangeEvent {
+  int32 entity_id = 1;
+  uint32 food_level = 2;
+}
+
+message HorseJumpEvent {
+  int32 entity_id = 1;
+  float power = 2;
+}
+
+message ItemDespawnEvent {
+  int32 entity_id = 1;
+}
+
+message ItemMergeEvent {
+  int32 entity_id = 1;
+  int32 target_id = 2;
+}
+
+message ItemSpawnEvent {
+  int32 entity_id = 1;
+  double pos_x = 2;
+  double pos_y = 3;
+  double pos_z = 4;
+  string item_name = 5;
+}
+
+message LingeringPotionSplashEvent {
+  int32 entity_id = 1;
+  int32 location_x = 2;
+  int32 location_y = 3;
+  int32 location_z = 4;
+  string potion_item = 5;
+}
+
+message PigZapEvent {
+  int32 entity_id = 1;
+  int32 lightning_id = 2;
+  int32 pig_zombie_id = 3;
+}
+
+message PigZombieAngerEvent {
+  int32 entity_id = 1;
+  int32 new_anger = 2;
+}
+
+message PiglinBarterEvent {
+  int32 entity_id = 1;
+  string input_item_name = 2;
+  int32 input_item_count = 3;
+  repeated string outcome_names = 4;
+}
+
+message PotionSplashEvent {
+  int32 entity_id = 1;
+  int32 location_x = 2;
+  int32 location_y = 3;
+  int32 location_z = 4;
+  string potion_item = 5;
+  repeated int32 affected_entities = 6;
+}
+
+message ProjectileHitEvent {
+  int32 entity_id = 1;
+  double hit_position_x = 2;
+  double hit_position_y = 3;
+  double hit_position_z = 4;
+}
+
+message ProjectileLaunchEvent {
+  int32 entity_id = 1;
+}
+
+message SheepDyeWoolEvent {
+  int32 entity_id = 1;
+  uint32 dye_color = 2;
+}
+
+message SheepRegrowWoolEvent {
+  int32 entity_id = 1;
+}
+
+message SlimeSplitEvent {
+  int32 entity_id = 1;
+  int32 count = 2;
+}
+
+message SpawnerSpawnEvent {
+  int32 entity_id = 1;
+  int32 spawner_pos_x = 2;
+  int32 spawner_pos_y = 3;
+  int32 spawner_pos_z = 4;
+}
+
+message StriderTemperatureChangeEvent {
+  int32 entity_id = 1;
+  bool is_shivering = 2;
+}
+
+message TrialSpawnerSpawnEvent {
+  int32 entity_id = 1;
+  int32 spawner_pos_x = 2;
+  int32 spawner_pos_y = 3;
+  int32 spawner_pos_z = 4;
+}
+
+message VillagerAcquireTradeEvent {
+  int32 entity_id = 1;
+  int32 recipe_index = 2;
+}
+
+message VillagerCareerChangeEvent {
+  int32 entity_id = 1;
+  string profession = 2;
+  string reason = 3;
+}
+
+message VillagerReplenishTradeEvent {
+  int32 entity_id = 1;
+  int32 restock_quantity = 2;
+}
+
+message VillagerReputationChangeEvent {
+  int32 entity_id = 1;
+  int32 target_id = 2;
+  int32 reputation_change = 3;
+}
+
+message WardenAngerChangeEvent {
+  int32 entity_id = 1;
+  int32 target_id = 2;
+  int32 old_anger = 3;
+  int32 new_anger = 4;
+}
diff --git a/proto/patchbukkit/events/event.proto b/proto/patchbukkit/events/event.proto
index 1b96f0e..ae6a6b3 100644
--- a/proto/patchbukkit/events/event.proto
+++ b/proto/patchbukkit/events/event.proto
@@ -1,57 +1,322 @@
 syntax = "proto3";
-
 package patchbukkit.events;
 
 import "patchbukkit/common/types.proto";
-import "patchbukkit/events/player_events.proto";
-import "patchbukkit/events/server_events.proto";
 import "patchbukkit/events/block_events.proto";
+import "patchbukkit/events/dialog_events.proto";
+import "patchbukkit/events/enchantment_events.proto";
+import "patchbukkit/events/entity_events.proto";
+import "patchbukkit/events/hanging_events.proto";
+import "patchbukkit/events/inventory_events.proto";
+import "patchbukkit/events/player_events.proto";
+import "patchbukkit/events/raid_events.proto";
+import "patchbukkit/events/server_events.proto";
+import "patchbukkit/events/vehicle_events.proto";
+import "patchbukkit/events/world_events.proto";
 
 option java_multiple_files = true;
 option java_package = "patchbukkit.events";
 
 message Event {
   oneof data {
-    PlayerJoinEvent player_join = 1;
-    PluginEnableEvent plugin_enable = 2;
-    PluginDisableEvent plugin_disable = 3;
-    PlayerQuitEvent player_quit = 4;
-    PlayerInteractEvent player_interact = 5;
-    PlayerGameModeChangeEvent player_gamemode_change = 6;
-    BlockBreakEvent block_break = 7;
-    BlockPlaceEvent block_place = 8;
-    PlayerToggleSneakEvent player_toggle_sneak = 9;
-    PlayerToggleSprintEvent player_toggle_sprint = 10;
-    PlayerToggleFlightEvent player_toggle_flight = 11;
-    PlayerChatEvent player_chat = 12;
-    PlayerMoveEvent player_move = 13;
-    PlayerInteractEntityEvent player_interact_entity = 14;
-    SignChangeEvent sign_change = 15;
-    BlockDamageEvent block_damage = 16;
-    ServerCommandEvent server_command = 17;
-    BlockIgniteEvent block_ignite = 18;
-    BlockGrowEvent block_grow = 19;
-    BlockFormEvent block_form = 20;
-    BlockFadeEvent block_fade = 21;
+    AsyncStructureGenerateEvent async_structure_generate = 1;
+    AsyncStructureSpawnEvent async_structure_spawn = 2;
+    ChunkLoad chunk_load = 3;
+    ChunkPopulateEvent chunk_populate = 4;
+    ChunkSave chunk_save = 5;
+    ChunkSend chunk_send = 6;
+    ChunkUnloadEvent chunk_unload = 7;
+    EntitiesLoadEvent entities_load = 8;
+    EntitiesUnloadEvent entities_unload = 9;
+    GenericGameEvent generic_game = 10;
+    LightningStrikeEvent lightning_strike = 11;
+    LootGenerateEvent loot_generate = 12;
+    PortalCreateEvent portal_create = 13;
+    SpawnChangeEvent spawn_change = 14;
+    StructureGrowEvent structure_grow = 15;
+    TimeSkipEvent time_skip = 16;
+    WeatherChangeEvent weather_change = 17;
+    ThunderChangeEvent thunder_change = 18;
+    WorldInitEvent world_init = 19;
+    WorldLoadEvent world_load = 20;
+    WorldUnloadEvent world_unload = 21;
+    WorldSaveEvent world_save = 22;
+    ServerListPingEvent server_list_ping = 23;
+    MapInitializeEvent map_initialize = 24;
+    PacketReceivedEvent packet_received = 25;
+    PacketSentEvent packet_sent = 26;
+    PluginDisableEvent plugin_disable = 27;
+    PluginEnableEvent plugin_enable = 28;
+    RemoteServerCommandEvent remote_server_command = 29;
+    ServerBroadcastEvent server_broadcast = 30;
+    ServerCommandEvent server_command = 31;
+    ServerLoadEvent server_load = 32;
+    ServerTickEndEvent server_tick_end = 33;
+    ServerTickStartEvent server_tick_start = 34;
+    ServiceRegisterEvent service_register = 35;
+    ServiceUnregisterEvent service_unregister = 36;
+    TabCompleteEvent tab_complete = 37;
+    VehicleBlockCollisionEvent vehicle_block_collision = 38;
+    VehicleCollisionEvent vehicle_collision = 39;
+    VehicleCreateEvent vehicle_create = 40;
+    VehicleDamageEvent vehicle_damage = 41;
+    VehicleDestroyEvent vehicle_destroy = 42;
+    VehicleEnterEvent vehicle_enter = 43;
+    VehicleEntityCollisionEvent vehicle_entity_collision = 44;
+    VehicleExitEvent vehicle_exit = 45;
+    VehicleMoveEvent vehicle_move = 46;
+    VehicleUpdateEvent vehicle_update = 47;
+    BrewEvent brew = 48;
+    BrewingStandFuelEvent brewing_stand_fuel = 49;
+    CraftItemEvent craft_item = 50;
+    FurnaceBurnEvent furnace_burn = 51;
+    FurnaceExtractEvent furnace_extract = 52;
+    FurnaceSmeltEvent furnace_smelt = 53;
+    FurnaceStartSmeltEvent furnace_start_smelt = 54;
+    HopperInventorySearchEvent hopper_inventory_search = 55;
+    InventoryCreativeEvent inventory_creative = 56;
+    InventoryDragEvent inventory_drag = 57;
+    InventoryInteractEvent inventory_interact = 58;
+    InventoryMoveItemEvent inventory_move_item = 59;
+    InventoryOpenEvent inventory_open = 60;
+    InventoryPickupItemEvent inventory_pickup_item = 61;
+    PrepareAnvilEvent prepare_anvil = 62;
+    PrepareGrindstoneEvent prepare_grindstone = 63;
+    PrepareInventoryResultEvent prepare_inventory_result = 64;
+    PrepareItemCraftEvent prepare_item_craft = 65;
+    PrepareSmithingEvent prepare_smithing = 66;
+    SmithItemEvent smith_item = 67;
+    TradeSelectEvent trade_select = 68;
+    BellResonateEvent bell_resonate = 69;
+    BellRingEvent bell_ring = 70;
+    BlockBreakEvent block_break = 71;
+    BlockBrushEvent block_brush = 72;
+    BlockBurnEvent block_burn = 73;
+    BlockCanBuildEvent block_can_build = 74;
+    BlockCookEvent block_cook = 75;
+    BlockDamageEvent block_damage = 76;
+    BlockDamageAbortEvent block_damage_abort = 77;
+    BlockDispenseEvent block_dispense = 78;
+    BlockDispenseArmorEvent block_dispense_armor = 79;
+    BlockDispenseLootEvent block_dispense_loot = 80;
+    BlockDropItemEvent block_drop_item = 81;
+    BlockExpEvent block_exp = 82;
+    BlockExplodeEvent block_explode = 83;
+    BlockFadeEvent block_fade = 84;
+    BlockFertilizeEvent block_fertilize = 85;
+    BlockFormEvent block_form = 86;
+    BlockFromToEvent block_from_to = 87;
+    BlockGrowEvent block_grow = 88;
+    BlockIgniteEvent block_ignite = 89;
+    BlockMultiPlaceEvent block_multi_place = 90;
+    BlockPhysicsEvent block_physics = 91;
+    BlockPistonExtendEvent block_piston_extend = 92;
+    BlockPistonRetractEvent block_piston_retract = 93;
+    BlockPlaceEvent block_place = 94;
+    BlockReceiveGameEvent block_receive_game = 95;
+    BlockRedstoneEvent block_redstone = 96;
+    BlockShearEntityEvent block_shear_entity = 97;
+    BlockSpreadEvent block_spread = 98;
+    BrewingStartEvent brewing_start = 99;
+    CampfireStartEvent campfire_start = 100;
+    CauldronLevelChangeEvent cauldron_level_change = 101;
+    CrafterCraftEvent crafter_craft = 102;
+    EntityBlockFormEvent entity_block_form = 103;
+    FluidLevelChangeEvent fluid_level_change = 104;
+    InventoryBlockStartEvent inventory_block_start = 105;
+    LeavesDecayEvent leaves_decay = 106;
+    MoistureChangeEvent moisture_change = 107;
+    NotePlayEvent note_play = 108;
+    SculkBloomEvent sculk_bloom = 109;
+    SignChangeEvent sign_change = 110;
+    SpongeAbsorbEvent sponge_absorb = 111;
+    TNTPrimeEvent tnt_prime = 112;
+    VaultDisplayItemEvent vault_display_item = 113;
+    DialogClearEvent dialog_clear = 114;
+    DialogClickActionEvent dialog_click_action = 115;
+    DialogShowEvent dialog_show = 116;
+    AsyncPlayerChatEvent async_player_chat = 117;
+    AsyncPlayerPreLoginEvent async_player_pre_login = 118;
+    BedrockFormResponseEvent bedrock_form_response = 119;
+    PlayerChangedMainHandEvent player_changed_main_hand = 120;
+    PlayerEggThrowEvent player_egg_throw = 121;
+    PlayerExpChangeEvent player_exp_change = 122;
+    PlayerFishEvent player_fish = 123;
+    InventoryCloseEvent inventory_close = 124;
+    InventoryClickEvent inventory_click = 125;
+    PlayerItemHeldEvent player_item_held = 126;
+    PlayerAdvancementDoneEvent player_advancement_done = 127;
+    PlayerAnimationEvent player_animation = 128;
+    PlayerArmorStandManipulateEvent player_armor_stand_manipulate = 129;
+    PlayerBedEnterEvent player_bed_enter = 130;
+    PlayerBedLeaveEvent player_bed_leave = 131;
+    PlayerBucketEmptyEvent player_bucket_empty = 132;
+    PlayerBucketFillEvent player_bucket_fill = 133;
+    PlayerBucketEntityEvent player_bucket_entity = 134;
+    PlayerChangeWorldEvent player_change_world = 135;
+    PlayerChangedWorldEvent player_changed_world = 136;
+    PlayerChannelEvent player_channel = 137;
+    PlayerChatEvent player_chat = 138;
+    PlayerCommandPreprocessEvent player_command_preprocess = 139;
+    PlayerCommandSendEvent player_command_send = 140;
+    PlayerCustomPayloadEvent player_custom_payload = 141;
+    PlayerDropItemEvent player_drop_item = 142;
+    PlayerEditBookEvent player_edit_book = 143;
+    PlayerElytraBoostEvent player_elytra_boost = 144;
+    PlayerExpCooldownChangeEvent player_exp_cooldown_change = 145;
+    PlayerGamemodeChangeEvent player_gamemode_change = 146;
+    PlayerHarvestBlockEvent player_harvest_block = 147;
+    PlayerHideEntityEvent player_hide_entity = 148;
+    PlayerInputEvent player_input = 149;
+    PlayerInteractAtEntityEvent player_interact_at_entity = 150;
+    PlayerInteractEntityEvent player_interact_entity = 151;
+    PlayerInteractEvent player_interact = 152;
+    PlayerInteractUnknownEntityEvent player_interact_unknown_entity = 153;
+    PlayerItemBreakEvent player_item_break = 154;
+    PlayerItemConsumeEvent player_item_consume = 155;
+    PlayerItemDamageEvent player_item_damage = 156;
+    PlayerItemMendEvent player_item_mend = 157;
+    PlayerJoinEvent player_join = 158;
+    PlayerKickEvent player_kick = 159;
+    PlayerLeashEntityEvent player_leash_entity = 160;
+    PlayerLeaveEvent player_leave = 161;
+    PlayerLevelChangeEvent player_level_change = 162;
+    PlayerLinksSendEvent player_links_send = 163;
+    PlayerLocaleChangeEvent player_locale_change = 164;
+    PlayerLoginEvent player_login = 165;
+    PlayerMoveEvent player_move = 166;
+    PlayerNameEntityEvent player_name_entity = 167;
+    PlayerOpenSignEvent player_open_sign = 168;
+    PlayerPermissionCheckEvent player_permission_check = 169;
+    PlayerPickupArrowEvent player_pickup_arrow = 170;
+    PlayerPortalEvent player_portal = 171;
+    PlayerPreLoginEvent player_pre_login = 172;
+    PlayerRecipeBookClickEvent player_recipe_book_click = 173;
+    PlayerRecipeBookSettingsChangeEvent player_recipe_book_settings_change = 174;
+    PlayerRecipeDiscoverEvent player_recipe_discover = 175;
+    PlayerRegisterChannelEvent player_register_channel = 176;
+    PlayerResourcePackStatusEvent player_resource_pack_status = 177;
+    PlayerRespawnEvent player_respawn = 178;
+    PlayerRiptideEvent player_riptide = 179;
+    PlayerShearEntityEvent player_shear_entity = 180;
+    PlayerShowEntityEvent player_show_entity = 181;
+    PlayerSpawnChangeEvent player_spawn_change = 182;
+    PlayerSpawnLocationEvent player_spawn_location = 183;
+    PlayerStatisticIncrementEvent player_statistic_increment = 184;
+    PlayerSwapHandItemsEvent player_swap_hand_items = 185;
+    PlayerTakeLecternBookEvent player_take_lectern_book = 186;
+    PlayerTeleportEvent player_teleport = 187;
+    PlayerToggleFlightEvent player_toggle_flight = 188;
+    PlayerToggleSneakEvent player_toggle_sneak = 189;
+    PlayerToggleSprintEvent player_toggle_sprint = 190;
+    PlayerUnleashEntityEvent player_unleash_entity = 191;
+    PlayerUnregisterChannelEvent player_unregister_channel = 192;
+    PlayerVelocityEvent player_velocity = 193;
+    HangingBreakEvent hanging_break = 194;
+    HangingBreakByEntityEvent hanging_break_by_entity = 195;
+    HangingPlaceEvent hanging_place = 196;
+    AreaEffectCloudApplyEvent area_effect_cloud_apply = 197;
+    ArrowBodyCountChangeEvent arrow_body_count_change = 198;
+    BatToggleSleepEvent bat_toggle_sleep = 199;
+    CreatureSpawnEvent creature_spawn = 200;
+    CreeperPowerEvent creeper_power = 201;
+    EnderDragonChangePhaseEvent ender_dragon_change_phase = 202;
+    EntityAirChangeEvent entity_air_change = 203;
+    EntityBreakDoorEvent entity_break_door = 204;
+    EntityBreedEvent entity_breed = 205;
+    EntityChangeBlockEvent entity_change_block = 206;
+    EntityCombustEvent entity_combust = 207;
+    EntityCombustByBlockEvent entity_combust_by_block = 208;
+    EntityCombustByEntityEvent entity_combust_by_entity = 209;
+    EntityDamageEvent entity_damage = 210;
+    EntityDamageByBlockEvent entity_damage_by_block = 211;
+    EntityDamageByEntityEvent entity_damage_by_entity = 212;
+    EntityDeathEvent entity_death = 213;
+    PlayerDeathEvent player_death = 214;
+    EntityDismountEvent entity_dismount = 215;
+    EntityDropItemEvent entity_drop_item = 216;
+    EntityDyeEvent entity_dye = 217;
+    EntityEnterBlockEvent entity_enter_block = 218;
+    EntityEnterLoveModeEvent entity_enter_love_mode = 219;
+    EntityExhaustionEvent entity_exhaustion = 220;
+    EntityExplodeEvent entity_explode = 221;
+    EntityInteractEvent entity_interact = 222;
+    EntityKnockbackEvent entity_knockback = 223;
+    EntityKnockbackByEntityEvent entity_knockback_by_entity = 224;
+    EntityMountEvent entity_mount = 225;
+    EntityPickupItemEvent entity_pickup_item = 226;
+    EntityPlaceEvent entity_place = 227;
+    EntityPortalEvent entity_portal = 228;
+    EntityPortalEnterEvent entity_portal_enter = 229;
+    EntityPortalExitEvent entity_portal_exit = 230;
+    EntityPoseChangeEvent entity_pose_change = 231;
+    EntityPotionEffectEvent entity_potion_effect = 232;
+    EntityRegainHealthEvent entity_regain_health = 233;
+    EntityRemoveEvent entity_remove = 234;
+    EntityResurrectEvent entity_resurrect = 235;
+    EntityShootBowEvent entity_shoot_bow = 236;
+    EntitySpawnEvent entity_spawn = 237;
+    EntitySpellCastEvent entity_spell_cast = 238;
+    EntityTameEvent entity_tame = 239;
+    EntityTargetEvent entity_target = 240;
+    EntityTargetBlockEvent entity_target_block = 241;
+    EntityTargetLivingEntityEvent entity_target_living_entity = 242;
+    EntityTeleportEvent entity_teleport = 243;
+    EntityToggleGlideEvent entity_toggle_glide = 244;
+    EntityToggleSwimEvent entity_toggle_swim = 245;
+    EntityTransformEvent entity_transform = 246;
+    EntityUnleashEvent entity_unleash = 247;
+    ExpBottleEvent exp_bottle = 248;
+    ExplosionPrimeEvent explosion_prime = 249;
+    FireworkExplodeEvent firework_explode = 250;
+    FoodLevelChangeEvent food_level_change = 251;
+    HorseJumpEvent horse_jump = 252;
+    ItemDespawnEvent item_despawn = 253;
+    ItemMergeEvent item_merge = 254;
+    ItemSpawnEvent item_spawn = 255;
+    LingeringPotionSplashEvent lingering_potion_splash = 256;
+    PigZapEvent pig_zap = 257;
+    PigZombieAngerEvent pig_zombie_anger = 258;
+    PiglinBarterEvent piglin_barter = 259;
+    PotionSplashEvent potion_splash = 260;
+    ProjectileHitEvent projectile_hit = 261;
+    ProjectileLaunchEvent projectile_launch = 262;
+    SheepDyeWoolEvent sheep_dye_wool = 263;
+    SheepRegrowWoolEvent sheep_regrow_wool = 264;
+    SlimeSplitEvent slime_split = 265;
+    SpawnerSpawnEvent spawner_spawn = 266;
+    StriderTemperatureChangeEvent strider_temperature_change = 267;
+    TrialSpawnerSpawnEvent trial_spawner_spawn = 268;
+    VillagerAcquireTradeEvent villager_acquire_trade = 269;
+    VillagerCareerChangeEvent villager_career_change = 270;
+    VillagerReplenishTradeEvent villager_replenish_trade = 271;
+    VillagerReputationChangeEvent villager_reputation_change = 272;
+    WardenAngerChangeEvent warden_anger_change = 273;
+    RaidFinishEvent raid_finish = 274;
+    RaidSpawnWaveEvent raid_spawn_wave = 275;
+    RaidStopEvent raid_stop = 276;
+    RaidTriggerEvent raid_trigger = 277;
+    EnchantItemEvent enchant_item = 278;
+    PrepareItemEnchantEvent prepare_item_enchant = 279;
   }
 }
 
+message FireEventResponse {
+  bool cancelled = 1;
+  Event data = 2;
+}
+
+message CallEventRequest {
+  Event event = 1;
+}
+
+message CallEventResponse {
+  FireEventResponse response = 1;
+}
+
 message RegisterEventRequest {
   string event_type = 1;
   string plugin_name = 2;
   int32 priority = 3;
   bool blocking = 4;
 }
-
-message CallEventRequest {
-  Event event = 1;
-}
-
-message CallEventResponse {
-  bool handled = 1;
-}
-
-message FireEventResponse {
-  bool cancelled = 1;
-  Event data = 2;
-}
diff --git a/proto/patchbukkit/events/hanging_events.proto b/proto/patchbukkit/events/hanging_events.proto
new file mode 100644
index 0000000..f62aaf6
--- /dev/null
+++ b/proto/patchbukkit/events/hanging_events.proto
@@ -0,0 +1,26 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message HangingBreakEvent {
+  patchbukkit.common.UUID entity_uuid = 1;
+  patchbukkit.common.UUID remover_uuid = 2;
+}
+
+message HangingBreakByEntityEvent {
+  patchbukkit.common.UUID entity_uuid = 1;
+  patchbukkit.common.UUID remover_uuid = 2;
+}
+
+message HangingPlaceEvent {
+  patchbukkit.common.UUID entity_uuid = 1;
+  patchbukkit.common.UUID player_uuid = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+  string block_face = 6;
+}
diff --git a/proto/patchbukkit/events/inventory_events.proto b/proto/patchbukkit/events/inventory_events.proto
new file mode 100644
index 0000000..f694b5c
--- /dev/null
+++ b/proto/patchbukkit/events/inventory_events.proto
@@ -0,0 +1,143 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message BrewEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  uint32 fuel_level = 4;
+}
+
+message BrewingStandFuelEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  uint32 fuel_power = 4;
+}
+
+message CraftItemEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string recipe_id = 2;
+}
+
+message FurnaceBurnEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string fuel_item = 4;
+  uint32 burn_time = 5;
+}
+
+message FurnaceExtractEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string item_id = 5;
+  uint32 item_amount = 6;
+  float exp_gained = 7;
+}
+
+message FurnaceSmeltEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string source_item = 4;
+  string result_item = 5;
+}
+
+message FurnaceStartSmeltEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string source_item = 4;
+  uint32 cooking_time = 5;
+}
+
+message HopperInventorySearchEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  int32 search_pos_x = 4;
+  int32 search_pos_y = 5;
+  int32 search_pos_z = 6;
+}
+
+message InventoryCreativeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 slot = 2;
+  string item_id = 3;
+  uint32 item_count = 4;
+}
+
+message InventoryDragEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message InventoryInteractEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message InventoryMoveItemEvent {
+  int32 source_pos_x = 1;
+  int32 source_pos_y = 2;
+  int32 source_pos_z = 3;
+  int32 target_pos_x = 4;
+  int32 target_pos_y = 5;
+  int32 target_pos_z = 6;
+  string item_id = 7;
+  uint32 item_amount = 8;
+}
+
+message InventoryOpenEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message InventoryPickupItemEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  int32 item_entity_id = 4;
+  string item_id = 5;
+}
+
+message PrepareAnvilEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string rename_text = 2;
+  uint32 repair_cost = 3;
+}
+
+message PrepareGrindstoneEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string result_item = 2;
+}
+
+message PrepareInventoryResultEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string result_item = 2;
+}
+
+message PrepareItemCraftEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string recipe_id = 2;
+}
+
+message PrepareSmithingEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string result_item = 2;
+}
+
+message SmithItemEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string recipe_id = 2;
+}
+
+message TradeSelectEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  uint32 slot_index = 2;
+}
diff --git a/proto/patchbukkit/events/player_events.proto b/proto/patchbukkit/events/player_events.proto
index dece73a..673f066 100644
--- a/proto/patchbukkit/events/player_events.proto
+++ b/proto/patchbukkit/events/player_events.proto
@@ -6,29 +6,474 @@ import "patchbukkit/common/types.proto";
 option java_multiple_files = true;
 option java_package = "patchbukkit.events";
 
-message PlayerJoinEvent {
+message AsyncPlayerChatEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  string join_message = 2;
+  string message = 2;
+  string format = 3;
 }
 
-message PlayerQuitEvent {
+message AsyncPlayerPreLoginEvent {
+  string player_name = 1;
+  patchbukkit.common.UUID player_uuid = 2;
+  string ip_address = 3;
+  string kick_message = 4;
+}
+
+message BedrockFormResponseEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  string quit_message = 2;
+  uint32 form_id = 2;
+  string response_data = 3;
+}
+
+message PlayerChangedMainHandEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string main_hand = 2;
+}
+
+message PlayerEggThrowEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID egg_uuid = 2;
+  bool hatching = 3;
+  uint32 num_hatches = 4;
+  string hatching_type = 5;
+}
+
+message PlayerExpChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 amount = 2;
+}
+
+message PlayerFishEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID caught_uuid = 2;
+  string caught_type = 3;
+  patchbukkit.common.UUID hook_uuid = 4;
+  string state = 5;
+  string hand = 6;
+  int32 exp_to_drop = 7;
+}
+
+message InventoryCloseEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message InventoryClickEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string click_type = 2;
+  int32 slot = 3;
+  int32 raw_slot = 4;
+  string clicked_item_name = 5;
+  int32 clicked_item_count = 6;
+  string cursor_name = 7;
+  int32 cursor_count = 8;
+  int32 hotbar_button = 9;
+}
+
+message PlayerItemHeldEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  uint32 previous_slot = 2;
+  uint32 new_slot = 3;
+}
+
+message PlayerAdvancementDoneEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string advancement_id = 2;
+}
+
+message PlayerAnimationEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string animation_type = 2;
+}
+
+message PlayerArmorStandManipulateEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 armor_stand_id = 2;
+  uint32 slot = 3;
+}
+
+message PlayerBedEnterEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 bed_pos_x = 2;
+  int32 bed_pos_y = 3;
+  int32 bed_pos_z = 4;
+}
+
+message PlayerBedLeaveEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 bed_pos_x = 2;
+  int32 bed_pos_y = 3;
+  int32 bed_pos_z = 4;
+}
+
+message PlayerBucketEmptyEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string bucket = 5;
+}
+
+message PlayerBucketFillEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string bucket = 5;
+}
+
+message PlayerBucketEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+  string bucket_item = 3;
+}
+
+message PlayerChangeWorldEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID previous_world_uuid = 2;
+  patchbukkit.common.UUID new_world_uuid = 3;
+  double pos_x = 4;
+  double pos_y = 5;
+  double pos_z = 6;
+  float yaw = 7;
+  float pitch = 8;
+}
+
+message PlayerChangedWorldEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID from_world_uuid = 2;
+  patchbukkit.common.UUID to_world_uuid = 3;
+}
+
+message PlayerChannelEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string channel = 2;
+}
+
+message PlayerChatEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string message = 2;
+  repeated patchbukkit.common.UUID recipients_uuids = 3;
+}
+
+message PlayerCommandPreprocessEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string command = 2;
+}
+
+message PlayerCommandSendEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string command = 2;
+}
+
+message PlayerCustomPayloadEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string channel = 2;
+  bytes data = 3;
+}
+
+message PlayerDropItemEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+  uint32 count = 3;
+}
+
+message PlayerEditBookEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  uint32 slot = 2;
+  repeated string pages = 3;
+  string title = 4;
+  bool signing = 5;
+}
+
+message PlayerElytraBoostEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 firework_id = 2;
+}
+
+message PlayerExpCooldownChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 new_cooldown = 2;
+}
+
+message PlayerGamemodeChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string previous_gamemode = 2;
+  string new_gamemode = 3;
+}
+
+message PlayerHarvestBlockEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  repeated string harvested_items_names = 5;
+}
+
+message PlayerHideEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+}
+
+message PlayerInputEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string input = 2;
+}
+
+message PlayerInteractAtEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+  double clicked_x = 3;
+  double clicked_y = 4;
+  double clicked_z = 5;
+  uint32 hand = 6;
+}
+
+message PlayerInteractEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID target_uuid = 2;
+  string action = 3;
+  double target_position_x = 4;
+  double target_position_y = 5;
+  double target_position_z = 6;
+  bool sneaking = 7;
 }
 
 message PlayerInteractEvent {
   patchbukkit.common.UUID player_uuid = 1;
   string action = 2;
-  int32 clicked_x = 3;
-  int32 clicked_y = 4;
-  int32 clicked_z = 5;
-  string block_face = 6;
-  string hand = 7;
+  int32 clicked_pos_x = 3;
+  int32 clicked_pos_y = 4;
+  int32 clicked_pos_z = 5;
+  string block = 6;
 }
 
-message PlayerGameModeChangeEvent {
+message PlayerInteractUnknownEntityEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  string new_gamemode = 2;
+  int32 entity_id = 2;
+  string action = 3;
+}
+
+message PlayerItemBreakEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+}
+
+message PlayerItemConsumeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+}
+
+message PlayerItemDamageEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+  int32 damage = 3;
+}
+
+message PlayerItemMendEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+  int32 repair_amount = 3;
+  int32 exp_consumed = 4;
+}
+
+message PlayerJoinEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string join_message = 2;
+}
+
+message PlayerKickEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string reason = 2;
+}
+
+message PlayerLeashEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+  int32 holder_id = 3;
+}
+
+message PlayerLeaveEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string leave_message = 2;
+}
+
+message PlayerLevelChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 old_level = 2;
+  int32 new_level = 3;
+}
+
+message PlayerLinksSendEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  repeated string links = 2;
+}
+
+message PlayerLocaleChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string new_locale = 2;
+}
+
+message PlayerLoginEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string kick_message = 2;
+}
+
+message PlayerMoveEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  double from_x = 2;
+  double from_y = 3;
+  double from_z = 4;
+  double to_x = 5;
+  double to_y = 6;
+  double to_z = 7;
+}
+
+message PlayerNameEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+  string name = 3;
+}
+
+message PlayerOpenSignEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  bool is_front = 5;
+}
+
+message PlayerPermissionCheckEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string permission = 2;
+  bool result = 3;
+}
+
+message PlayerPickupArrowEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 arrow_id = 2;
+}
+
+message PlayerPortalEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 from_pos_x = 2;
+  int32 from_pos_y = 3;
+  int32 from_pos_z = 4;
+  int32 to_pos_x = 5;
+  int32 to_pos_y = 6;
+  int32 to_pos_z = 7;
+}
+
+message PlayerPreLoginEvent {
+  string player_name = 1;
+  patchbukkit.common.UUID player_uuid = 2;
+  string ip_address = 3;
+  string kick_message = 4;
+}
+
+message PlayerRecipeBookClickEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string recipe_id = 2;
+  bool make_all = 3;
+}
+
+message PlayerRecipeBookSettingsChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string book_type = 2;
+  bool is_open = 3;
+  bool is_filtering = 4;
+}
+
+message PlayerRecipeDiscoverEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string recipe_id = 2;
+}
+
+message PlayerRegisterChannelEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string channel = 2;
+}
+
+message PlayerResourcePackStatusEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string pack_id = 2;
+  string status = 3;
+}
+
+message PlayerRespawnEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  patchbukkit.common.UUID previous_world_uuid = 2;
+  patchbukkit.common.UUID respawned_world_uuid = 3;
+  double pos_x = 4;
+  double pos_y = 5;
+  double pos_z = 6;
+  float yaw = 7;
+  float pitch = 8;
+  bool alive = 9;
+}
+
+message PlayerRiptideEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string item_name = 2;
+}
+
+message PlayerShearEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+  uint32 hand = 3;
+}
+
+message PlayerShowEntityEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 entity_id = 2;
+}
+
+message PlayerSpawnChangeEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 new_spawn_x = 2;
+  int32 new_spawn_y = 3;
+  int32 new_spawn_z = 4;
+  bool forced = 5;
+}
+
+message PlayerSpawnLocationEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  double spawn_pos_x = 2;
+  double spawn_pos_y = 3;
+  double spawn_pos_z = 4;
+}
+
+message PlayerStatisticIncrementEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  string statistic_id = 2;
+  int32 amount = 3;
+}
+
+message PlayerSwapHandItemsEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+}
+
+message PlayerTakeLecternBookEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+  string book_name = 5;
+  int32 book_count = 6;
+}
+
+message PlayerTeleportEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  double from_x = 2;
+  double from_y = 3;
+  double from_z = 4;
+  double to_x = 5;
+  double to_y = 6;
+  double to_z = 7;
+}
+
+message PlayerToggleFlightEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  bool is_flying = 2;
 }
 
 message PlayerToggleSneakEvent {
@@ -41,28 +486,19 @@ message PlayerToggleSprintEvent {
   bool is_sprinting = 2;
 }
 
-message PlayerToggleFlightEvent {
+message PlayerUnleashEntityEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  bool is_flying = 2;
+  int32 entity_id = 2;
 }
 
-message PlayerChatEvent {
+message PlayerUnregisterChannelEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  string message = 2;
-  string format = 3;
+  string channel = 2;
 }
 
-message PlayerMoveEvent {
+message PlayerVelocityEvent {
   patchbukkit.common.UUID player_uuid = 1;
-  patchbukkit.common.Location from = 2;
-  patchbukkit.common.Location to = 3;
+  double velocity_x = 2;
+  double velocity_y = 3;
+  double velocity_z = 4;
 }
-
-message PlayerInteractEntityEvent {
-  patchbukkit.common.UUID player_uuid = 1;
-  patchbukkit.common.UUID target_uuid = 2;
-  string action = 3;
-  bool is_sneaking = 4;
-}
-
-
diff --git a/proto/patchbukkit/events/raid_events.proto b/proto/patchbukkit/events/raid_events.proto
new file mode 100644
index 0000000..293949b
--- /dev/null
+++ b/proto/patchbukkit/events/raid_events.proto
@@ -0,0 +1,28 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message RaidFinishEvent {
+  bool victory = 1;
+}
+
+message RaidSpawnWaveEvent {
+  uint32 wave = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message RaidStopEvent {
+  string reason = 1;
+}
+
+message RaidTriggerEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+}
diff --git a/proto/patchbukkit/events/server_events.proto b/proto/patchbukkit/events/server_events.proto
index b52c362..fed7747 100644
--- a/proto/patchbukkit/events/server_events.proto
+++ b/proto/patchbukkit/events/server_events.proto
@@ -6,15 +6,72 @@ import "patchbukkit/common/types.proto";
 option java_multiple_files = true;
 option java_package = "patchbukkit.events";
 
-message PluginEnableEvent {
-  string plugin_name = 1;
+message ServerListPingEvent {
+  string motd = 1;
+  uint32 max_players = 2;
+  uint32 num_players = 3;
+  string favicon = 4;
+}
+
+message MapInitializeEvent {
+  int32 map_id = 1;
+}
+
+message PacketReceivedEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 packet_id = 2;
+  bytes payload = 3;
+}
+
+message PacketSentEvent {
+  patchbukkit.common.UUID player_uuid = 1;
+  int32 packet_id = 2;
+  bytes payload = 3;
 }
 
 message PluginDisableEvent {
   string plugin_name = 1;
 }
 
-message ServerCommandEvent {
-  string sender_name = 1;
-  string command = 2;
+message PluginEnableEvent {
+  string plugin_name = 1;
+}
+
+message RemoteServerCommandEvent {
+  string command = 1;
+}
+
+message ServerBroadcastEvent {
+  string message = 1;
+  string sender = 2;
+}
+
+message ServerCommandEvent {
+  string command = 1;
+}
+
+message ServerLoadEvent {
+  string load_type = 1;
+}
+
+message ServerTickEndEvent {
+  int32 tick = 1;
+  int64 duration_nanos = 2;
+}
+
+message ServerTickStartEvent {
+  int32 tick = 1;
+}
+
+message ServiceRegisterEvent {
+  string service_name = 1;
+}
+
+message ServiceUnregisterEvent {
+  string service_name = 1;
+}
+
+message TabCompleteEvent {
+  string buffer = 1;
+  repeated string completions = 2;
 }
diff --git a/proto/patchbukkit/events/vehicle_events.proto b/proto/patchbukkit/events/vehicle_events.proto
new file mode 100644
index 0000000..ce05e11
--- /dev/null
+++ b/proto/patchbukkit/events/vehicle_events.proto
@@ -0,0 +1,60 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message VehicleBlockCollisionEvent {
+  int32 vehicle_id = 1;
+  int32 block_x = 2;
+  int32 block_y = 3;
+  int32 block_z = 4;
+}
+
+message VehicleCollisionEvent {
+  int32 vehicle_id = 1;
+}
+
+message VehicleCreateEvent {
+  int32 vehicle_id = 1;
+}
+
+message VehicleDamageEvent {
+  int32 vehicle_id = 1;
+  float damage = 2;
+}
+
+message VehicleDestroyEvent {
+  int32 vehicle_id = 1;
+}
+
+message VehicleEnterEvent {
+  int32 vehicle_id = 1;
+  int32 entered_id = 2;
+}
+
+message VehicleEntityCollisionEvent {
+  int32 vehicle_id = 1;
+  int32 collided_entity_id = 2;
+}
+
+message VehicleExitEvent {
+  int32 vehicle_id = 1;
+  int32 exited_id = 2;
+}
+
+message VehicleMoveEvent {
+  int32 vehicle_id = 1;
+  double from_x = 2;
+  double from_y = 3;
+  double from_z = 4;
+  double to_x = 5;
+  double to_y = 6;
+  double to_z = 7;
+}
+
+message VehicleUpdateEvent {
+  int32 vehicle_id = 1;
+}
diff --git a/proto/patchbukkit/events/world_events.proto b/proto/patchbukkit/events/world_events.proto
new file mode 100644
index 0000000..a2fdf17
--- /dev/null
+++ b/proto/patchbukkit/events/world_events.proto
@@ -0,0 +1,134 @@
+syntax = "proto3";
+package patchbukkit.events;
+
+import "patchbukkit/common/types.proto";
+
+option java_multiple_files = true;
+option java_package = "patchbukkit.events";
+
+message AsyncStructureGenerateEvent {
+  string world_name = 1;
+  string structure_name = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+}
+
+message AsyncStructureSpawnEvent {
+  string world_name = 1;
+  string structure_name = 2;
+  int32 block_x = 3;
+  int32 block_y = 4;
+  int32 block_z = 5;
+}
+
+message ChunkLoad {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message ChunkPopulateEvent {
+  int32 chunk_x = 1;
+  int32 chunk_z = 2;
+}
+
+message ChunkSave {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message ChunkSend {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message ChunkUnloadEvent {
+  int32 chunk_x = 1;
+  int32 chunk_z = 2;
+}
+
+message EntitiesLoadEvent {
+  int32 chunk_x = 1;
+  int32 chunk_z = 2;
+  int64 entity_count = 3;
+}
+
+message EntitiesUnloadEvent {
+  int32 chunk_x = 1;
+  int32 chunk_z = 2;
+  int64 entity_count = 3;
+}
+
+message GenericGameEvent {
+  string event_key = 1;
+  double pos_x = 2;
+  double pos_y = 3;
+  double pos_z = 4;
+}
+
+message LightningStrikeEvent {
+  double pos_x = 1;
+  double pos_y = 2;
+  double pos_z = 3;
+  bool is_effect = 4;
+}
+
+message LootGenerateEvent {
+  string loot_table = 1;
+}
+
+message PortalCreateEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string portal_type = 4;
+}
+
+message SpawnChangeEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+  int32 previous_position_x = 2;
+  int32 previous_position_y = 3;
+  int32 previous_position_z = 4;
+  float previous_yaw = 5;
+  float previous_pitch = 6;
+  int32 new_position_x = 7;
+  int32 new_position_y = 8;
+  int32 new_position_z = 9;
+  float new_yaw = 10;
+  float new_pitch = 11;
+}
+
+message StructureGrowEvent {
+  int32 block_x = 1;
+  int32 block_y = 2;
+  int32 block_z = 3;
+  string species = 4;
+  bool bone_meal = 5;
+}
+
+message TimeSkipEvent {
+  int64 skip_amount = 1;
+}
+
+message WeatherChangeEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+  bool to_weather_state = 2;
+}
+
+message ThunderChangeEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+  bool to_thunder_state = 2;
+}
+
+message WorldInitEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message WorldLoadEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message WorldUnloadEvent {
+  patchbukkit.common.UUID world_uuid = 1;
+}
+
+message WorldSaveEvent {
+  string world_name = 1;
+}
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index b477ebd..d154007 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -2939,9 +2939,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "ordered-float"
-version = "5.3.0"
+version = "5.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7d950ca161dc355eaf28f82b11345ed76c6e1f6eb1f4f4479e0323b9e2fbd0e"
+checksum = "8c7c9e0d9b23589f26070720bac724174bfec1083e82f7854cdd0267518343c0"
 dependencies = [
  "num-traits",
 ]
@@ -3510,7 +3510,7 @@ dependencies = [
 [[package]]
 name = "pumpkin"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "aes 0.9.2",
  "arc-swap",
@@ -3565,8 +3565,8 @@ dependencies = [
  "tracing-subscriber",
  "ureq",
  "uuid",
- "wasm-encoder 0.256.0",
- "wasmparser 0.256.0",
+ "wasm-encoder 0.257.1",
+ "wasmparser 0.257.1",
  "wasmtime",
  "wasmtime-wasi",
  "wasmtime-wasi-http",
@@ -3576,7 +3576,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-api-macros"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "proc-macro-error2",
  "proc-macro2",
@@ -3587,7 +3587,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-codecs"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "serde_json",
  "tracing",
@@ -3596,7 +3596,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-config"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "pumpkin-util",
  "serde",
@@ -3608,7 +3608,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-data"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "crc-fast",
  "phf",
@@ -3621,7 +3621,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-inventory"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "pumpkin-data",
  "pumpkin-protocol",
@@ -3636,7 +3636,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-macros"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "heck",
  "proc-macro-error2",
@@ -3649,7 +3649,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-nbt"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "bytes",
  "cesu8",
@@ -3663,7 +3663,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-protocol"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "aes 0.9.2",
  "async-compression",
@@ -3688,7 +3688,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-util"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "base64 0.23.1",
  "bytes",
@@ -3714,7 +3714,7 @@ dependencies = [
 [[package]]
 name = "pumpkin-world"
 version = "0.1.0-dev+26.2-26.40"
-source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#80e6fceb08cf29dfcab81c19912cec28937eef51"
+source = "git+https://github.com/Pumpkin-MC/Pumpkin.git?branch=master#0d55aa54118956e459702394f2cf4609ab71db75"
 dependencies = [
  "arc-swap",
  "bitflags 2.13.1",
@@ -5357,9 +5357,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.24.1"
+version = "1.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cefc03fd367c0c6d4305de1b312cf00248c4114f4a0418ce6a6af769e3b0bd9"
+checksum = "f053576934f05a761a402421fbbe3d425d9366f75f978806a037b3ca481abecc"
 dependencies = [
  "getrandom 0.4.3",
  "js-sys",
@@ -5456,12 +5456,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.256.0"
+version = "0.257.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec1492381bfd5ea51c2a99a919b676662559925cb8d7490547ec2e14c1ad3eb1"
+checksum = "7d8ad9f0a39050867bda22e6486c316e2e52d20a42154d5bc433934bf738d085"
 dependencies = [
  "leb128fmt",
- "wasmparser 0.256.0",
+ "wasmparser 0.257.1",
 ]
 
 [[package]]
@@ -5479,15 +5479,13 @@ dependencies = [
 
 [[package]]
 name = "wasmparser"
-version = "0.256.0"
+version = "0.257.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60bd825ffedc6cba8a642924ba7ae424afbc47811cffbcb7b92031ec24e59b4c"
+checksum = "d92fc335fb6d48f46bda1d8b26b69e28320c15ac3272208333833d6e217e2b4a"
 dependencies = [
  "bitflags 2.13.1",
- "hashbrown 0.17.1",
  "indexmap",
  "semver",
- "serde",
 ]
 
 [[package]]
diff --git a/rust/src/events/handler.rs b/rust/src/events/handler.rs
index 8d0f240..f8f9906 100644
--- a/rust/src/events/handler.rs
+++ b/rust/src/events/handler.rs
@@ -1,25 +1,18 @@
+#![allow(clippy::all)]
+use pumpkin::plugin::{BoxFuture, EventHandler, Payload};
+use pumpkin::server::Server;
 use std::marker::PhantomData;
 use std::sync::Arc;
-
-use pumpkin::entity::player::Player;
-use pumpkin::plugin::{BoxFuture, Cancellable, EventHandler, Payload};
-use pumpkin::server::Server;
 use tokio::sync::{mpsc, oneshot};
 
 use crate::java::jvm::commands::JvmCommand;
 use crate::proto::patchbukkit::common::Uuid;
 use crate::proto::patchbukkit::events::event::Data;
-use crate::proto::patchbukkit::events::{
-    BlockBreakEvent, BlockDamageEvent, BlockFadeEvent, BlockFormEvent, BlockGrowEvent,
-    BlockIgniteEvent, BlockPlaceEvent, Event, PlayerChatEvent, PlayerGameModeChangeEvent,
-    PlayerInteractEntityEvent, PlayerInteractEvent, PlayerJoinEvent, PlayerMoveEvent,
-    PlayerQuitEvent, PlayerToggleFlightEvent, PlayerToggleSneakEvent, PlayerToggleSprintEvent,
-    ServerCommandEvent, SignChangeEvent,
-};
+use crate::proto::patchbukkit::events::*;
 
 pub struct EventContext {
     pub server: Arc<Server>,
-    pub player: Option<Arc<Player>>,
+    pub player: Option<Arc<pumpkin::entity::player::Player>>,
 }
 
 pub struct JvmEventPayload {
@@ -29,124 +22,515 @@ pub struct JvmEventPayload {
 
 pub trait PatchBukkitEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload;
-    fn apply_modifications(&mut self, server: &Arc<Server>, data: Data) -> Option<()>;
-}
-
-impl PatchBukkitEvent for pumpkin::plugin::player::player_join::PlayerJoinEvent {
-    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        JvmEventPayload {
-            event: Event {
-                data: Some(Data::PlayerJoin(PlayerJoinEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    join_message: serde_json::to_string(&self.join_message).unwrap_or_default(),
-                })),
-            },
-            context: EventContext {
-                server,
-                player: Some(self.player.clone()),
-            },
-        }
-    }
-
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::PlayerJoin(event) = data
-            && let Ok(msg) = serde_json::from_str(&event.join_message)
-        {
-            self.join_message = msg;
-        }
-
-        Some(())
-    }
-}
-
-impl PatchBukkitEvent for pumpkin::plugin::player::player_leave::PlayerLeaveEvent {
-    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        JvmEventPayload {
-            event: Event {
-                data: Some(Data::PlayerQuit(PlayerQuitEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    quit_message: serde_json::to_string(&self.leave_message).unwrap_or_default(),
-                })),
-            },
-            context: EventContext {
-                server,
-                player: Some(self.player.clone()),
-            },
-        }
-    }
-
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::PlayerQuit(event) = data
-            && let Ok(msg) = serde_json::from_str(&event.quit_message)
-        {
-            self.leave_message = msg;
-        }
-
+    fn apply_modifications(&mut self, server: &Arc<Server>, data: Data) -> Option<()> {
+        let _ = (server, data);
         Some(())
     }
+    fn set_cancelled(&mut self, _cancelled: bool) {}
 }
 
 impl PatchBukkitEvent
-    for pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent
+    for pumpkin::plugin::world::async_structure_generate::AsyncStructureGenerateEvent
 {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerGamemodeChange(PlayerGameModeChangeEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    new_gamemode: format!("{:?}", self.new_gamemode),
+                data: Some(Data::AsyncStructureGenerate(AsyncStructureGenerateEvent {
+                    world_name: self.world_name.clone(),
+                    structure_name: self.structure_name.clone(),
+                    block_x: self.pos.0.x,
+                    block_y: self.pos.0.y,
+                    block_z: self.pos.0.z,
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::player::player_interact_event::PlayerInteractEvent {
+impl PatchBukkitEvent for pumpkin::plugin::world::async_structure_spawn::AsyncStructureSpawnEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        let (x, y, z) = match self.clicked_pos {
-            Some(pos) => (pos.0.x, pos.0.y, pos.0.z),
-            None => (0, 0, 0),
-        };
-        let action_str = match self.action {
-            pumpkin::plugin::player::player_interact_event::InteractAction::LeftClickBlock => {
-                "LEFT_CLICK_BLOCK"
-            }
-            pumpkin::plugin::player::player_interact_event::InteractAction::LeftClickAir => {
-                "LEFT_CLICK_AIR"
-            }
-            pumpkin::plugin::player::player_interact_event::InteractAction::RightClickAir => {
-                "RIGHT_CLICK_AIR"
-            }
-            pumpkin::plugin::player::player_interact_event::InteractAction::RightClickBlock => {
-                "RIGHT_CLICK_BLOCK"
-            }
-        };
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerInteract(PlayerInteractEvent {
+                data: Some(Data::AsyncStructureSpawn(AsyncStructureSpawnEvent {
+                    world_name: self.world_name.clone(),
+                    structure_name: self.structure_name.clone(),
+                    block_x: self.pos.0.x,
+                    block_y: self.pos.0.y,
+                    block_z: self.pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::chunk_load::ChunkLoad {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ChunkLoad(ChunkLoad { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::chunk_populate::ChunkPopulateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ChunkPopulate(ChunkPopulateEvent {
+                    chunk_x: self.chunk_pos.x,
+                    chunk_z: self.chunk_pos.y,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::chunk_save::ChunkSave {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ChunkSave(ChunkSave { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::chunk_send::ChunkSend {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ChunkSend(ChunkSend { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::chunk_unload::ChunkUnloadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ChunkUnload(ChunkUnloadEvent {
+                    chunk_x: self.chunk_pos.x,
+                    chunk_z: self.chunk_pos.y,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::entities_load::EntitiesLoadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntitiesLoad(EntitiesLoadEvent {
+                    chunk_x: self.chunk_pos.x,
+                    chunk_z: self.chunk_pos.y,
+                    entity_count: self.entity_count as i64,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::entities_unload::EntitiesUnloadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntitiesUnload(EntitiesUnloadEvent {
+                    chunk_x: self.chunk_pos.x,
+                    chunk_z: self.chunk_pos.y,
+                    entity_count: self.entity_count as i64,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::generic_game::GenericGameEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::GenericGame(GenericGameEvent {
+                    event_key: self.event_key.clone(),
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::lightning_strike::LightningStrikeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::LightningStrike(LightningStrikeEvent {
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    is_effect: self.is_effect,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::loot_generate::LootGenerateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::LootGenerate(LootGenerateEvent {
+                    loot_table: self.loot_table.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::portal_create::PortalCreateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PortalCreate(PortalCreateEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    portal_type: format!("{:?}", self.portal_type),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::spawn_change::SpawnChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SpawnChange(SpawnChangeEvent {
+                    world_uuid: None,
+                    previous_position_x: self.previous_position.0.x,
+                    previous_position_y: self.previous_position.0.y,
+                    previous_position_z: self.previous_position.0.z,
+                    previous_yaw: self.previous_yaw,
+                    previous_pitch: self.previous_pitch,
+                    new_position_x: self.new_position.0.x,
+                    new_position_y: self.new_position.0.y,
+                    new_position_z: self.new_position.0.z,
+                    new_yaw: self.new_yaw,
+                    new_pitch: self.new_pitch,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::structure_grow::StructureGrowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::StructureGrow(StructureGrowEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    species: format!("{:?}", self.species),
+                    bone_meal: self.bone_meal,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::time_skip::TimeSkipEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::TimeSkip(TimeSkipEvent {
+                    skip_amount: self.skip_amount,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::weather_change::WeatherChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WeatherChange(WeatherChangeEvent {
+                    world_uuid: None,
+                    to_weather_state: self.to_weather_state,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::weather_change::ThunderChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ThunderChange(ThunderChangeEvent {
+                    world_uuid: None,
+                    to_thunder_state: self.to_thunder_state,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::world_init::WorldInitEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WorldInit(WorldInitEvent { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::world_load::WorldLoadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WorldLoad(WorldLoadEvent { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::world_load::WorldUnloadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WorldUnload(WorldUnloadEvent { world_uuid: None })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::world::world_save::WorldSaveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WorldSave(WorldSaveEvent {
+                    world_name: self.world_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::list_ping::ServerListPingEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerListPing(ServerListPingEvent {
+                    motd: serde_json::to_string(&self.motd).unwrap_or_default(),
+                    max_players: self.max_players,
+                    num_players: self.num_players,
+                    favicon: self.favicon.clone().unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::map_initialize::MapInitializeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::MapInitialize(MapInitializeEvent {
+                    map_id: self.map_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::packet::PacketReceivedEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PacketReceived(PacketReceivedEvent {
                     player_uuid: Some(Uuid {
                         value: self.player.gameprofile.id.to_string(),
                     }),
-                    action: action_str.to_string(),
-                    clicked_x: x,
-                    clicked_y: y,
-                    clicked_z: z,
-                    block_face: "SELF".to_string(),
-                    hand: "HAND".to_string(),
+                    packet_id: self.packet_id,
+                    payload: self.payload.to_vec(),
                 })),
             },
             context: EventContext {
@@ -156,8 +540,991 @@ impl PatchBukkitEvent for pumpkin::plugin::player::player_interact_event::Player
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::packet::PacketSentEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PacketSent(PacketSentEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    packet_id: self.packet_id,
+                    payload: self.payload.to_vec(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::plugin_disable::PluginDisableEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PluginDisable(PluginDisableEvent {
+                    plugin_name: self.plugin_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::plugin_enable::PluginEnableEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PluginEnable(PluginEnableEvent {
+                    plugin_name: self.plugin_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::remote_server_command::RemoteServerCommandEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::RemoteServerCommand(RemoteServerCommandEvent {
+                    command: self.command.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::server_broadcast::ServerBroadcastEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerBroadcast(ServerBroadcastEvent {
+                    message: serde_json::to_string(&self.message).unwrap_or_default(),
+                    sender: serde_json::to_string(&self.sender).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::server_command::ServerCommandEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerCommand(ServerCommandEvent {
+                    command: self.command.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::server_load::ServerLoadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerLoad(ServerLoadEvent {
+                    load_type: format!("{:?}", self.load_type),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::server_tick_end::ServerTickEndEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerTickEnd(ServerTickEndEvent {
+                    tick: self.tick,
+                    duration_nanos: self.duration_nanos,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::server_tick_start::ServerTickStartEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServerTickStart(ServerTickStartEvent {
+                    tick: self.tick,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::service_register::ServiceRegisterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServiceRegister(ServiceRegisterEvent {
+                    service_name: self.service_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::service_unregister::ServiceUnregisterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ServiceUnregister(ServiceUnregisterEvent {
+                    service_name: self.service_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::server::tab_complete::TabCompleteEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::TabComplete(TabCompleteEvent {
+                    buffer: self.buffer.clone(),
+                    completions: self.completions.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::vehicle::vehicle_block_collision::VehicleBlockCollisionEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleBlockCollision(VehicleBlockCollisionEvent {
+                    vehicle_id: self.vehicle_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_collision::VehicleCollisionEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleCollision(VehicleCollisionEvent {
+                    vehicle_id: self.vehicle_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_create::VehicleCreateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleCreate(VehicleCreateEvent {
+                    vehicle_id: self.vehicle_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_damage::VehicleDamageEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleDamage(VehicleDamageEvent {
+                    vehicle_id: self.vehicle_id,
+                    damage: self.damage,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_destroy::VehicleDestroyEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleDestroy(VehicleDestroyEvent {
+                    vehicle_id: self.vehicle_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_enter::VehicleEnterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleEnter(VehicleEnterEvent {
+                    vehicle_id: self.vehicle_id,
+                    entered_id: self.entered_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::vehicle::vehicle_entity_collision::VehicleEntityCollisionEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleEntityCollision(VehicleEntityCollisionEvent {
+                    vehicle_id: self.vehicle_id,
+                    collided_entity_id: self.collided_entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_exit::VehicleExitEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleExit(VehicleExitEvent {
+                    vehicle_id: self.vehicle_id,
+                    exited_id: self.exited_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_move::VehicleMoveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleMove(VehicleMoveEvent {
+                    vehicle_id: self.vehicle_id,
+                    from_x: self.from.x,
+                    from_y: self.from.y,
+                    from_z: self.from.z,
+                    to_x: self.to.x,
+                    to_y: self.to.y,
+                    to_z: self.to.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::vehicle::vehicle_update::VehicleUpdateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VehicleUpdate(VehicleUpdateEvent {
+                    vehicle_id: self.vehicle_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::brew::BrewEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::Brew(BrewEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    fuel_level: u32::from(self.fuel_level),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::brewing_stand_fuel::BrewingStandFuelEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BrewingStandFuel(BrewingStandFuelEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    fuel_power: u32::from(self.fuel_power),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::craft_item::CraftItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::CraftItem(CraftItemEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    recipe_id: self.recipe_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::furnace_burn::FurnaceBurnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FurnaceBurn(FurnaceBurnEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    fuel_item: self.fuel_item.clone(),
+                    burn_time: self.burn_time,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::furnace_extract::FurnaceExtractEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FurnaceExtract(FurnaceExtractEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    item_id: self.item_id.clone(),
+                    item_amount: self.item_amount,
+                    exp_gained: self.exp_gained,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::furnace_smelt::FurnaceSmeltEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FurnaceSmelt(FurnaceSmeltEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    source_item: self.source_item.clone(),
+                    result_item: self.result_item.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::furnace_start_smelt::FurnaceStartSmeltEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FurnaceStartSmelt(FurnaceStartSmeltEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    source_item: self.source_item.clone(),
+                    cooking_time: self.cooking_time,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::inventory::hopper_inventory_search::HopperInventorySearchEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::HopperInventorySearch(HopperInventorySearchEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    search_pos_x: self.search_pos.0.x,
+                    search_pos_y: self.search_pos.0.y,
+                    search_pos_z: self.search_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::inventory_creative::InventoryCreativeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryCreative(InventoryCreativeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    slot: i32::from(self.slot),
+                    item_id: self.item_id.clone(),
+                    item_count: u32::from(self.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::inventory_drag::InventoryDragEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryDrag(InventoryDragEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::inventory_interact::InventoryInteractEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryInteract(InventoryInteractEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::inventory_move_item::InventoryMoveItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryMoveItem(InventoryMoveItemEvent {
+                    source_pos_x: self.source_pos.0.x,
+                    source_pos_y: self.source_pos.0.y,
+                    source_pos_z: self.source_pos.0.z,
+                    target_pos_x: self.target_pos.0.x,
+                    target_pos_y: self.target_pos.0.y,
+                    target_pos_z: self.target_pos.0.z,
+                    item_id: self.item_id.clone(),
+                    item_amount: self.item_amount,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::inventory_open::InventoryOpenEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryOpen(InventoryOpenEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::inventory::inventory_pickup_item::InventoryPickupItemEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryPickupItem(InventoryPickupItemEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    item_entity_id: self.item_entity_id,
+                    item_id: self.item_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::prepare_anvil::PrepareAnvilEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareAnvil(PrepareAnvilEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    rename_text: self.rename_text.clone(),
+                    repair_cost: self.repair_cost,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::prepare_grindstone::PrepareGrindstoneEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareGrindstone(PrepareGrindstoneEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    result_item: self.result_item.clone().unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::inventory::prepare_inventory_result::PrepareInventoryResultEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareInventoryResult(PrepareInventoryResultEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    result_item: self.result_item.clone().unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::prepare_item_craft::PrepareItemCraftEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareItemCraft(PrepareItemCraftEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    recipe_id: self.recipe_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::prepare_smithing::PrepareSmithingEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareSmithing(PrepareSmithingEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    result_item: self.result_item.clone().unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::smith_item::SmithItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SmithItem(SmithItemEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    recipe_id: self.recipe_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::inventory::trade_select::TradeSelectEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::TradeSelect(TradeSelectEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    slot_index: u32::from(self.slot_index),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::bell_resonate::BellResonateEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BellResonate(BellResonateEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::bell_ring::BellRingEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BellRing(BellRingEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    entity_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
@@ -169,12 +1536,12 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_break::BlockBreakEvent {
                     player_uuid: self.player.as_ref().map(|p| Uuid {
                         value: p.gameprofile.id.to_string(),
                     }),
+                    block: self.block.name.to_string(),
                     block_x: self.block_position.0.x,
                     block_y: self.block_position.0.y,
                     block_z: self.block_position.0.z,
-                    block_type: format!("{:?}", self.block),
                     exp: self.exp,
-                    drop_items: self.drop,
+                    drop: self.drop,
                 })),
             },
             context: EventContext {
@@ -184,8 +1551,556 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_break::BlockBreakEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_brush::BlockBrushEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockBrush(BlockBrushEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_burn::BlockBurnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockBurn(BlockBurnEvent {
+                    igniting_block: self.igniting_block.name.to_string(),
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_can_build::BlockCanBuildEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockCanBuild(BlockCanBuildEvent {
+                    block_to_build: self.block_to_build.name.to_string(),
+                    buildable: self.buildable,
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_cook::BlockCookEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockCook(BlockCookEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    source_name: self.source.item.registry_key.to_string(),
+                    source_count: i32::from(self.source.item_count),
+                    result_name: self.result.item.registry_key.to_string(),
+                    result_count: i32::from(self.result.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_damage::BlockDamageEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDamage(BlockDamageEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block: self.block.name.to_string(),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    insta_break: self.insta_break,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_damage_abort::BlockDamageAbortEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDamageAbort(BlockDamageAbortEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    item_in_hand_name: self.item_in_hand.item.registry_key.to_string(),
+                    item_in_hand_count: i32::from(self.item_in_hand.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_dispense::BlockDispenseEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDispense(BlockDispenseEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    item_name: self.item_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_dispense_armor::BlockDispenseArmorEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDispenseArmor(BlockDispenseArmorEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    target_uuid: None,
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_dispense_loot::BlockDispenseLootEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDispenseLoot(BlockDispenseLootEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    items_names: self
+                        .items
+                        .iter()
+                        .map(|i| i.item.registry_key.to_string())
+                        .collect(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_drop_item::BlockDropItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockDropItem(BlockDropItemEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    player_uuid: self.player.as_ref().map(|p| Uuid {
+                        value: p.gameprofile.id.to_string(),
+                    }),
+                    items_names: self
+                        .items
+                        .iter()
+                        .map(|i| i.item.registry_key.to_string())
+                        .collect(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: self.player.clone(),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_exp::BlockExpEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockExp(BlockExpEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    exp: self.exp,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_explode::BlockExplodeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockExplode(BlockExplodeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    yield_rate: self.yield_rate,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_fade::BlockFadeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockFade(BlockFadeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_fertilize::BlockFertilizeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockFertilize(BlockFertilizeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    player_uuid: self.player.as_ref().map(|p| Uuid {
+                        value: p.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: self.player.clone(),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_form::BlockFormEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockForm(BlockFormEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_from_to::BlockFromToEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockFromTo(BlockFromToEvent {
+                    from_pos_x: self.from_pos.0.x,
+                    from_pos_y: self.from_pos.0.y,
+                    from_pos_z: self.from_pos.0.z,
+                    to_pos_x: self.to_pos.0.x,
+                    to_pos_y: self.to_pos.0.y,
+                    to_pos_z: self.to_pos.0.z,
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_grow::BlockGrowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockGrow(BlockGrowEvent {
+                    world_uuid: None,
+                    old_block: self.old_block.name.to_string(),
+                    old_state_id: i32::from(self.old_state_id.as_u16()),
+                    new_block: self.new_block.name.to_string(),
+                    new_state_id: i32::from(self.new_state_id.as_u16()),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_ignite::BlockIgniteEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockIgnite(BlockIgniteEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    igniting_block: self.igniting_block.name.to_string(),
+                    player_uuid: self.player.as_ref().map(|p| Uuid {
+                        value: p.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: self.player.clone(),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_multi_place::BlockMultiPlaceEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockMultiPlace(BlockMultiPlaceEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_physics::BlockPhysicsEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockPhysics(BlockPhysicsEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    changed_pos_x: self.changed_pos.0.x,
+                    changed_pos_y: self.changed_pos.0.y,
+                    changed_pos_z: self.changed_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_piston::BlockPistonExtendEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockPistonExtend(BlockPistonExtendEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    direction: self.direction.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::block_piston::BlockPistonRetractEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::BlockPistonRetract(BlockPistonRetractEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    direction: self.direction.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
@@ -197,11 +2112,11 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_place::BlockPlaceEvent {
                     player_uuid: Some(Uuid {
                         value: self.player.gameprofile.id.to_string(),
                     }),
+                    block_placed: self.block_placed.name.to_string(),
+                    block_placed_against: self.block_placed_against.name.to_string(),
                     block_x: self.block_position.0.x,
                     block_y: self.block_position.0.y,
                     block_z: self.block_position.0.z,
-                    block_placed_type: format!("{:?}", self.block_placed),
-                    block_against_type: format!("{:?}", self.block_placed_against),
                     can_build: self.can_build,
                 })),
             },
@@ -212,202 +2127,378 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_place::BlockPlaceEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent
-    for pumpkin::plugin::player::player_toggle_sneak_event::PlayerToggleSneakEvent
-{
+impl PatchBukkitEvent for pumpkin::plugin::block::block_receive_game::BlockReceiveGameEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerToggleSneak(PlayerToggleSneakEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    is_sneaking: self.is_sneaking,
+                data: Some(Data::BlockReceiveGame(BlockReceiveGameEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    game_event: self.game_event.clone(),
+                    source_entity_uuid: None,
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent
-    for pumpkin::plugin::player::player_toggle_sprint_event::PlayerToggleSprintEvent
-{
+impl PatchBukkitEvent for pumpkin::plugin::block::block_redstone::BlockRedstoneEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerToggleSprint(PlayerToggleSprintEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    is_sprinting: self.is_sprinting,
+                data: Some(Data::BlockRedstone(BlockRedstoneEvent {
+                    world_uuid: None,
+                    block_state_id: i32::from(self.block_state_id.as_u16()),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    old_current: self.old_current,
+                    new_current: self.new_current,
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent
-    for pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent
-{
+impl PatchBukkitEvent for pumpkin::plugin::block::block_shear_entity::BlockShearEntityEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerToggleFlight(PlayerToggleFlightEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    is_flying: self.is_flying,
+                data: Some(Data::BlockShearEntity(BlockShearEntityEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    target_uuid: None,
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::player::player_move::PlayerMoveEvent {
+impl PatchBukkitEvent for pumpkin::plugin::block::block_spread::BlockSpreadEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        let move_vel = self.to - self.from;
-        self.player.living_entity.entity.velocity.store(move_vel);
-
-        let player_uuid = self.player.gameprofile.id.to_string();
-        let world_uuid = self.player.world().uuid.to_string();
-
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerMove(PlayerMoveEvent {
-                    player_uuid: Some(Uuid { value: player_uuid }),
-                    from: Some(crate::proto::patchbukkit::common::Location {
-                        world: Some(crate::proto::patchbukkit::common::World {
-                            uuid: Some(Uuid {
-                                value: world_uuid.clone(),
-                            }),
-                        }),
-                        position: Some(crate::proto::patchbukkit::common::Vec3 {
-                            x: self.from.x,
-                            y: self.from.y,
-                            z: self.from.z,
-                        }),
-                        yaw: self.player.living_entity.entity.yaw.load(),
-                        pitch: self.player.living_entity.entity.pitch.load(),
-                    }),
-                    to: Some(crate::proto::patchbukkit::common::Location {
-                        world: Some(crate::proto::patchbukkit::common::World {
-                            uuid: Some(Uuid { value: world_uuid }),
-                        }),
-                        position: Some(crate::proto::patchbukkit::common::Vec3 {
-                            x: self.to.x,
-                            y: self.to.y,
-                            z: self.to.z,
-                        }),
-                        yaw: self.player.living_entity.entity.yaw.load(),
-                        pitch: self.player.living_entity.entity.pitch.load(),
-                    }),
+                data: Some(Data::BlockSpread(BlockSpreadEvent {
+                    source_pos_x: self.source_pos.0.x,
+                    source_pos_y: self.source_pos.0.y,
+                    source_pos_z: self.source_pos.0.z,
+                    target_pos_x: self.target_pos.0.x,
+                    target_pos_y: self.target_pos.0.y,
+                    target_pos_z: self.target_pos.0.z,
+                    world_uuid: None,
+                    new_state_id: i32::from(self.new_state_id.as_u16()),
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::PlayerMove(event) = data
-            && let Some(to) = event.to
-            && let Some(pos) = to.position
-        {
-            self.to = pumpkin_util::math::vector3::Vector3::new(pos.x, pos.y, pos.z);
-        }
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::player::player_chat::PlayerChatEvent {
+impl PatchBukkitEvent for pumpkin::plugin::block::brewing_start::BrewingStartEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerChat(PlayerChatEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    message: self.message.clone(),
-                    format: "<%1$s> %2$s".to_string(),
+                data: Some(Data::BrewingStart(BrewingStartEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    brewing_time: self.brewing_time,
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::PlayerChat(event) = data {
-            self.message = event.message;
-        }
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent
-    for pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent
-{
+impl PatchBukkitEvent for pumpkin::plugin::block::campfire_start::CampfireStartEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        let action_str = match self.action {
-            pumpkin_protocol::java::server::play::ActionType::Interact => "INTERACT",
-            pumpkin_protocol::java::server::play::ActionType::Attack => "ATTACK",
-            pumpkin_protocol::java::server::play::ActionType::InteractAt => "INTERACT_AT",
-        };
         JvmEventPayload {
             event: Event {
-                data: Some(Data::PlayerInteractEntity(PlayerInteractEntityEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
-                    target_uuid: Some(Uuid {
-                        value: self.target.get_entity().entity_uuid.to_string(),
-                    }),
-                    action: action_str.to_string(),
-                    is_sneaking: self.sneaking,
+                data: Some(Data::CampfireStart(CampfireStartEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                    slot: u32::from(self.slot),
+                    cooking_time: self.cooking_time,
                 })),
             },
             context: EventContext {
                 server,
-                player: Some(self.player.clone()),
+                player: None,
             },
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::cauldron_level_change::CauldronLevelChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::CauldronLevelChange(CauldronLevelChangeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    old_level: self.old_level,
+                    new_level: self.new_level,
+                    reason: format!("{:?}", self.reason),
+                    entity_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::crafter_craft::CrafterCraftEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::CrafterCraft(CrafterCraftEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    result_name: self.result.item.registry_key.to_string(),
+                    result_count: i32::from(self.result.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::entity_block_form::EntityBlockFormEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityBlockForm(EntityBlockFormEvent {
+                    entity_uuid: None,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    new_state_id: i32::from(self.new_state_id.as_u16()),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::fluid_level_change::FluidLevelChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FluidLevelChange(FluidLevelChangeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    new_state_id: i32::from(self.new_state_id.as_u16()),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::inventory_block_start::InventoryBlockStartEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryBlockStart(InventoryBlockStartEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::leaves_decay::LeavesDecayEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::LeavesDecay(LeavesDecayEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::moisture_change::MoistureChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::MoistureChange(MoistureChangeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    new_moisture: self.new_moisture,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::note_play::NotePlayEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::NotePlay(NotePlayEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    instrument: self.instrument.clone(),
+                    note: u32::from(self.note),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::sculk_bloom::SculkBloomEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SculkBloom(SculkBloomEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    charge: self.charge,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
@@ -432,26 +2523,89 @@ impl PatchBukkitEvent for pumpkin::plugin::block::sign_change::SignChangeEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::SignChange(event) = data {
-            self.lines = event.lines;
-        }
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::block::block_damage::BlockDamageEvent {
+impl PatchBukkitEvent for pumpkin::plugin::block::sponge_absorb::SpongeAbsorbEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::BlockDamage(BlockDamageEvent {
-                    player_uuid: Some(Uuid {
-                        value: self.player.gameprofile.id.to_string(),
-                    }),
+                data: Some(Data::SpongeAbsorb(SpongeAbsorbEvent {
                     block_x: self.block_pos.0.x,
                     block_y: self.block_pos.0.y,
                     block_z: self.block_pos.0.z,
-                    insta_break: false,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::tnt_prime::TNTPrimeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::TntPrime(TntPrimeEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    prime_reason: self.prime_reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::block::vault_display_item::VaultDisplayItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VaultDisplayItem(VaultDisplayItemEvent {
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    world_uuid: None,
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::dialog::dialog_clear::DialogClearEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::DialogClear(DialogClearEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
                 })),
             },
             context: EventContext {
@@ -461,18 +2615,98 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_damage::BlockDamageEvent
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::server::server_command::ServerCommandEvent {
+impl PatchBukkitEvent for pumpkin::plugin::dialog::dialog_click_action::DialogClickActionEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::ServerCommand(ServerCommandEvent {
-                    sender_name: "Console".to_string(),
-                    command: self.command.clone(),
+                data: Some(Data::DialogClickAction(DialogClickActionEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    id: self.id.clone(),
+                    payload: self
+                        .payload
+                        .as_ref()
+                        .map(|b| b.to_vec())
+                        .unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::dialog::dialog_show::DialogShowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::DialogShow(DialogShowEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::async_player_chat::AsyncPlayerChatEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::AsyncPlayerChat(AsyncPlayerChatEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    message: self.message.clone(),
+                    format: serde_json::to_string(&self.format).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::async_player_pre_login::AsyncPlayerPreLoginEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::AsyncPlayerPreLogin(AsyncPlayerPreLoginEvent {
+                    player_name: self.player_name.clone(),
+                    player_uuid: Some(Uuid {
+                        value: self.player_uuid.to_string(),
+                    }),
+                    ip_address: self.ip_address.to_string(),
+                    kick_message: serde_json::to_string(&self.kick_message).unwrap_or_default(),
                 })),
             },
             context: EventContext {
@@ -482,27 +2716,1957 @@ impl PatchBukkitEvent for pumpkin::plugin::server::server_command::ServerCommand
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, data: Data) -> Option<()> {
-        if let Data::ServerCommand(event) = data {
-            self.command = event.command;
-        }
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::block::block_ignite::BlockIgniteEvent {
+impl PatchBukkitEvent for pumpkin::plugin::player::bedrock_form_response::BedrockFormResponseEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
-        let player_uuid = self.player.as_ref().map(|p| Uuid {
-            value: p.gameprofile.id.to_string(),
-        });
         JvmEventPayload {
             event: Event {
-                data: Some(Data::BlockIgnite(BlockIgniteEvent {
-                    player_uuid,
+                data: Some(Data::BedrockFormResponse(BedrockFormResponseEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    form_id: self.form_id,
+                    response_data: self.response_data.clone().unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::changed_main_hand::PlayerChangedMainHandEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerChangedMainHand(PlayerChangedMainHandEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    main_hand: format!("{:?}", self.main_hand),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::egg_throw::PlayerEggThrowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerEggThrow(PlayerEggThrowEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    egg_uuid: Some(Uuid {
+                        value: self.egg_uuid.to_string(),
+                    }),
+                    hatching: self.hatching,
+                    num_hatches: u32::from(self.num_hatches),
+                    hatching_type: self.hatching_type.id.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::exp_change::PlayerExpChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerExpChange(PlayerExpChangeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    amount: self.amount,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::fish::PlayerFishEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerFish(PlayerFishEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    caught_uuid: self.caught_uuid.map(|u| Uuid {
+                        value: u.to_string(),
+                    }),
+                    caught_type: self.caught_type.clone(),
+                    hook_uuid: Some(Uuid {
+                        value: self.hook_uuid.to_string(),
+                    }),
+                    state: match self.state {
+                        pumpkin::plugin::player::PlayerFishState::Fishing => "FISHING",
+                        pumpkin::plugin::player::PlayerFishState::CaughtFish => "CAUGHT_FISH",
+                        pumpkin::plugin::player::PlayerFishState::CaughtEntity => "CAUGHT_ENTITY",
+                        pumpkin::plugin::player::PlayerFishState::InGround => "IN_GROUND",
+                        pumpkin::plugin::player::PlayerFishState::FailedAttempt => "FAILED_ATTEMPT",
+                        pumpkin::plugin::player::PlayerFishState::ReelIn => "REEL_IN",
+                        pumpkin::plugin::player::PlayerFishState::Bite => "BITE",
+                    }
+                    .to_string(),
+                    hand: format!("{:?}", self.hand),
+                    exp_to_drop: self.exp_to_drop,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::inventory_close::InventoryCloseEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryClose(InventoryCloseEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::inventory_interact::InventoryClickEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::InventoryClick(InventoryClickEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    click_type: format!("{:?}", self.click_type),
+                    slot: i32::from(self.slot),
+                    raw_slot: i32::from(self.raw_slot),
+                    clicked_item_name: self
+                        .clicked_item
+                        .as_ref()
+                        .map(|i| i.item.registry_key.to_string())
+                        .unwrap_or_default(),
+                    clicked_item_count: self
+                        .clicked_item
+                        .as_ref()
+                        .map(|i| i32::from(i.item_count))
+                        .unwrap_or(0),
+                    cursor_name: self
+                        .cursor
+                        .as_ref()
+                        .map(|i| i.item.registry_key.to_string())
+                        .unwrap_or_default(),
+                    cursor_count: self
+                        .cursor
+                        .as_ref()
+                        .map(|i| i32::from(i.item_count))
+                        .unwrap_or(0),
+                    hotbar_button: self.hotbar_button,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::item_held::PlayerItemHeldEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerItemHeld(PlayerItemHeldEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    previous_slot: u32::from(self.previous_slot),
+                    new_slot: u32::from(self.new_slot),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_advancement_done::PlayerAdvancementDoneEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerAdvancementDone(PlayerAdvancementDoneEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    advancement_id: self.advancement_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_animation::PlayerAnimationEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerAnimation(PlayerAnimationEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    animation_type: format!("{:?}", self.animation_type),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_armor_stand_manipulate::PlayerArmorStandManipulateEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerArmorStandManipulate(
+                    PlayerArmorStandManipulateEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        armor_stand_id: self.armor_stand_id,
+                        slot: u32::from(self.slot),
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_bed::PlayerBedEnterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerBedEnter(PlayerBedEnterEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    bed_pos_x: self.bed_pos.0.x,
+                    bed_pos_y: self.bed_pos.0.y,
+                    bed_pos_z: self.bed_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_bed::PlayerBedLeaveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerBedLeave(PlayerBedLeaveEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    bed_pos_x: self.bed_pos.0.x,
+                    bed_pos_y: self.bed_pos.0.y,
+                    bed_pos_z: self.bed_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_bucket::PlayerBucketEmptyEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerBucketEmpty(PlayerBucketEmptyEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
                     block_x: self.block_pos.0.x,
                     block_y: self.block_pos.0.y,
                     block_z: self.block_pos.0.z,
-                    ignite_cause: "FLINT_AND_STEEL".to_string(),
+                    bucket: self.bucket.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_bucket::PlayerBucketFillEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerBucketFill(PlayerBucketFillEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    bucket: self.bucket.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_bucket_entity::PlayerBucketEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerBucketEntity(PlayerBucketEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                    bucket_item: self.bucket_item.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_change_world::PlayerChangeWorldEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerChangeWorld(PlayerChangeWorldEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    previous_world_uuid: None,
+                    new_world_uuid: None,
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    yaw: self.yaw,
+                    pitch: self.pitch,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_changed_world::PlayerChangedWorldEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerChangedWorld(PlayerChangedWorldEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    from_world_uuid: None,
+                    to_world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_channel::PlayerChannelEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerChannel(PlayerChannelEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    channel: self.channel.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_chat::PlayerChatEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerChat(PlayerChatEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    message: self.message.clone(),
+                    recipients_uuids: self
+                        .recipients
+                        .iter()
+                        .map(|p| Uuid {
+                            value: p.gameprofile.id.to_string(),
+                        })
+                        .collect(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_command_preprocess::PlayerCommandPreprocessEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerCommandPreprocess(
+                    PlayerCommandPreprocessEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        command: self.command.clone(),
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_command_send::PlayerCommandSendEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerCommandSend(PlayerCommandSendEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    command: self.command.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_custom_payload::PlayerCustomPayloadEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerCustomPayload(PlayerCustomPayloadEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    channel: self.channel.clone(),
+                    data: self.data.to_vec(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_drop_item::PlayerDropItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerDropItem(PlayerDropItemEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                    count: u32::from(self.count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_edit_book::PlayerEditBookEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerEditBook(PlayerEditBookEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    slot: self.slot,
+                    pages: self.pages.clone(),
+                    title: self.title.clone().unwrap_or_default(),
+                    signing: self.signing,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_elytra_boost::PlayerElytraBoostEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerElytraBoost(PlayerElytraBoostEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    firework_id: self.firework_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_exp_cooldown_change::PlayerExpCooldownChangeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerExpCooldownChange(
+                    PlayerExpCooldownChangeEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        new_cooldown: self.new_cooldown,
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerGamemodeChange(PlayerGamemodeChangeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    previous_gamemode: format!("{:?}", self.previous_gamemode),
+                    new_gamemode: format!("{:?}", self.new_gamemode),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_harvest_block::PlayerHarvestBlockEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerHarvestBlock(PlayerHarvestBlockEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    harvested_items_names: self
+                        .harvested_items
+                        .iter()
+                        .map(|i| i.item.registry_key.to_string())
+                        .collect(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_hide_entity::PlayerHideEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerHideEntity(PlayerHideEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_input::PlayerInputEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerInput(PlayerInputEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    input: self.input.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_interact_at_entity::PlayerInteractAtEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerInteractAtEntity(PlayerInteractAtEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                    clicked_x: self.clicked_x,
+                    clicked_y: self.clicked_y,
+                    clicked_z: self.clicked_z,
+                    hand: u32::from(self.hand),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerInteractEntity(PlayerInteractEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    target_uuid: None,
+                    action: format!("{:?}", self.action),
+                    target_position_x: self.target_position.map(|p| p.x).unwrap_or(0.0),
+                    target_position_y: self.target_position.map(|p| p.y).unwrap_or(0.0),
+                    target_position_z: self.target_position.map(|p| p.z).unwrap_or(0.0),
+                    sneaking: self.sneaking,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_interact_event::PlayerInteractEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerInteract(PlayerInteractEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    action: match self.action {
+                        pumpkin::plugin::player::InteractAction::LeftClickBlock => {
+                            "LEFT_CLICK_BLOCK"
+                        }
+                        pumpkin::plugin::player::InteractAction::LeftClickAir => "LEFT_CLICK_AIR",
+                        pumpkin::plugin::player::InteractAction::RightClickAir => "RIGHT_CLICK_AIR",
+                        pumpkin::plugin::player::InteractAction::RightClickBlock => {
+                            "RIGHT_CLICK_BLOCK"
+                        }
+                    }
+                    .to_string(),
+                    clicked_pos_x: self.clicked_pos.map(|p| p.0.x).unwrap_or(0),
+                    clicked_pos_y: self.clicked_pos.map(|p| p.0.y).unwrap_or(0),
+                    clicked_pos_z: self.clicked_pos.map(|p| p.0.z).unwrap_or(0),
+                    block: self.block.name.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_interact_unknown_entity_event::PlayerInteractUnknownEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerInteractUnknownEntity(PlayerInteractUnknownEntityEvent {
+                    player_uuid: Some(Uuid { value: self.player.gameprofile.id.to_string() }),
+                    entity_id: self.entity_id,
+                    action: format!("{:?}", self.action),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_item_break::PlayerItemBreakEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerItemBreak(PlayerItemBreakEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_item_consume::PlayerItemConsumeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerItemConsume(PlayerItemConsumeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_item_damage::PlayerItemDamageEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerItemDamage(PlayerItemDamageEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                    damage: self.damage,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_item_mend::PlayerItemMendEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerItemMend(PlayerItemMendEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                    repair_amount: self.repair_amount,
+                    exp_consumed: self.exp_consumed,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_join::PlayerJoinEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerJoin(PlayerJoinEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    join_message: serde_json::to_string(&self.join_message).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_kick::PlayerKickEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerKick(PlayerKickEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    reason: self.reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_leash_entity::PlayerLeashEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLeashEntity(PlayerLeashEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                    holder_id: self.holder_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_leave::PlayerLeaveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLeave(PlayerLeaveEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    leave_message: serde_json::to_string(&self.leave_message).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_level_change::PlayerLevelChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLevelChange(PlayerLevelChangeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    old_level: self.old_level,
+                    new_level: self.new_level,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_links_send::PlayerLinksSendEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLinksSend(PlayerLinksSendEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    links: self.links.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_locale_change::PlayerLocaleChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLocaleChange(PlayerLocaleChangeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    new_locale: self.new_locale.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_login::PlayerLoginEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerLogin(PlayerLoginEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    kick_message: serde_json::to_string(&self.kick_message).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_move::PlayerMoveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerMove(PlayerMoveEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    from_x: self.from.x,
+                    from_y: self.from.y,
+                    from_z: self.from.z,
+                    to_x: self.to.x,
+                    to_y: self.to.y,
+                    to_z: self.to.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_name_entity::PlayerNameEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerNameEntity(PlayerNameEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                    name: serde_json::to_string(&self.name).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_open_sign::PlayerOpenSignEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerOpenSign(PlayerOpenSignEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    is_front: self.is_front,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_permission_check::PlayerPermissionCheckEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerPermissionCheck(PlayerPermissionCheckEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    permission: self.permission.clone(),
+                    result: self.result,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_pickup_arrow::PlayerPickupArrowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerPickupArrow(PlayerPickupArrowEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    arrow_id: self.arrow_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_portal::PlayerPortalEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerPortal(PlayerPortalEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    from_pos_x: self.from_pos.0.x,
+                    from_pos_y: self.from_pos.0.y,
+                    from_pos_z: self.from_pos.0.z,
+                    to_pos_x: self.to_pos.map(|p| p.0.x).unwrap_or(0),
+                    to_pos_y: self.to_pos.map(|p| p.0.y).unwrap_or(0),
+                    to_pos_z: self.to_pos.map(|p| p.0.z).unwrap_or(0),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_pre_login::PlayerPreLoginEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerPreLogin(PlayerPreLoginEvent {
+                    player_name: self.player_name.clone(),
+                    player_uuid: Some(Uuid {
+                        value: self.player_uuid.to_string(),
+                    }),
+                    ip_address: self.ip_address.to_string(),
+                    kick_message: serde_json::to_string(&self.kick_message).unwrap_or_default(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_recipe_book_click::PlayerRecipeBookClickEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRecipeBookClick(PlayerRecipeBookClickEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    recipe_id: self.recipe_id.clone(),
+                    make_all: self.make_all,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRecipeBookSettingsChange(PlayerRecipeBookSettingsChangeEvent {
+                    player_uuid: Some(Uuid { value: self.player.gameprofile.id.to_string() }),
+                    book_type: self.book_type.clone(),
+                    is_open: self.is_open,
+                    is_filtering: self.is_filtering,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_recipe_discover::PlayerRecipeDiscoverEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRecipeDiscover(PlayerRecipeDiscoverEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    recipe_id: self.recipe_id.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_register_channel::PlayerRegisterChannelEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRegisterChannel(PlayerRegisterChannelEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    channel: self.channel.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_resource_pack_status::PlayerResourcePackStatusEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerResourcePackStatus(
+                    PlayerResourcePackStatusEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        pack_id: self.pack_id.clone(),
+                        status: self.status.clone(),
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_respawn::PlayerRespawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRespawn(PlayerRespawnEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    previous_world_uuid: None,
+                    respawned_world_uuid: None,
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    yaw: self.yaw,
+                    pitch: self.pitch,
+                    alive: self.alive,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_riptide::PlayerRiptideEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerRiptide(PlayerRiptideEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_shear_entity::PlayerShearEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerShearEntity(PlayerShearEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                    hand: u32::from(self.hand),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_show_entity::PlayerShowEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerShowEntity(PlayerShowEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_spawn_change::PlayerSpawnChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerSpawnChange(PlayerSpawnChangeEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    new_spawn_x: self.new_spawn.map(|p| p.0.x).unwrap_or(0),
+                    new_spawn_y: self.new_spawn.map(|p| p.0.y).unwrap_or(0),
+                    new_spawn_z: self.new_spawn.map(|p| p.0.z).unwrap_or(0),
+                    forced: self.forced,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_spawn_location::PlayerSpawnLocationEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerSpawnLocation(PlayerSpawnLocationEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    spawn_pos_x: self.spawn_pos.x,
+                    spawn_pos_y: self.spawn_pos.y,
+                    spawn_pos_z: self.spawn_pos.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_statistic_increment::PlayerStatisticIncrementEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerStatisticIncrement(
+                    PlayerStatisticIncrementEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        statistic_id: self.statistic_id.clone(),
+                        amount: self.amount,
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_swap_hands::PlayerSwapHandItemsEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerSwapHandItems(PlayerSwapHandItemsEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_take_lectern_book::PlayerTakeLecternBookEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerTakeLecternBook(PlayerTakeLecternBookEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    book_name: self.book.item.registry_key.to_string(),
+                    book_count: i32::from(self.book.item_count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_teleport::PlayerTeleportEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerTeleport(PlayerTeleportEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    from_x: self.from.x,
+                    from_y: self.from.y,
+                    from_z: self.from.z,
+                    to_x: self.to.x,
+                    to_y: self.to.y,
+                    to_z: self.to.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerToggleFlight(PlayerToggleFlightEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    is_flying: self.is_flying,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_toggle_sneak_event::PlayerToggleSneakEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerToggleSneak(PlayerToggleSneakEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    is_sneaking: self.is_sneaking,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_toggle_sprint_event::PlayerToggleSprintEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerToggleSprint(PlayerToggleSprintEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    is_sprinting: self.is_sprinting,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_unleash_entity::PlayerUnleashEntityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerUnleashEntity(PlayerUnleashEntityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::player::player_unregister_channel::PlayerUnregisterChannelEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerUnregisterChannel(
+                    PlayerUnregisterChannelEvent {
+                        player_uuid: Some(Uuid {
+                            value: self.player.gameprofile.id.to_string(),
+                        }),
+                        channel: self.channel.clone(),
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::player::player_velocity::PlayerVelocityEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerVelocity(PlayerVelocityEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    velocity_x: self.velocity.x,
+                    velocity_y: self.velocity.y,
+                    velocity_z: self.velocity.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::hanging::hanging_break::HangingBreakEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::HangingBreak(HangingBreakEvent {
+                    entity_uuid: None,
+                    remover_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::hanging::hanging_break_by_entity::HangingBreakByEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::HangingBreakByEntity(HangingBreakByEntityEvent {
+                    entity_uuid: None,
+                    remover_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::hanging::hanging_place::HangingPlaceEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::HangingPlace(HangingPlaceEvent {
+                    entity_uuid: None,
+                    player_uuid: self.player.as_ref().map(|p| Uuid {
+                        value: p.gameprofile.id.to_string(),
+                    }),
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    block_face: format!("{:?}", self.block_face),
                 })),
             },
             context: EventContext {
@@ -512,20 +4676,20 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_ignite::BlockIgniteEvent
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::block::block_grow::BlockGrowEvent {
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::area_effect_cloud_apply::AreaEffectCloudApplyEvent
+{
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::BlockGrow(BlockGrowEvent {
-                    block_x: self.block_pos.0.x,
-                    block_y: self.block_pos.0.y,
-                    block_z: self.block_pos.0.z,
-                    new_block_type: self.new_block.name.to_string(),
+                data: Some(Data::AreaEffectCloudApply(AreaEffectCloudApplyEvent {
+                    entity_id: self.entity_id,
+                    affected_entities: self.affected_entities.clone(),
                 })),
             },
             context: EventContext {
@@ -535,20 +4699,21 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_grow::BlockGrowEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::block::block_form::BlockFormEvent {
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::arrow_body_count_change::ArrowBodyCountChangeEvent
+{
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::BlockForm(BlockFormEvent {
-                    block_x: self.block_pos.0.x,
-                    block_y: self.block_pos.0.y,
-                    block_z: self.block_pos.0.z,
-                    new_block_type: self.block.name.to_string(),
+                data: Some(Data::ArrowBodyCountChange(ArrowBodyCountChangeEvent {
+                    entity_id: self.entity_id,
+                    old_amount: self.old_amount,
+                    new_amount: self.new_amount,
                 })),
             },
             context: EventContext {
@@ -558,20 +4723,18 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_form::BlockFormEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
-impl PatchBukkitEvent for pumpkin::plugin::block::block_fade::BlockFadeEvent {
+impl PatchBukkitEvent for pumpkin::plugin::entity::bat_toggle_sleep::BatToggleSleepEvent {
     fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
         JvmEventPayload {
             event: Event {
-                data: Some(Data::BlockFade(BlockFadeEvent {
-                    block_x: self.block_pos.0.x,
-                    block_y: self.block_pos.0.y,
-                    block_z: self.block_pos.0.z,
-                    new_block_type: self.block.name.to_string(),
+                data: Some(Data::BatToggleSleep(BatToggleSleepEvent {
+                    entity_id: self.entity_id,
+                    is_awake: self.is_awake,
                 })),
             },
             context: EventContext {
@@ -581,8 +4744,1834 @@ impl PatchBukkitEvent for pumpkin::plugin::block::block_fade::BlockFadeEvent {
         }
     }
 
-    fn apply_modifications(&mut self, _server: &Arc<Server>, _data: Data) -> Option<()> {
-        Some(())
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::creature_spawn::CreatureSpawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::CreatureSpawn(CreatureSpawnEvent {
+                    entity_id: self.entity_id,
+                    entity_type: self.entity_type.clone(),
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    world_uuid: None,
+                    spawn_reason: self.spawn_reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::creeper_power::CreeperPowerEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::CreeperPower(CreeperPowerEvent {
+                    entity_id: self.entity_id,
+                    cause: self.cause.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::ender_dragon_change_phase::EnderDragonChangePhaseEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EnderDragonChangePhase(EnderDragonChangePhaseEvent {
+                    entity_id: self.entity_id,
+                    current_phase: self.current_phase.clone(),
+                    new_phase: self.new_phase.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_air_change::EntityAirChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityAirChange(EntityAirChangeEvent {
+                    entity_id: self.entity_id,
+                    amount: self.amount,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_break_door::EntityBreakDoorEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityBreakDoor(EntityBreakDoorEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_breed::EntityBreedEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityBreed(EntityBreedEvent {
+                    father_id: self.father_id,
+                    mother_id: self.mother_id,
+                    child_id: self.child_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_change_block::EntityChangeBlockEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityChangeBlock(EntityChangeBlockEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    new_block: self.new_block.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_combust::EntityCombustEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityCombust(EntityCombustEvent {
+                    entity_id: self.entity_id,
+                    duration_secs: self.duration_secs,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_combust_by_block::EntityCombustByBlockEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityCombustByBlock(EntityCombustByBlockEvent {
+                    entity_id: self.entity_id,
+                    combuster_x: self.combuster.0.x,
+                    combuster_y: self.combuster.0.y,
+                    combuster_z: self.combuster.0.z,
+                    duration: self.duration,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_combust_by_entity::EntityCombustByEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityCombustByEntity(EntityCombustByEntityEvent {
+                    entity_id: self.entity_id,
+                    combuster_id: self.combuster_id,
+                    duration: self.duration,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_damage::EntityDamageEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDamage(EntityDamageEvent {
+                    entity_id: self.entity_id,
+                    damage: self.damage,
+                    damage_type: self.damage_type.message_id.to_string(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_damage_by_block::EntityDamageByBlockEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDamageByBlock(EntityDamageByBlockEvent {
+                    entity_id: self.entity_id,
+                    damager_pos_x: self.damager_pos.map(|p| p.0.x).unwrap_or(0),
+                    damager_pos_y: self.damager_pos.map(|p| p.0.y).unwrap_or(0),
+                    damager_pos_z: self.damager_pos.map(|p| p.0.z).unwrap_or(0),
+                    damage: self.damage,
+                    cause: self.cause.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_damage_by_entity::EntityDamageByEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDamageByEntity(EntityDamageByEntityEvent {
+                    entity_id: self.entity_id,
+                    damager_id: self.damager_id,
+                    damage: self.damage,
+                    cause: self.cause.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_death::EntityDeathEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDeath(EntityDeathEvent {
+                    entity_id: self.entity_id,
+                    dropped_exp: self.dropped_exp,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_death::PlayerDeathEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PlayerDeath(PlayerDeathEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    death_message: serde_json::to_string(&self.death_message).unwrap_or_default(),
+                    dropped_exp: self.dropped_exp,
+                    keep_inventory: self.keep_inventory,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_dismount::EntityDismountEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDismount(EntityDismountEvent {
+                    entity_id: self.entity_id,
+                    dismounted_id: self.dismounted_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_drop_item::EntityDropItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDropItem(EntityDropItemEvent {
+                    entity_id: self.entity_id,
+                    item_name: self.item_name.clone(),
+                    count: u32::from(self.count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_dye::EntityDyeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityDye(EntityDyeEvent {
+                    entity_id: self.entity_id,
+                    color: format!("{:?}", self.color),
+                    player_uuid: self.player.as_ref().map(|p| Uuid {
+                        value: p.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: self.player.clone(),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_enter_block::EntityEnterBlockEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityEnterBlock(EntityEnterBlockEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_enter_love_mode::EntityEnterLoveModeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityEnterLoveMode(EntityEnterLoveModeEvent {
+                    entity_id: self.entity_id,
+                    ticks_in_love: self.ticks_in_love,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_exhaustion::EntityExhaustionEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityExhaustion(EntityExhaustionEvent {
+                    entity_id: self.entity_id,
+                    exhaustion: self.exhaustion,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_explode::EntityExplodeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityExplode(EntityExplodeEvent {
+                    entity_id: self.entity_id,
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    yield_rate: self.yield_rate,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_interact::EntityInteractEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityInteract(EntityInteractEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_knockback::EntityKnockbackEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityKnockback(EntityKnockbackEvent {
+                    entity_id: self.entity_id,
+                    knockback_x: self.knockback.x,
+                    knockback_y: self.knockback.y,
+                    knockback_z: self.knockback.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_knockback_by_entity::EntityKnockbackByEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityKnockbackByEntity(
+                    EntityKnockbackByEntityEvent {
+                        entity_id: self.entity_id,
+                        hit_by_id: self.hit_by_id,
+                        force: self.force,
+                        x: self.x,
+                        z: self.z,
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_mount::EntityMountEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityMount(EntityMountEvent {
+                    entity_id: self.entity_id,
+                    mount_id: self.mount_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_pickup_item::EntityPickupItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPickupItem(EntityPickupItemEvent {
+                    entity_id: self.entity_id,
+                    item_name: self.item_name.clone(),
+                    count: u32::from(self.count),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_place::EntityPlaceEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPlace(EntityPlaceEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                    block_name: self.block_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_portal::EntityPortalEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPortal(EntityPortalEvent {
+                    entity_id: self.entity_id,
+                    portal_pos_x: self.portal_pos.0.x,
+                    portal_pos_y: self.portal_pos.0.y,
+                    portal_pos_z: self.portal_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_portal_enter::EntityPortalEnterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPortalEnter(EntityPortalEnterEvent {
+                    entity_id: self.entity_id,
+                    location_x: self.location.0.x,
+                    location_y: self.location.0.y,
+                    location_z: self.location.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_portal_exit::EntityPortalExitEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPortalExit(EntityPortalExitEvent {
+                    entity_id: self.entity_id,
+                    from_pos_x: self.from_pos.0.x,
+                    from_pos_y: self.from_pos.0.y,
+                    from_pos_z: self.from_pos.0.z,
+                    to_pos_x: self.to_pos.map(|p| p.0.x).unwrap_or(0),
+                    to_pos_y: self.to_pos.map(|p| p.0.y).unwrap_or(0),
+                    to_pos_z: self.to_pos.map(|p| p.0.z).unwrap_or(0),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_pose_change::EntityPoseChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPoseChange(EntityPoseChangeEvent {
+                    entity_id: self.entity_id,
+                    pose: self.pose.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_potion_effect::EntityPotionEffectEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityPotionEffect(EntityPotionEffectEvent {
+                    entity_id: self.entity_id,
+                    effect_name: self.effect_name.clone(),
+                    duration: self.duration,
+                    amplifier: u32::from(self.amplifier),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_regain_health::EntityRegainHealthEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityRegainHealth(EntityRegainHealthEvent {
+                    entity_id: self.entity_id,
+                    amount: self.amount,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_remove::EntityRemoveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityRemove(EntityRemoveEvent {
+                    entity_id: self.entity_id,
+                    cause: self.cause.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_resurrect::EntityResurrectEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityResurrect(EntityResurrectEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_shoot_bow::EntityShootBowEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityShootBow(EntityShootBowEvent {
+                    entity_id: self.entity_id,
+                    weapon_name: self.weapon_name.clone(),
+                    force: self.force,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_spawn::EntitySpawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntitySpawn(EntitySpawnEvent {
+                    entity_id: self.entity_id,
+                    entity_type: self.entity_type.clone(),
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    world_uuid: None,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_spell_cast::EntitySpellCastEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntitySpellCast(EntitySpellCastEvent {
+                    entity_id: self.entity_id,
+                    spell: self.spell.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_tame::EntityTameEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTame(EntityTameEvent {
+                    entity_id: self.entity_id,
+                    owner_uuid: Some(Uuid {
+                        value: self.owner.gameprofile.id.to_string(),
+                    }),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.owner.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_target::EntityTargetEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTarget(EntityTargetEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_target_block::EntityTargetBlockEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTargetBlock(EntityTargetBlockEvent {
+                    entity_id: self.entity_id,
+                    block_x: self.block_pos.0.x,
+                    block_y: self.block_pos.0.y,
+                    block_z: self.block_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::entity_target_living_entity::EntityTargetLivingEntityEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTargetLivingEntity(
+                    EntityTargetLivingEntityEvent {
+                        entity_id: self.entity_id,
+                        reason: self.reason.clone(),
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_teleport::EntityTeleportEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTeleport(EntityTeleportEvent {
+                    entity_id: self.entity_id,
+                    from_position_x: self.from_position.x,
+                    from_position_y: self.from_position.y,
+                    from_position_z: self.from_position.z,
+                    to_position_x: self.to_position.x,
+                    to_position_y: self.to_position.y,
+                    to_position_z: self.to_position.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_toggle_glide::EntityToggleGlideEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityToggleGlide(EntityToggleGlideEvent {
+                    entity_id: self.entity_id,
+                    is_gliding: self.is_gliding,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_toggle_swim::EntityToggleSwimEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityToggleSwim(EntityToggleSwimEvent {
+                    entity_id: self.entity_id,
+                    is_swimming: self.is_swimming,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_transform::EntityTransformEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityTransform(EntityTransformEvent {
+                    entity_id: self.entity_id,
+                    new_entity_id: self.new_entity_id,
+                    transform_reason: self.transform_reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::entity_unleash::EntityUnleashEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EntityUnleash(EntityUnleashEvent {
+                    entity_id: self.entity_id,
+                    reason: self.reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::exp_bottle::ExpBottleEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ExpBottle(ExpBottleEvent {
+                    entity_id: self.entity_id,
+                    experience: self.experience,
+                    location_x: self.location.0.x,
+                    location_y: self.location.0.y,
+                    location_z: self.location.0.z,
+                    show_effect: self.show_effect,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::explosion_prime::ExplosionPrimeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ExplosionPrime(ExplosionPrimeEvent {
+                    entity_id: self.entity_id,
+                    radius: self.radius,
+                    fire: self.fire,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::firework_explode::FireworkExplodeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FireworkExplode(FireworkExplodeEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::food_level_change::FoodLevelChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::FoodLevelChange(FoodLevelChangeEvent {
+                    entity_id: self.entity_id,
+                    food_level: u32::from(self.food_level),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::horse_jump::HorseJumpEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::HorseJump(HorseJumpEvent {
+                    entity_id: self.entity_id,
+                    power: self.power,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::item_despawn::ItemDespawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ItemDespawn(ItemDespawnEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::item_merge::ItemMergeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ItemMerge(ItemMergeEvent {
+                    entity_id: self.entity_id,
+                    target_id: self.target_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::item_spawn::ItemSpawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ItemSpawn(ItemSpawnEvent {
+                    entity_id: self.entity_id,
+                    pos_x: self.position.x,
+                    pos_y: self.position.y,
+                    pos_z: self.position.z,
+                    item_name: self.item_name.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::lingering_potion_splash::LingeringPotionSplashEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::LingeringPotionSplash(LingeringPotionSplashEvent {
+                    entity_id: self.entity_id,
+                    location_x: self.location.0.x,
+                    location_y: self.location.0.y,
+                    location_z: self.location.0.z,
+                    potion_item: self.potion_item.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::pig_zap::PigZapEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PigZap(PigZapEvent {
+                    entity_id: self.entity_id,
+                    lightning_id: self.lightning_id,
+                    pig_zombie_id: self.pig_zombie_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::pig_zombie_anger::PigZombieAngerEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PigZombieAnger(PigZombieAngerEvent {
+                    entity_id: self.entity_id,
+                    new_anger: self.new_anger,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::piglin_barter::PiglinBarterEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PiglinBarter(PiglinBarterEvent {
+                    entity_id: self.entity_id,
+                    input_item_name: self.input_item.item.registry_key.to_string(),
+                    input_item_count: i32::from(self.input_item.item_count),
+                    outcome_names: self
+                        .outcome
+                        .iter()
+                        .map(|i| i.item.registry_key.to_string())
+                        .collect(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::potion_splash::PotionSplashEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PotionSplash(PotionSplashEvent {
+                    entity_id: self.entity_id,
+                    location_x: self.location.0.x,
+                    location_y: self.location.0.y,
+                    location_z: self.location.0.z,
+                    potion_item: self.potion_item.clone(),
+                    affected_entities: self.affected_entities.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::projectile_hit::ProjectileHitEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ProjectileHit(ProjectileHitEvent {
+                    entity_id: self.entity_id,
+                    hit_position_x: self.hit_position.x,
+                    hit_position_y: self.hit_position.y,
+                    hit_position_z: self.hit_position.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::projectile_launch::ProjectileLaunchEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::ProjectileLaunch(ProjectileLaunchEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::sheep_dye_wool::SheepDyeWoolEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SheepDyeWool(SheepDyeWoolEvent {
+                    entity_id: self.entity_id,
+                    dye_color: u32::from(self.dye_color),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::sheep_regrow_wool::SheepRegrowWoolEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SheepRegrowWool(SheepRegrowWoolEvent {
+                    entity_id: self.entity_id,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::slime_split::SlimeSplitEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SlimeSplit(SlimeSplitEvent {
+                    entity_id: self.entity_id,
+                    count: self.count,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::spawner_spawn::SpawnerSpawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::SpawnerSpawn(SpawnerSpawnEvent {
+                    entity_id: self.entity_id,
+                    spawner_pos_x: self.spawner_pos.0.x,
+                    spawner_pos_y: self.spawner_pos.0.y,
+                    spawner_pos_z: self.spawner_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::strider_temperature_change::StriderTemperatureChangeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::StriderTemperatureChange(
+                    StriderTemperatureChangeEvent {
+                        entity_id: self.entity_id,
+                        is_shivering: self.is_shivering,
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::trial_spawner_spawn::TrialSpawnerSpawnEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::TrialSpawnerSpawn(TrialSpawnerSpawnEvent {
+                    entity_id: self.entity_id,
+                    spawner_pos_x: self.spawner_pos.0.x,
+                    spawner_pos_y: self.spawner_pos.0.y,
+                    spawner_pos_z: self.spawner_pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::villager_acquire_trade::VillagerAcquireTradeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VillagerAcquireTrade(VillagerAcquireTradeEvent {
+                    entity_id: self.entity_id,
+                    recipe_index: self.recipe_index,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::villager_career_change::VillagerCareerChangeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VillagerCareerChange(VillagerCareerChangeEvent {
+                    entity_id: self.entity_id,
+                    profession: self.profession.clone(),
+                    reason: self.reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::villager_replenish_trade::VillagerReplenishTradeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VillagerReplenishTrade(VillagerReplenishTradeEvent {
+                    entity_id: self.entity_id,
+                    restock_quantity: self.restock_quantity,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::entity::villager_reputation_change::VillagerReputationChangeEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::VillagerReputationChange(
+                    VillagerReputationChangeEvent {
+                        entity_id: self.entity_id,
+                        target_id: self.target_id,
+                        reputation_change: self.reputation_change,
+                    },
+                )),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::entity::warden_anger_change::WardenAngerChangeEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::WardenAngerChange(WardenAngerChangeEvent {
+                    entity_id: self.entity_id,
+                    target_id: self.target_id,
+                    old_anger: self.old_anger,
+                    new_anger: self.new_anger,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::raid::raid_finish::RaidFinishEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::RaidFinish(RaidFinishEvent {
+                    victory: self.victory,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::raid::raid_spawn_wave::RaidSpawnWaveEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::RaidSpawnWave(RaidSpawnWaveEvent {
+                    wave: self.wave,
+                    block_x: self.pos.0.x,
+                    block_y: self.pos.0.y,
+                    block_z: self.pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::raid::raid_stop::RaidStopEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::RaidStop(RaidStopEvent {
+                    reason: self.reason.clone(),
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::raid::raid_trigger::RaidTriggerEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::RaidTrigger(RaidTriggerEvent {
+                    block_x: self.pos.0.x,
+                    block_y: self.pos.0.y,
+                    block_z: self.pos.0.z,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: None,
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent for pumpkin::plugin::enchantment::enchant_item::EnchantItemEvent {
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::EnchantItem(EnchantItemEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                    option: self.option,
+                    exp_level_cost: self.exp_level_cost,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
+    }
+}
+
+impl PatchBukkitEvent
+    for pumpkin::plugin::enchantment::prepare_item_enchant::PrepareItemEnchantEvent
+{
+    fn to_payload(&self, server: Arc<Server>) -> JvmEventPayload {
+        JvmEventPayload {
+            event: Event {
+                data: Some(Data::PrepareItemEnchant(PrepareItemEnchantEvent {
+                    player_uuid: Some(Uuid {
+                        value: self.player.gameprofile.id.to_string(),
+                    }),
+                    item_name: self.item.item.registry_key.to_string(),
+                    item_count: i32::from(self.item.item_count),
+                    level_requirements: self.level_requirements.to_vec(),
+                    enchantment_id: self.enchantment_id.to_vec(),
+                    enchantment_level: self.enchantment_level.to_vec(),
+                    bookshelf_count: self.bookshelf_count,
+                })),
+            },
+            context: EventContext {
+                server,
+                player: Some(self.player.clone()),
+            },
+        }
+    }
+
+    fn set_cancelled(&mut self, cancelled: bool) {
+        pumpkin::plugin::Cancellable::set_cancelled(self, cancelled);
     }
 }
 
@@ -605,7 +6594,7 @@ impl<E: PatchBukkitEvent> PatchBukkitEventHandler<E> {
 
 impl<E> EventHandler<E> for PatchBukkitEventHandler<E>
 where
-    E: PatchBukkitEvent + Payload + Cancellable + 'static,
+    E: PatchBukkitEvent + Payload + 'static,
 {
     fn handle<'a>(&'a self, server: &'a Arc<Server>, event: &'a E) -> BoxFuture<'a, ()> {
         let command_tx = self.command_tx.clone();
diff --git a/rust/src/java/native_callbacks/events.rs b/rust/src/java/native_callbacks/events.rs
index 61d55b3..288830b 100644
--- a/rust/src/java/native_callbacks/events.rs
+++ b/rust/src/java/native_callbacks/events.rs
@@ -1,61 +1,51 @@
+#![allow(clippy::all)]
 use std::collections::HashSet;
 use std::sync::{Arc, LazyLock, Mutex};
 
 use pumpkin::plugin::EventPriority;
 
 use crate::events::handler::PatchBukkitEventHandler;
-use crate::java::native_callbacks::CALLBACK_CONTEXT;
 use crate::proto::patchbukkit::events::{
-    CallEventRequest, CallEventResponse, RegisterEventRequest,
+    CallEventRequest, CallEventResponse, FireEventResponse, RegisterEventRequest,
 };
 
-/// One Pumpkin handler per (plugin, event type). The Java side already deduplicates its
-/// registerEvent calls, but this guard also protects against direct HandlerList
-/// registrations and plugin reloads re-registering: every duplicate Pumpkin handler costs a
-/// full serialize + cross-thread round trip per event fire, and re-invokes listeners that
-/// already ran.
 static REGISTERED_EVENTS: LazyLock<Mutex<HashSet<(String, String)>>> =
     LazyLock::new(|| Mutex::new(HashSet::new()));
 
-pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> Option<()> {
-    let ctx = CALLBACK_CONTEXT.get()?;
+pub fn ffi_native_bridge_call_event_impl(request: CallEventRequest) -> Option<CallEventResponse> {
+    Some(CallEventResponse {
+        response: Some(FireEventResponse {
+            cancelled: false,
+            data: request.event,
+        }),
+    })
+}
 
-    {
-        let mut registered = REGISTERED_EVENTS.lock().ok()?;
-        if !registered.insert((request.plugin_name.clone(), request.event_type.clone())) {
-            tracing::debug!(
-                "Skipping duplicate native registration of '{}' for plugin '{}'",
-                request.event_type,
-                request.plugin_name
-            );
-            return Some(());
-        }
+pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> Option<()> {
+    let mut registered = REGISTERED_EVENTS.lock().unwrap();
+    if !registered.insert((request.plugin_name.clone(), request.event_type.clone())) {
+        return Some(());
     }
+
+    let context = crate::java::native_callbacks::CALLBACK_CONTEXT.get()?;
+    let plugin_context = context.plugin_context.clone();
+    let command_tx = context.command_tx.clone();
+
     let pumpkin_priority = match request.priority {
         0 => EventPriority::Lowest,
         1 => EventPriority::Low,
         2 => EventPriority::Normal,
         3 => EventPriority::High,
-        _ => EventPriority::Highest,
+        4 => EventPriority::Highest,
+        _ => EventPriority::Normal,
     };
 
-    tracing::info!(
-        "Plugin '{}' registering listener for '{}' (priority={:?}, blocking={})",
-        request.plugin_name,
-        request.event_type,
-        request.priority,
-        request.blocking
-    );
-
-    let command_tx = ctx.command_tx.clone();
-    let context = ctx.plugin_context.clone();
-
     match request.event_type.as_str() {
-        "org.bukkit.event.player.PlayerJoinEvent" => {
-            context
+        "org.bukkit.event.world.AsyncStructureGenerateEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_join::PlayerJoinEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_join::PlayerJoinEvent>,
+                    pumpkin::plugin::world::async_structure_generate::AsyncStructureGenerateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::async_structure_generate::AsyncStructureGenerateEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -65,11 +55,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerQuitEvent" => {
-            context
+        "org.bukkit.event.world.AsyncStructureSpawnEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_leave::PlayerLeaveEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_leave::PlayerLeaveEvent>,
+                    pumpkin::plugin::world::async_structure_spawn::AsyncStructureSpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::async_structure_spawn::AsyncStructureSpawnEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -79,11 +69,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerGameModeChangeEvent" => {
-            context
+        "org.bukkit.event.world.ChunkLoadEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent>,
+                    pumpkin::plugin::world::chunk_load::ChunkLoad,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::chunk_load::ChunkLoad>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -93,11 +83,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerInteractEvent" => {
-            context
+        "org.bukkit.event.world.ChunkPopulateEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_interact_event::PlayerInteractEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_interact_event::PlayerInteractEvent>,
+                    pumpkin::plugin::world::chunk_populate::ChunkPopulateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::chunk_populate::ChunkPopulateEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -107,11 +97,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockBreakEvent" => {
-            context
+        "org.bukkit.event.world.ChunkUnloadEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_break::BlockBreakEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_break::BlockBreakEvent>,
+                    pumpkin::plugin::world::chunk_save::ChunkSave,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::chunk_save::ChunkSave>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -121,11 +111,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockPlaceEvent" => {
-            context
+        "org.bukkit.event.world.EntitiesLoadEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_place::BlockPlaceEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_place::BlockPlaceEvent>,
+                    pumpkin::plugin::world::entities_load::EntitiesLoadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::entities_load::EntitiesLoadEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -135,11 +125,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.SignChangeEvent" => {
-            context
+        "org.bukkit.event.world.EntitiesUnloadEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::sign_change::SignChangeEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::sign_change::SignChangeEvent>,
+                    pumpkin::plugin::world::entities_unload::EntitiesUnloadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::entities_unload::EntitiesUnloadEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -149,11 +139,263 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockDamageEvent" => {
-            context
+        "org.bukkit.event.world.GenericGameEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_damage::BlockDamageEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_damage::BlockDamageEvent>,
+                    pumpkin::plugin::world::generic_game::GenericGameEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::generic_game::GenericGameEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.weather.LightningStrikeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::lightning_strike::LightningStrikeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::lightning_strike::LightningStrikeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.LootGenerateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::loot_generate::LootGenerateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::loot_generate::LootGenerateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.PortalCreateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::portal_create::PortalCreateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::portal_create::PortalCreateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.SpawnChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::spawn_change::SpawnChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::spawn_change::SpawnChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.StructureGrowEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::structure_grow::StructureGrowEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::structure_grow::StructureGrowEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.TimeSkipEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::time_skip::TimeSkipEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::time_skip::TimeSkipEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.weather.WeatherChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::weather_change::WeatherChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::weather_change::WeatherChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.weather.ThunderChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::weather_change::ThunderChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::weather_change::ThunderChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.WorldInitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::world_init::WorldInitEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::world_init::WorldInitEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.WorldLoadEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::world_load::WorldLoadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::world_load::WorldLoadEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.WorldUnloadEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::world_load::WorldUnloadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::world_load::WorldUnloadEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.world.WorldSaveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::world::world_save::WorldSaveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::world::world_save::WorldSaveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.ServerListPingEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::list_ping::ServerListPingEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::list_ping::ServerListPingEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.MapInitializeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::map_initialize::MapInitializeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::map_initialize::MapInitializeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.PluginDisableEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::plugin_disable::PluginDisableEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::plugin_disable::PluginDisableEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.PluginEnableEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::plugin_enable::PluginEnableEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::plugin_enable::PluginEnableEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.RemoteServerCommandEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::remote_server_command::RemoteServerCommandEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::remote_server_command::RemoteServerCommandEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.BroadcastMessageEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::server_broadcast::ServerBroadcastEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::server_broadcast::ServerBroadcastEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -164,7 +406,7 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                 );
         }
         "org.bukkit.event.server.ServerCommandEvent" => {
-            context
+            plugin_context
                 .register_event::<
                     pumpkin::plugin::server::server_command::ServerCommandEvent,
                     PatchBukkitEventHandler<pumpkin::plugin::server::server_command::ServerCommandEvent>,
@@ -177,11 +419,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockIgniteEvent" => {
-            context
+        "org.bukkit.event.server.ServerLoadEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_ignite::BlockIgniteEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_ignite::BlockIgniteEvent>,
+                    pumpkin::plugin::server::server_load::ServerLoadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::server_load::ServerLoadEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -191,11 +433,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockGrowEvent" => {
-            context
+        "com.destroystokyo.paper.event.server.ServerTickEndEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_grow::BlockGrowEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_grow::BlockGrowEvent>,
+                    pumpkin::plugin::server::server_tick_end::ServerTickEndEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::server_tick_end::ServerTickEndEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -205,11 +447,683 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.block.BlockFormEvent" => {
-            context
+        "com.destroystokyo.paper.event.server.ServerTickStartEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::block::block_form::BlockFormEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::block::block_form::BlockFormEvent>,
+                    pumpkin::plugin::server::server_tick_start::ServerTickStartEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::server_tick_start::ServerTickStartEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.ServiceRegisterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::service_register::ServiceRegisterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::service_register::ServiceRegisterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.ServiceUnregisterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::service_unregister::ServiceUnregisterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::service_unregister::ServiceUnregisterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.server.TabCompleteEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::server::tab_complete::TabCompleteEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::server::tab_complete::TabCompleteEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleBlockCollisionEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_block_collision::VehicleBlockCollisionEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_block_collision::VehicleBlockCollisionEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleCollisionEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_collision::VehicleCollisionEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_collision::VehicleCollisionEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleCreateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_create::VehicleCreateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_create::VehicleCreateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleDamageEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_damage::VehicleDamageEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_damage::VehicleDamageEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleDestroyEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_destroy::VehicleDestroyEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_destroy::VehicleDestroyEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleEnterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_enter::VehicleEnterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_enter::VehicleEnterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleEntityCollisionEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_entity_collision::VehicleEntityCollisionEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_entity_collision::VehicleEntityCollisionEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleExitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_exit::VehicleExitEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_exit::VehicleExitEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleMoveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_move::VehicleMoveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_move::VehicleMoveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.vehicle.VehicleUpdateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::vehicle::vehicle_update::VehicleUpdateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::vehicle::vehicle_update::VehicleUpdateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.BrewEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::brew::BrewEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::brew::BrewEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.BrewingStandFuelEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::brewing_stand_fuel::BrewingStandFuelEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::brewing_stand_fuel::BrewingStandFuelEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.CraftItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::craft_item::CraftItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::craft_item::CraftItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.FurnaceBurnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::furnace_burn::FurnaceBurnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::furnace_burn::FurnaceBurnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.FurnaceExtractEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::furnace_extract::FurnaceExtractEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::furnace_extract::FurnaceExtractEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.FurnaceSmeltEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::furnace_smelt::FurnaceSmeltEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::furnace_smelt::FurnaceSmeltEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.FurnaceStartSmeltEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::furnace_start_smelt::FurnaceStartSmeltEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::furnace_start_smelt::FurnaceStartSmeltEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.HopperInventorySearchEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::hopper_inventory_search::HopperInventorySearchEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::hopper_inventory_search::HopperInventorySearchEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryCreativeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_creative::InventoryCreativeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_creative::InventoryCreativeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryDragEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_drag::InventoryDragEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_drag::InventoryDragEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryInteractEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_interact::InventoryInteractEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_interact::InventoryInteractEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryMoveItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_move_item::InventoryMoveItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_move_item::InventoryMoveItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryOpenEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_open::InventoryOpenEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_open::InventoryOpenEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryPickupItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::inventory_pickup_item::InventoryPickupItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::inventory_pickup_item::InventoryPickupItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.PrepareAnvilEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::prepare_anvil::PrepareAnvilEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::prepare_anvil::PrepareAnvilEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.PrepareGrindstoneEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::prepare_grindstone::PrepareGrindstoneEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::prepare_grindstone::PrepareGrindstoneEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.PrepareInventoryResultEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::prepare_inventory_result::PrepareInventoryResultEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::prepare_inventory_result::PrepareInventoryResultEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.PrepareItemCraftEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::prepare_item_craft::PrepareItemCraftEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::prepare_item_craft::PrepareItemCraftEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.PrepareSmithingEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::prepare_smithing::PrepareSmithingEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::prepare_smithing::PrepareSmithingEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.SmithItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::smith_item::SmithItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::smith_item::SmithItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.TradeSelectEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::inventory::trade_select::TradeSelectEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::inventory::trade_select::TradeSelectEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BellResonateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::bell_resonate::BellResonateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::bell_resonate::BellResonateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BellRingEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::bell_ring::BellRingEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::bell_ring::BellRingEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockBreakEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_break::BlockBreakEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_break::BlockBreakEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockBurnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_burn::BlockBurnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_burn::BlockBurnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockCanBuildEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_can_build::BlockCanBuildEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_can_build::BlockCanBuildEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockCookEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_cook::BlockCookEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_cook::BlockCookEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDamageEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_damage::BlockDamageEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_damage::BlockDamageEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDamageAbortEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_damage_abort::BlockDamageAbortEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_damage_abort::BlockDamageAbortEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDispenseEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_dispense::BlockDispenseEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_dispense::BlockDispenseEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDispenseArmorEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_dispense_armor::BlockDispenseArmorEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_dispense_armor::BlockDispenseArmorEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDispenseLootEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_dispense_loot::BlockDispenseLootEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_dispense_loot::BlockDispenseLootEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockDropItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_drop_item::BlockDropItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_drop_item::BlockDropItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockExpEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_exp::BlockExpEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_exp::BlockExpEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockExplodeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_explode::BlockExplodeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_explode::BlockExplodeEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -220,7 +1134,7 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                 );
         }
         "org.bukkit.event.block.BlockFadeEvent" => {
-            context
+            plugin_context
                 .register_event::<
                     pumpkin::plugin::block::block_fade::BlockFadeEvent,
                     PatchBukkitEventHandler<pumpkin::plugin::block::block_fade::BlockFadeEvent>,
@@ -233,8 +1147,1352 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
+        "org.bukkit.event.block.BlockFertilizeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_fertilize::BlockFertilizeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_fertilize::BlockFertilizeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockFormEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_form::BlockFormEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_form::BlockFormEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockFromToEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_from_to::BlockFromToEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_from_to::BlockFromToEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockGrowEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_grow::BlockGrowEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_grow::BlockGrowEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockIgniteEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_ignite::BlockIgniteEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_ignite::BlockIgniteEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockMultiPlaceEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_multi_place::BlockMultiPlaceEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_multi_place::BlockMultiPlaceEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockPhysicsEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_physics::BlockPhysicsEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_physics::BlockPhysicsEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockPistonExtendEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_piston::BlockPistonExtendEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_piston::BlockPistonExtendEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockPistonRetractEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_piston::BlockPistonRetractEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_piston::BlockPistonRetractEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockPlaceEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_place::BlockPlaceEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_place::BlockPlaceEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockReceiveGameEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_receive_game::BlockReceiveGameEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_receive_game::BlockReceiveGameEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockRedstoneEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_redstone::BlockRedstoneEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_redstone::BlockRedstoneEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockShearEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_shear_entity::BlockShearEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_shear_entity::BlockShearEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BlockSpreadEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::block_spread::BlockSpreadEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::block_spread::BlockSpreadEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.BrewingStartEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::brewing_start::BrewingStartEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::brewing_start::BrewingStartEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.CampfireStartEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::campfire_start::CampfireStartEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::campfire_start::CampfireStartEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.CauldronLevelChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::cauldron_level_change::CauldronLevelChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::cauldron_level_change::CauldronLevelChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.CrafterCraftEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::crafter_craft::CrafterCraftEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::crafter_craft::CrafterCraftEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.EntityBlockFormEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::entity_block_form::EntityBlockFormEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::entity_block_form::EntityBlockFormEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.FluidLevelChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::fluid_level_change::FluidLevelChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::fluid_level_change::FluidLevelChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.InventoryBlockStartEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::inventory_block_start::InventoryBlockStartEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::inventory_block_start::InventoryBlockStartEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.LeavesDecayEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::leaves_decay::LeavesDecayEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::leaves_decay::LeavesDecayEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.MoistureChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::moisture_change::MoistureChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::moisture_change::MoistureChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.NotePlayEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::note_play::NotePlayEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::note_play::NotePlayEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.SculkBloomEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::sculk_bloom::SculkBloomEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::sculk_bloom::SculkBloomEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.SignChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::sign_change::SignChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::sign_change::SignChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.SpongeAbsorbEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::sponge_absorb::SpongeAbsorbEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::sponge_absorb::SpongeAbsorbEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.TNTPrimeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::tnt_prime::TNTPrimeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::tnt_prime::TNTPrimeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.block.VaultDisplayItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::block::vault_display_item::VaultDisplayItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::block::vault_display_item::VaultDisplayItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.AsyncPlayerChatEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::async_player_chat::AsyncPlayerChatEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::async_player_chat::AsyncPlayerChatEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.AsyncPlayerPreLoginEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::async_player_pre_login::AsyncPlayerPreLoginEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::async_player_pre_login::AsyncPlayerPreLoginEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerChangedMainHandEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::changed_main_hand::PlayerChangedMainHandEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::changed_main_hand::PlayerChangedMainHandEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerEggThrowEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::egg_throw::PlayerEggThrowEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::egg_throw::PlayerEggThrowEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerExpChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::exp_change::PlayerExpChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::exp_change::PlayerExpChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerFishEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::fish::PlayerFishEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::fish::PlayerFishEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryCloseEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::inventory_close::InventoryCloseEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::inventory_close::InventoryCloseEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.inventory.InventoryClickEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::inventory_interact::InventoryClickEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::inventory_interact::InventoryClickEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerItemHeldEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::item_held::PlayerItemHeldEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::item_held::PlayerItemHeldEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerAdvancementDoneEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_advancement_done::PlayerAdvancementDoneEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_advancement_done::PlayerAdvancementDoneEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerAnimationEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_animation::PlayerAnimationEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_animation::PlayerAnimationEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerArmorStandManipulateEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_armor_stand_manipulate::PlayerArmorStandManipulateEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_armor_stand_manipulate::PlayerArmorStandManipulateEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerBedEnterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_bed::PlayerBedEnterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_bed::PlayerBedEnterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerBedLeaveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_bed::PlayerBedLeaveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_bed::PlayerBedLeaveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerBucketEmptyEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_bucket::PlayerBucketEmptyEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_bucket::PlayerBucketEmptyEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerBucketFillEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_bucket::PlayerBucketFillEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_bucket::PlayerBucketFillEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerBucketEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_bucket_entity::PlayerBucketEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_bucket_entity::PlayerBucketEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerChangedWorldEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_changed_world::PlayerChangedWorldEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_changed_world::PlayerChangedWorldEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerChannelEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_channel::PlayerChannelEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_channel::PlayerChannelEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerChatEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_chat::PlayerChatEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_chat::PlayerChatEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerCommandPreprocessEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_command_preprocess::PlayerCommandPreprocessEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_command_preprocess::PlayerCommandPreprocessEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerCommandSendEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_command_send::PlayerCommandSendEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_command_send::PlayerCommandSendEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerDropItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_drop_item::PlayerDropItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_drop_item::PlayerDropItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerEditBookEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_edit_book::PlayerEditBookEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_edit_book::PlayerEditBookEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "com.destroystokyo.paper.event.player.PlayerElytraBoostEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_elytra_boost::PlayerElytraBoostEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_elytra_boost::PlayerElytraBoostEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerExpCooldownChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_exp_cooldown_change::PlayerExpCooldownChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_exp_cooldown_change::PlayerExpCooldownChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerGameModeChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_gamemode_change::PlayerGamemodeChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerHarvestBlockEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_harvest_block::PlayerHarvestBlockEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_harvest_block::PlayerHarvestBlockEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerHideEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_hide_entity::PlayerHideEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_hide_entity::PlayerHideEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerInputEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_input::PlayerInputEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_input::PlayerInputEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerInteractAtEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_interact_at_entity::PlayerInteractAtEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_interact_at_entity::PlayerInteractAtEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerInteractEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerInteractEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_interact_event::PlayerInteractEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_interact_event::PlayerInteractEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerItemBreakEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_item_break::PlayerItemBreakEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_item_break::PlayerItemBreakEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerItemConsumeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_item_consume::PlayerItemConsumeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_item_consume::PlayerItemConsumeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerItemDamageEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_item_damage::PlayerItemDamageEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_item_damage::PlayerItemDamageEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerItemMendEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_item_mend::PlayerItemMendEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_item_mend::PlayerItemMendEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerJoinEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_join::PlayerJoinEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_join::PlayerJoinEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerKickEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_kick::PlayerKickEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_kick::PlayerKickEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PlayerLeashEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_leash_entity::PlayerLeashEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_leash_entity::PlayerLeashEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerQuitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_leave::PlayerLeaveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_leave::PlayerLeaveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerLevelChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_level_change::PlayerLevelChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_level_change::PlayerLevelChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerLinksSendEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_links_send::PlayerLinksSendEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_links_send::PlayerLinksSendEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerLocaleChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_locale_change::PlayerLocaleChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_locale_change::PlayerLocaleChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerLoginEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_login::PlayerLoginEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_login::PlayerLoginEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerMoveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_move::PlayerMoveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_move::PlayerMoveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "io.papermc.paper.event.player.PlayerNameEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_name_entity::PlayerNameEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_name_entity::PlayerNameEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "io.papermc.paper.event.player.PlayerOpenSignEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_open_sign::PlayerOpenSignEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_open_sign::PlayerOpenSignEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerPickupArrowEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_pickup_arrow::PlayerPickupArrowEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_pickup_arrow::PlayerPickupArrowEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerPortalEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_portal::PlayerPortalEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_portal::PlayerPortalEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerPreLoginEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_pre_login::PlayerPreLoginEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_pre_login::PlayerPreLoginEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRecipeBookClickEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_recipe_book_click::PlayerRecipeBookClickEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_recipe_book_click::PlayerRecipeBookClickEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRecipeBookSettingsChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRecipeDiscoverEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_recipe_discover::PlayerRecipeDiscoverEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_recipe_discover::PlayerRecipeDiscoverEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRegisterChannelEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_register_channel::PlayerRegisterChannelEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_register_channel::PlayerRegisterChannelEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerResourcePackStatusEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_resource_pack_status::PlayerResourcePackStatusEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_resource_pack_status::PlayerResourcePackStatusEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRespawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_respawn::PlayerRespawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_respawn::PlayerRespawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerRiptideEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_riptide::PlayerRiptideEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_riptide::PlayerRiptideEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerShearEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_shear_entity::PlayerShearEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_shear_entity::PlayerShearEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerShowEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_show_entity::PlayerShowEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_show_entity::PlayerShowEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerSpawnChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_spawn_change::PlayerSpawnChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_spawn_change::PlayerSpawnChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.spigotmc.event.player.PlayerSpawnLocationEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_spawn_location::PlayerSpawnLocationEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_spawn_location::PlayerSpawnLocationEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerStatisticIncrementEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_statistic_increment::PlayerStatisticIncrementEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_statistic_increment::PlayerStatisticIncrementEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerSwapHandItemsEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_swap_hands::PlayerSwapHandItemsEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_swap_hands::PlayerSwapHandItemsEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerTakeLecternBookEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_take_lectern_book::PlayerTakeLecternBookEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_take_lectern_book::PlayerTakeLecternBookEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerTeleportEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_teleport::PlayerTeleportEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_teleport::PlayerTeleportEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.player.PlayerToggleFlightEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
         "org.bukkit.event.player.PlayerToggleSneakEvent" => {
-            context
+            plugin_context
                 .register_event::<
                     pumpkin::plugin::player::player_toggle_sneak_event::PlayerToggleSneakEvent,
                     PatchBukkitEventHandler<pumpkin::plugin::player::player_toggle_sneak_event::PlayerToggleSneakEvent>,
@@ -248,7 +2506,7 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                 );
         }
         "org.bukkit.event.player.PlayerToggleSprintEvent" => {
-            context
+            plugin_context
                 .register_event::<
                     pumpkin::plugin::player::player_toggle_sprint_event::PlayerToggleSprintEvent,
                     PatchBukkitEventHandler<pumpkin::plugin::player::player_toggle_sprint_event::PlayerToggleSprintEvent>,
@@ -261,11 +2519,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerToggleFlightEvent" => {
-            context
+        "org.bukkit.event.player.PlayerUnleashEntityEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_toggle_flight_event::PlayerToggleFlightEvent>,
+                    pumpkin::plugin::player::player_unleash_entity::PlayerUnleashEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_unleash_entity::PlayerUnleashEntityEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -275,11 +2533,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerMoveEvent" => {
-            context
+        "org.bukkit.event.player.PlayerUnregisterChannelEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_move::PlayerMoveEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_move::PlayerMoveEvent>,
+                    pumpkin::plugin::player::player_unregister_channel::PlayerUnregisterChannelEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_unregister_channel::PlayerUnregisterChannelEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -289,14 +2547,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.PlayerInteractEntityEvent"
-        | "org.bukkit.event.player.PlayerInteractAtEntityEvent"
-        | "org.bukkit.event.entity.EntityDamageByEntityEvent"
-        | "org.bukkit.event.entity.EntityDamageEvent" => {
-            context
+        "org.bukkit.event.player.PlayerVelocityEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_interact_entity_event::PlayerInteractEntityEvent>,
+                    pumpkin::plugin::player::player_velocity::PlayerVelocityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::player::player_velocity::PlayerVelocityEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -306,12 +2561,11 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        "org.bukkit.event.player.AsyncPlayerChatEvent"
-        | "org.bukkit.event.player.PlayerChatEvent" => {
-            context
+        "org.bukkit.event.hanging.HangingBreakEvent" => {
+            plugin_context
                 .register_event::<
-                    pumpkin::plugin::player::player_chat::PlayerChatEvent,
-                    PatchBukkitEventHandler<pumpkin::plugin::player::player_chat::PlayerChatEvent>,
+                    pumpkin::plugin::hanging::hanging_break::HangingBreakEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::hanging::hanging_break::HangingBreakEvent>,
                 >(
                     Arc::new(PatchBukkitEventHandler::new(
                         request.plugin_name.clone(),
@@ -321,115 +2575,1188 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
                     request.blocking,
                 );
         }
-        // Player Events
-        "org.bukkit.event.player.PlayerDropItemEvent"
-        | "org.bukkit.event.player.PlayerItemHeldEvent"
-        | "org.bukkit.event.player.PlayerCommandPreprocessEvent"
-        | "org.bukkit.event.player.PlayerRespawnEvent"
-        | "org.bukkit.event.player.PlayerTeleportEvent"
-        | "org.bukkit.event.player.PlayerChangedWorldEvent"
-        | "org.bukkit.event.player.PlayerBedEnterEvent"
-        | "org.bukkit.event.player.PlayerBedLeaveEvent"
-        | "org.bukkit.event.player.PlayerItemConsumeEvent"
-        | "org.bukkit.event.player.PlayerItemDamageEvent"
-        | "org.bukkit.event.player.PlayerItemBreakEvent"
-        | "org.bukkit.event.player.PlayerAnimationEvent"
-        | "org.bukkit.event.player.PlayerBucketEmptyEvent"
-        | "org.bukkit.event.player.PlayerBucketFillEvent"
-        | "org.bukkit.event.player.PlayerAdvancementDoneEvent"
-        | "org.bukkit.event.player.PlayerExpChangeEvent"
-        | "org.bukkit.event.player.PlayerLevelChangeEvent"
-        | "org.bukkit.event.player.PlayerResourcePackStatusEvent"
-        | "org.bukkit.event.player.PlayerStatisticIncrementEvent"
-        | "org.bukkit.event.player.PlayerPortalEvent"
-        | "org.bukkit.event.player.PlayerKickEvent"
-        | "org.bukkit.event.player.PlayerLocaleChangeEvent"
-        | "org.bukkit.event.player.PlayerArmorStandManipulateEvent"
-        | "org.bukkit.event.player.PlayerTakeLecternBookEvent"
-        | "org.bukkit.event.player.PlayerUnleashEntityEvent"
-        | "org.bukkit.event.player.PlayerShearEntityEvent"
-        | "org.bukkit.event.player.PlayerEggThrowEvent"
-        | "org.bukkit.event.player.PlayerFishEvent"
-        | "org.bukkit.event.player.PlayerEvent"
-        // Entity Events
-        | "org.bukkit.event.entity.EntityDamageByBlockEvent"
-        | "org.bukkit.event.entity.EntityDeathEvent"
-        | "org.bukkit.event.entity.PlayerDeathEvent"
-        | "org.bukkit.event.entity.CreatureSpawnEvent"
-        | "org.bukkit.event.entity.EntitySpawnEvent"
-        | "org.bukkit.event.entity.EntityTargetEvent"
-        | "org.bukkit.event.entity.EntityTargetLivingEntityEvent"
-        | "org.bukkit.event.entity.EntityCombustEvent"
-        | "org.bukkit.event.entity.EntityCombustByEntityEvent"
-        | "org.bukkit.event.entity.EntityRegainHealthEvent"
-        | "org.bukkit.event.entity.EntityShootBowEvent"
-        | "org.bukkit.event.entity.EntityToggleGlideEvent"
-        | "org.bukkit.event.entity.EntityPickupItemEvent"
-        | "org.bukkit.event.entity.EntityDropItemEvent"
-        | "org.bukkit.event.entity.EntityExplodeEvent"
-        | "org.bukkit.event.entity.ExplosionPrimeEvent"
-        | "org.bukkit.event.entity.FoodLevelChangeEvent"
-        | "org.bukkit.event.entity.ProjectileHitEvent"
-        | "org.bukkit.event.entity.ProjectileLaunchEvent"
-        | "org.bukkit.event.entity.EntityInteractEvent"
-        | "org.bukkit.event.entity.EntityTransformEvent"
-        | "org.bukkit.event.entity.EntityDismountEvent"
-        | "org.bukkit.event.entity.EntityMountEvent"
+        "org.bukkit.event.hanging.HangingBreakByEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::hanging::hanging_break_by_entity::HangingBreakByEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::hanging::hanging_break_by_entity::HangingBreakByEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.hanging.HangingPlaceEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::hanging::hanging_place::HangingPlaceEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::hanging::hanging_place::HangingPlaceEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.AreaEffectCloudApplyEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::area_effect_cloud_apply::AreaEffectCloudApplyEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::area_effect_cloud_apply::AreaEffectCloudApplyEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ArrowBodyCountChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::arrow_body_count_change::ArrowBodyCountChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::arrow_body_count_change::ArrowBodyCountChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.BatToggleSleepEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::bat_toggle_sleep::BatToggleSleepEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::bat_toggle_sleep::BatToggleSleepEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.CreatureSpawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::creature_spawn::CreatureSpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::creature_spawn::CreatureSpawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.CreeperPowerEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::creeper_power::CreeperPowerEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::creeper_power::CreeperPowerEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EnderDragonChangePhaseEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::ender_dragon_change_phase::EnderDragonChangePhaseEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::ender_dragon_change_phase::EnderDragonChangePhaseEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityAirChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_air_change::EntityAirChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_air_change::EntityAirChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityBreakDoorEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_break_door::EntityBreakDoorEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_break_door::EntityBreakDoorEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityBreedEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_breed::EntityBreedEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_breed::EntityBreedEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityChangeBlockEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_change_block::EntityChangeBlockEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_change_block::EntityChangeBlockEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityCombustEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_combust::EntityCombustEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_combust::EntityCombustEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityCombustByBlockEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_combust_by_block::EntityCombustByBlockEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_combust_by_block::EntityCombustByBlockEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityCombustByEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_combust_by_entity::EntityCombustByEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_combust_by_entity::EntityCombustByEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDamageEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_damage::EntityDamageEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_damage::EntityDamageEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDamageByBlockEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_damage_by_block::EntityDamageByBlockEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_damage_by_block::EntityDamageByBlockEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDamageByEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_damage_by_entity::EntityDamageByEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_damage_by_entity::EntityDamageByEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDeathEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_death::EntityDeathEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_death::EntityDeathEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PlayerDeathEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_death::PlayerDeathEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_death::PlayerDeathEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDismountEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_dismount::EntityDismountEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_dismount::EntityDismountEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityDropItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_drop_item::EntityDropItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_drop_item::EntityDropItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "io.papermc.paper.event.entity.EntityDyeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_dye::EntityDyeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_dye::EntityDyeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityEnterBlockEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_enter_block::EntityEnterBlockEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_enter_block::EntityEnterBlockEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityEnterLoveModeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_enter_love_mode::EntityEnterLoveModeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_enter_love_mode::EntityEnterLoveModeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityExhaustionEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_exhaustion::EntityExhaustionEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_exhaustion::EntityExhaustionEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityExplodeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_explode::EntityExplodeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_explode::EntityExplodeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityInteractEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_interact::EntityInteractEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_interact::EntityInteractEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityKnockbackEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_knockback::EntityKnockbackEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_knockback::EntityKnockbackEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityKnockbackByEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_knockback_by_entity::EntityKnockbackByEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_knockback_by_entity::EntityKnockbackByEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityMountEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_mount::EntityMountEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_mount::EntityMountEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPickupItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_pickup_item::EntityPickupItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_pickup_item::EntityPickupItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPlaceEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_place::EntityPlaceEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_place::EntityPlaceEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPortalEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_portal::EntityPortalEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_portal::EntityPortalEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPortalEnterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_portal_enter::EntityPortalEnterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_portal_enter::EntityPortalEnterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPortalExitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_portal_exit::EntityPortalExitEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_portal_exit::EntityPortalExitEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPoseChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_pose_change::EntityPoseChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_pose_change::EntityPoseChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityPotionEffectEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_potion_effect::EntityPotionEffectEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_potion_effect::EntityPotionEffectEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityRegainHealthEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_regain_health::EntityRegainHealthEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_regain_health::EntityRegainHealthEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityRemoveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_remove::EntityRemoveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_remove::EntityRemoveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityResurrectEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_resurrect::EntityResurrectEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_resurrect::EntityResurrectEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityShootBowEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_shoot_bow::EntityShootBowEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_shoot_bow::EntityShootBowEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntitySpawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_spawn::EntitySpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_spawn::EntitySpawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntitySpellCastEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_spell_cast::EntitySpellCastEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_spell_cast::EntitySpellCastEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityTameEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_tame::EntityTameEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_tame::EntityTameEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityTargetEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_target::EntityTargetEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_target::EntityTargetEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityTargetLivingEntityEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_target_living_entity::EntityTargetLivingEntityEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_target_living_entity::EntityTargetLivingEntityEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityTeleportEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_teleport::EntityTeleportEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_teleport::EntityTeleportEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityToggleGlideEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_toggle_glide::EntityToggleGlideEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_toggle_glide::EntityToggleGlideEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityToggleSwimEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_toggle_swim::EntityToggleSwimEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_toggle_swim::EntityToggleSwimEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityTransformEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_transform::EntityTransformEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_transform::EntityTransformEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.EntityUnleashEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::entity_unleash::EntityUnleashEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::entity_unleash::EntityUnleashEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ExpBottleEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::exp_bottle::ExpBottleEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::exp_bottle::ExpBottleEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ExplosionPrimeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::explosion_prime::ExplosionPrimeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::explosion_prime::ExplosionPrimeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.FireworkExplodeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::firework_explode::FireworkExplodeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::firework_explode::FireworkExplodeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.FoodLevelChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::food_level_change::FoodLevelChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::food_level_change::FoodLevelChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.HorseJumpEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::horse_jump::HorseJumpEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::horse_jump::HorseJumpEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ItemDespawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::item_despawn::ItemDespawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::item_despawn::ItemDespawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ItemMergeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::item_merge::ItemMergeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::item_merge::ItemMergeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ItemSpawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::item_spawn::ItemSpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::item_spawn::ItemSpawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.LingeringPotionSplashEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::lingering_potion_splash::LingeringPotionSplashEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::lingering_potion_splash::LingeringPotionSplashEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PigZapEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::pig_zap::PigZapEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::pig_zap::PigZapEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PigZombieAngerEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::pig_zombie_anger::PigZombieAngerEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::pig_zombie_anger::PigZombieAngerEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PiglinBarterEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::piglin_barter::PiglinBarterEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::piglin_barter::PiglinBarterEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.PotionSplashEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::potion_splash::PotionSplashEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::potion_splash::PotionSplashEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ProjectileHitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::projectile_hit::ProjectileHitEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::projectile_hit::ProjectileHitEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.ProjectileLaunchEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::projectile_launch::ProjectileLaunchEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::projectile_launch::ProjectileLaunchEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.SheepDyeWoolEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::sheep_dye_wool::SheepDyeWoolEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::sheep_dye_wool::SheepDyeWoolEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.SheepRegrowWoolEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::sheep_regrow_wool::SheepRegrowWoolEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::sheep_regrow_wool::SheepRegrowWoolEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.SlimeSplitEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::slime_split::SlimeSplitEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::slime_split::SlimeSplitEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.SpawnerSpawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::spawner_spawn::SpawnerSpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::spawner_spawn::SpawnerSpawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.StriderTemperatureChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::strider_temperature_change::StriderTemperatureChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::strider_temperature_change::StriderTemperatureChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.TrialSpawnerSpawnEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::trial_spawner_spawn::TrialSpawnerSpawnEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::trial_spawner_spawn::TrialSpawnerSpawnEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.VillagerAcquireTradeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::villager_acquire_trade::VillagerAcquireTradeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::villager_acquire_trade::VillagerAcquireTradeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.VillagerCareerChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::villager_career_change::VillagerCareerChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::villager_career_change::VillagerCareerChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.entity.VillagerReplenishTradeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::villager_replenish_trade::VillagerReplenishTradeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::villager_replenish_trade::VillagerReplenishTradeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "io.papermc.paper.event.entity.WardenAngerChangeEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::entity::warden_anger_change::WardenAngerChangeEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::entity::warden_anger_change::WardenAngerChangeEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.raid.RaidFinishEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::raid::raid_finish::RaidFinishEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::raid::raid_finish::RaidFinishEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.raid.RaidSpawnWaveEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::raid::raid_spawn_wave::RaidSpawnWaveEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::raid::raid_spawn_wave::RaidSpawnWaveEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.raid.RaidStopEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::raid::raid_stop::RaidStopEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::raid::raid_stop::RaidStopEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.raid.RaidTriggerEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::raid::raid_trigger::RaidTriggerEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::raid::raid_trigger::RaidTriggerEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.enchantment.EnchantItemEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::enchantment::enchant_item::EnchantItemEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::enchantment::enchant_item::EnchantItemEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        "org.bukkit.event.enchantment.PrepareItemEnchantEvent" => {
+            plugin_context
+                .register_event::<
+                    pumpkin::plugin::enchantment::prepare_item_enchant::PrepareItemEnchantEvent,
+                    PatchBukkitEventHandler<pumpkin::plugin::enchantment::prepare_item_enchant::PrepareItemEnchantEvent>,
+                >(
+                    Arc::new(PatchBukkitEventHandler::new(
+                        request.plugin_name.clone(),
+                        command_tx.clone(),
+                    )),
+                    pumpkin_priority,
+                    request.blocking,
+                );
+        }
+        // Generic fallback Bukkit event categories
+        "org.bukkit.event.player.PlayerEvent"
         | "org.bukkit.event.entity.EntityEvent"
-        // Block Events
-        | "org.bukkit.event.block.BlockSpreadEvent"
-        | "org.bukkit.event.block.BlockBurnEvent"
-        | "org.bukkit.event.block.BlockPhysicsEvent"
-        | "org.bukkit.event.block.BlockRedstoneEvent"
-        | "org.bukkit.event.block.BlockPistonExtendEvent"
-        | "org.bukkit.event.block.BlockPistonRetractEvent"
-        | "org.bukkit.event.block.BlockExplodeEvent"
-        | "org.bukkit.event.block.BlockFromToEvent"
-        | "org.bukkit.event.block.BlockDispenseEvent"
-        | "org.bukkit.event.block.LeavesDecayEvent"
-        | "org.bukkit.event.block.BlockCanBuildEvent"
         | "org.bukkit.event.block.BlockEvent"
-        // Inventory Events
-        | "org.bukkit.event.inventory.InventoryClickEvent"
-        | "org.bukkit.event.inventory.InventoryCloseEvent"
-        | "org.bukkit.event.inventory.InventoryOpenEvent"
-        | "org.bukkit.event.inventory.InventoryDragEvent"
-        | "org.bukkit.event.inventory.InventoryCreativeEvent"
-        | "org.bukkit.event.inventory.CraftItemEvent"
-        | "org.bukkit.event.inventory.PrepareItemCraftEvent"
-        | "org.bukkit.event.inventory.PrepareAnvilEvent"
-        | "org.bukkit.event.inventory.PrepareSmithingEvent"
-        | "org.bukkit.event.inventory.FurnaceSmeltEvent"
-        | "org.bukkit.event.inventory.FurnaceBurnEvent"
         | "org.bukkit.event.inventory.InventoryEvent"
-        // Server / World / Weather Events
-        | "org.bukkit.event.server.PluginEnableEvent"
-        | "org.bukkit.event.server.PluginDisableEvent"
-        | "org.bukkit.event.server.PluginEvent"
-        | "org.bukkit.event.server.ServerListPingEvent"
-        | "org.bukkit.event.server.ServiceRegisterEvent"
-        | "org.bukkit.event.server.ServiceUnregisterEvent"
-        | "org.bukkit.event.server.MapInitializeEvent"
         | "org.bukkit.event.server.ServerEvent"
-        | "org.bukkit.event.world.WorldInitEvent"
-        | "org.bukkit.event.world.WorldLoadEvent"
-        | "org.bukkit.event.world.WorldUnloadEvent"
-        | "org.bukkit.event.world.WorldSaveEvent"
-        | "org.bukkit.event.world.ChunkLoadEvent"
-        | "org.bukkit.event.world.ChunkUnloadEvent"
         | "org.bukkit.event.world.WorldEvent"
-        | "org.bukkit.event.weather.WeatherChangeEvent"
-        | "org.bukkit.event.weather.ThunderChangeEvent"
-        | "org.bukkit.event.weather.WeatherEvent" => {
+        | "org.bukkit.event.weather.WeatherEvent"
+        | "org.bukkit.event.vehicle.VehicleEvent"
+        | "org.bukkit.event.hanging.HangingEvent"
+        | "org.bukkit.event.raid.RaidEvent" => {
             tracing::info!(
-                "Registered Bukkit event listener '{}' from plugin '{}'",
+                "Registered Bukkit generic event listener '{}' from plugin '{}'",
                 request.event_type,
                 request.plugin_name
             );
         }
         _ => {
             tracing::warn!(
-                "Unsupported Bukkit event type '{}' from plugin '{}'",
+                "Unknown or unhandled Bukkit event type '{}' from plugin '{}'",
                 request.event_type,
                 request.plugin_name
             );
@@ -438,7 +3765,3 @@ pub fn ffi_native_bridge_register_event_impl(request: RegisterEventRequest) -> O
 
     Some(())
 }
-
-pub fn ffi_native_bridge_call_event_impl(_request: CallEventRequest) -> Option<CallEventResponse> {
-    Some(CallEventResponse { handled: false })
-}