feat: add missing events

crates/pumpkin-plugin-api/src/events/block/bell_resonate.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BellResonateEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a bell resonates.
+pub struct BellResonateEvent;
+impl FromIntoEvent for BellResonateEvent {
+    const EVENT_TYPE: EventType = EventType::BellResonateEvent;
+    type Data = BellResonateEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BellResonateEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BellResonateEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/bell_ring.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BellRingEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a bell is rung.
+pub struct BellRingEvent;
+impl FromIntoEvent for BellRingEvent {
+    const EVENT_TYPE: EventType = EventType::BellRingEvent;
+    type Data = BellRingEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BellRingEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BellRingEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_brush.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockBrushEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a player brushes a block.
+pub struct BlockBrushEvent;
+impl FromIntoEvent for BlockBrushEvent {
+    const EVENT_TYPE: EventType = EventType::BlockBrushEvent;
+    type Data = BlockBrushEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockBrushEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockBrushEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_cook.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockCookEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block cooks an item.
+pub struct BlockCookEvent;
+impl FromIntoEvent for BlockCookEvent {
+    const EVENT_TYPE: EventType = EventType::BlockCookEvent;
+    type Data = BlockCookEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockCookEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockCookEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_damage_abort.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockDamageAbortEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a player stops damaging a block.
+pub struct BlockDamageAbortEvent;
+impl FromIntoEvent for BlockDamageAbortEvent {
+    const EVENT_TYPE: EventType = EventType::BlockDamageAbortEvent;
+    type Data = BlockDamageAbortEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockDamageAbortEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockDamageAbortEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_dispense_armor.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockDispenseArmorEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a dispenser equips armor on an entity.
+pub struct BlockDispenseArmorEvent;
+impl FromIntoEvent for BlockDispenseArmorEvent {
+    const EVENT_TYPE: EventType = EventType::BlockDispenseArmorEvent;
+    type Data = BlockDispenseArmorEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockDispenseArmorEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockDispenseArmorEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_dispense_loot.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockDispenseLootEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block dispenses loot.
+pub struct BlockDispenseLootEvent;
+impl FromIntoEvent for BlockDispenseLootEvent {
+    const EVENT_TYPE: EventType = EventType::BlockDispenseLootEvent;
+    type Data = BlockDispenseLootEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockDispenseLootEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockDispenseLootEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_drop_item.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockDropItemEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block drops items into the world.
+pub struct BlockDropItemEvent;
+impl FromIntoEvent for BlockDropItemEvent {
+    const EVENT_TYPE: EventType = EventType::BlockDropItemEvent;
+    type Data = BlockDropItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockDropItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockDropItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_exp.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockExpEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block gives experience.
+pub struct BlockExpEvent;
+impl FromIntoEvent for BlockExpEvent {
+    const EVENT_TYPE: EventType = EventType::BlockExpEvent;
+    type Data = BlockExpEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockExpEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockExpEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_fertilize.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockFertilizeEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block is fertilized.
+pub struct BlockFertilizeEvent;
+impl FromIntoEvent for BlockFertilizeEvent {
+    const EVENT_TYPE: EventType = EventType::BlockFertilizeEvent;
+    type Data = BlockFertilizeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockFertilizeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockFertilizeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_multi_place.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockMultiPlaceEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when multiple blocks are placed at once.
+pub struct BlockMultiPlaceEvent;
+impl FromIntoEvent for BlockMultiPlaceEvent {
+    const EVENT_TYPE: EventType = EventType::BlockMultiPlaceEvent;
+    type Data = BlockMultiPlaceEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockMultiPlaceEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockMultiPlaceEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_receive_game.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockReceiveGameEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block receives a game event.
+pub struct BlockReceiveGameEvent;
+impl FromIntoEvent for BlockReceiveGameEvent {
+    const EVENT_TYPE: EventType = EventType::BlockReceiveGameEvent;
+    type Data = BlockReceiveGameEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockReceiveGameEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockReceiveGameEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_shear_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockShearEntityEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a dispenser shears an entity.
+pub struct BlockShearEntityEvent;
+impl FromIntoEvent for BlockShearEntityEvent {
+    const EVENT_TYPE: EventType = EventType::BlockShearEntityEvent;
+    type Data = BlockShearEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockShearEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockShearEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/block_spread.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BlockSpreadEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block spreads based on world conditions.
+pub struct BlockSpreadEvent;
+impl FromIntoEvent for BlockSpreadEvent {
+    const EVENT_TYPE: EventType = EventType::BlockSpreadEvent;
+    type Data = BlockSpreadEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BlockSpreadEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BlockSpreadEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/brewing_start.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BrewingStartEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a brewing stand starts brewing.
+pub struct BrewingStartEvent;
+impl FromIntoEvent for BrewingStartEvent {
+    const EVENT_TYPE: EventType = EventType::BrewingStartEvent;
+    type Data = BrewingStartEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BrewingStartEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BrewingStartEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/campfire_start.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{CampfireStartEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a campfire starts cooking an item.
+pub struct CampfireStartEvent;
+impl FromIntoEvent for CampfireStartEvent {
+    const EVENT_TYPE: EventType = EventType::CampfireStartEvent;
+    type Data = CampfireStartEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::CampfireStartEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::CampfireStartEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/cauldron_level_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{CauldronLevelChangeEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a cauldron fluid level changes.
+pub struct CauldronLevelChangeEvent;
+impl FromIntoEvent for CauldronLevelChangeEvent {
+    const EVENT_TYPE: EventType = EventType::CauldronLevelChangeEvent;
+    type Data = CauldronLevelChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::CauldronLevelChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::CauldronLevelChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/crafter_craft.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{CrafterCraftEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a crafter crafts an item.
+pub struct CrafterCraftEvent;
+impl FromIntoEvent for CrafterCraftEvent {
+    const EVENT_TYPE: EventType = EventType::CrafterCraftEvent;
+    type Data = CrafterCraftEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::CrafterCraftEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::CrafterCraftEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/entity_block_form.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityBlockFormEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a block forms due to an entity action.
+pub struct EntityBlockFormEvent;
+impl FromIntoEvent for EntityBlockFormEvent {
+    const EVENT_TYPE: EventType = EventType::EntityBlockFormEvent;
+    type Data = EntityBlockFormEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityBlockFormEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityBlockFormEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/fluid_level_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FluidLevelChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a fluid level changes.
+pub struct FluidLevelChangeEvent;
+impl FromIntoEvent for FluidLevelChangeEvent {
+    const EVENT_TYPE: EventType = EventType::FluidLevelChangeEvent;
+    type Data = FluidLevelChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FluidLevelChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FluidLevelChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/inventory_block_start.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryBlockStartEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an inventory block starts an operation.
+pub struct InventoryBlockStartEvent;
+impl FromIntoEvent for InventoryBlockStartEvent {
+    const EVENT_TYPE: EventType = EventType::InventoryBlockStartEvent;
+    type Data = InventoryBlockStartEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::InventoryBlockStartEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::InventoryBlockStartEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/leaves_decay.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, LeavesDecayEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when leaves decay naturally.
+pub struct LeavesDecayEvent;
+impl FromIntoEvent for LeavesDecayEvent {
+    const EVENT_TYPE: EventType = EventType::LeavesDecayEvent;
+    type Data = LeavesDecayEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::LeavesDecayEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::LeavesDecayEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/mod.rs

@@ -1,58 +1,133 @@
+/// Bell resonate event.
+pub mod bell_resonate;
+/// Bell ring event.
+pub mod bell_ring;
 /// Block break event.
 pub mod block_break;
+/// Block brush event.
+pub mod block_brush;
 /// Block burn event.
 pub mod block_burn;
 /// Block can build check event.
 pub mod block_can_build;
+/// Block cook event.
+pub mod block_cook;
 /// Block damage event.
 pub mod block_damage;
+/// Block damage abort event.
+pub mod block_damage_abort;
 /// Block dispense event.
 pub mod block_dispense;
+/// Block dispense armor event.
+pub mod block_dispense_armor;
+/// Block dispense loot event.
+pub mod block_dispense_loot;
+/// Block drop item event.
+pub mod block_drop_item;
+/// Block exp event.
+pub mod block_exp;
 /// Block explode event.
 pub mod block_explode;
 /// Block fade event.
 pub mod block_fade;
+/// Block fertilize event.
+pub mod block_fertilize;
 /// Block form event.
 pub mod block_form;
 /// Block fluid flow event.
 pub mod block_from_to;
-/// Block growth event.
+/// Block grow event.
 pub mod block_grow;
 /// Block ignite event.
 pub mod block_ignite;
+/// Block multi-place event.
+pub mod block_multi_place;
 /// Block physics event.
 pub mod block_physics;
 /// Block piston event.
 pub mod block_piston;
 /// Block place event.
 pub mod block_place;
+/// Block receive game event.
+pub mod block_receive_game;
 /// Block redstone signal event.
 pub mod block_redstone;
+/// Block shear entity event.
+pub mod block_shear_entity;
+/// Block spread event.
+pub mod block_spread;
+/// Brewing start event.
+pub mod brewing_start;
+/// Campfire start event.
+pub mod campfire_start;
+/// Cauldron level change event.
+pub mod cauldron_level_change;
+/// Crafter craft event.
+pub mod crafter_craft;
+/// Entity block form event.
+pub mod entity_block_form;
+/// Fluid level change event.
+pub mod fluid_level_change;
+/// Inventory block start event.
+pub mod inventory_block_start;
+/// Leaves decay event.
+pub mod leaves_decay;
+/// Moisture change event.
+pub mod moisture_change;
 /// Note block play event.
 pub mod note_play;
+/// Sculk bloom event.
+pub mod sculk_bloom;
 /// Sign text change event.
 pub mod sign_change;
 /// Sponge absorb water event.
 pub mod sponge_absorb;
 /// TNT prime event.
 pub mod tnt_prime;
+/// Vault display item event.
+pub mod vault_display_item;
 
+pub use bell_resonate::*;
+pub use bell_ring::*;
 pub use block_break::*;
+pub use block_brush::*;
 pub use block_burn::*;
 pub use block_can_build::*;
+pub use block_cook::*;
 pub use block_damage::*;
+pub use block_damage_abort::*;
 pub use block_dispense::*;
+pub use block_dispense_armor::*;
+pub use block_dispense_loot::*;
+pub use block_drop_item::*;
+pub use block_exp::*;
 pub use block_explode::*;
 pub use block_fade::*;
+pub use block_fertilize::*;
 pub use block_form::*;
 pub use block_from_to::*;
 pub use block_grow::*;
 pub use block_ignite::*;
+pub use block_multi_place::*;
 pub use block_physics::*;
 pub use block_piston::*;
 pub use block_place::*;
+pub use block_receive_game::*;
 pub use block_redstone::*;
+pub use block_shear_entity::*;
+pub use block_spread::*;
+pub use brewing_start::*;
+pub use campfire_start::*;
+pub use cauldron_level_change::*;
+pub use crafter_craft::*;
+pub use entity_block_form::*;
+pub use fluid_level_change::*;
+pub use inventory_block_start::*;
+pub use leaves_decay::*;
+pub use moisture_change::*;
 pub use note_play::*;
+pub use sculk_bloom::*;
 pub use sign_change::*;
 pub use sponge_absorb::*;
 pub use tnt_prime::*;
+pub use vault_display_item::*;

crates/pumpkin-plugin-api/src/events/block/moisture_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, MoistureChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when farmland moisture changes.
+pub struct MoistureChangeEvent;
+impl FromIntoEvent for MoistureChangeEvent {
+    const EVENT_TYPE: EventType = EventType::MoistureChangeEvent;
+    type Data = MoistureChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::MoistureChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::MoistureChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/sculk_bloom.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, SculkBloomEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a sculk catalyst blooms.
+pub struct SculkBloomEvent;
+impl FromIntoEvent for SculkBloomEvent {
+    const EVENT_TYPE: EventType = EventType::SculkBloomEvent;
+    type Data = SculkBloomEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::SculkBloomEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::SculkBloomEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/block/vault_display_item.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, VaultDisplayItemEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a vault displays an item.
+pub struct VaultDisplayItemEvent;
+impl FromIntoEvent for VaultDisplayItemEvent {
+    const EVENT_TYPE: EventType = EventType::VaultDisplayItemEvent;
+    type Data = VaultDisplayItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::VaultDisplayItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::VaultDisplayItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/enchantment/enchant_item.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EnchantItemEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an item is enchanted at an enchanting table.
+pub struct EnchantItemEvent;
+impl FromIntoEvent for EnchantItemEvent {
+    const EVENT_TYPE: EventType = EventType::EnchantItemEvent;
+    type Data = EnchantItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EnchantItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EnchantItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/enchantment/mod.rs

@@ -0,0 +1,7 @@
+/// Enchant item event.
+pub mod enchant_item;
+/// Prepare item enchant event.
+pub mod prepare_item_enchant;
+
+pub use enchant_item::*;
+pub use prepare_item_enchant::*;

crates/pumpkin-plugin-api/src/events/enchantment/prepare_item_enchant.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, PrepareItemEnchantEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an item is placed in an enchanting table to prepare options.
+pub struct PrepareItemEnchantEvent;
+impl FromIntoEvent for PrepareItemEnchantEvent {
+    const EVENT_TYPE: EventType = EventType::PrepareItemEnchantEvent;
+    type Data = PrepareItemEnchantEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::PrepareItemEnchantEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::PrepareItemEnchantEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/area_effect_cloud_apply.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{AreaEffectCloudApplyEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an area effect cloud applies its effect to entities.
+pub struct AreaEffectCloudApplyEvent;
+impl FromIntoEvent for AreaEffectCloudApplyEvent {
+    const EVENT_TYPE: EventType = EventType::AreaEffectCloudApplyEvent;
+    type Data = AreaEffectCloudApplyEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::AreaEffectCloudApplyEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::AreaEffectCloudApplyEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/arrow_body_count_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{ArrowBodyCountChangeEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when the number of arrows stuck in an entity changes.
+pub struct ArrowBodyCountChangeEvent;
+impl FromIntoEvent for ArrowBodyCountChangeEvent {
+    const EVENT_TYPE: EventType = EventType::ArrowBodyCountChangeEvent;
+    type Data = ArrowBodyCountChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ArrowBodyCountChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ArrowBodyCountChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/bat_toggle_sleep.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{BatToggleSleepEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a bat toggles its sleep state.
+pub struct BatToggleSleepEvent;
+impl FromIntoEvent for BatToggleSleepEvent {
+    const EVENT_TYPE: EventType = EventType::BatToggleSleepEvent;
+    type Data = BatToggleSleepEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BatToggleSleepEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BatToggleSleepEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/creature_spawn.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{CreatureSpawnEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a creature spawns.
+pub struct CreatureSpawnEvent;
+impl FromIntoEvent for CreatureSpawnEvent {
+    const EVENT_TYPE: EventType = EventType::CreatureSpawnEvent;
+    type Data = CreatureSpawnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::CreatureSpawnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::CreatureSpawnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/creeper_power.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{CreeperPowerEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a creeper is powered.
+pub struct CreeperPowerEvent;
+impl FromIntoEvent for CreeperPowerEvent {
+    const EVENT_TYPE: EventType = EventType::CreeperPowerEvent;
+    type Data = CreeperPowerEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::CreeperPowerEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::CreeperPowerEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/ender_dragon_change_phase.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EnderDragonChangePhaseEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an Ender Dragon changes its phase.
+pub struct EnderDragonChangePhaseEvent;
+impl FromIntoEvent for EnderDragonChangePhaseEvent {
+    const EVENT_TYPE: EventType = EventType::EnderDragonChangePhaseEvent;
+    type Data = EnderDragonChangePhaseEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EnderDragonChangePhaseEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EnderDragonChangePhaseEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_break_door.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityBreakDoorEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity breaks a door.
+pub struct EntityBreakDoorEvent;
+impl FromIntoEvent for EntityBreakDoorEvent {
+    const EVENT_TYPE: EventType = EventType::EntityBreakDoorEvent;
+    type Data = EntityBreakDoorEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityBreakDoorEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityBreakDoorEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_change_block.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityChangeBlockEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity changes a block in the world.
+pub struct EntityChangeBlockEvent;
+impl FromIntoEvent for EntityChangeBlockEvent {
+    const EVENT_TYPE: EventType = EventType::EntityChangeBlockEvent;
+    type Data = EntityChangeBlockEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityChangeBlockEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityChangeBlockEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_block.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityCombustByBlockEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity is set on fire by a block.
+pub struct EntityCombustByBlockEvent;
+impl FromIntoEvent for EntityCombustByBlockEvent {
+    const EVENT_TYPE: EventType = EventType::EntityCombustByBlockEvent;
+    type Data = EntityCombustByBlockEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityCombustByBlockEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityCombustByBlockEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_combust_by_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityCombustByEntityEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity is set on fire by another entity.
+pub struct EntityCombustByEntityEvent;
+impl FromIntoEvent for EntityCombustByEntityEvent {
+    const EVENT_TYPE: EventType = EventType::EntityCombustByEntityEvent;
+    type Data = EntityCombustByEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityCombustByEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityCombustByEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_block.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityDamageByBlockEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity takes damage from a block.
+pub struct EntityDamageByBlockEvent;
+impl FromIntoEvent for EntityDamageByBlockEvent {
+    const EVENT_TYPE: EventType = EventType::EntityDamageByBlockEvent;
+    type Data = EntityDamageByBlockEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityDamageByBlockEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityDamageByBlockEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_damage_by_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityDamageByEntityEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity takes damage from another entity.
+pub struct EntityDamageByEntityEvent;
+impl FromIntoEvent for EntityDamageByEntityEvent {
+    const EVENT_TYPE: EventType = EventType::EntityDamageByEntityEvent;
+    type Data = EntityDamageByEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityDamageByEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityDamageByEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_drop_item.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityDropItemEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity drops an item.
+pub struct EntityDropItemEvent;
+impl FromIntoEvent for EntityDropItemEvent {
+    const EVENT_TYPE: EventType = EventType::EntityDropItemEvent;
+    type Data = EntityDropItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityDropItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityDropItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_enter_block.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityEnterBlockEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity enters a block.
+pub struct EntityEnterBlockEvent;
+impl FromIntoEvent for EntityEnterBlockEvent {
+    const EVENT_TYPE: EventType = EventType::EntityEnterBlockEvent;
+    type Data = EntityEnterBlockEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityEnterBlockEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityEnterBlockEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_exhaustion.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityExhaustionEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity experiences hunger exhaustion.
+pub struct EntityExhaustionEvent;
+impl FromIntoEvent for EntityExhaustionEvent {
+    const EVENT_TYPE: EventType = EventType::EntityExhaustionEvent;
+    type Data = EntityExhaustionEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityExhaustionEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityExhaustionEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_interact.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityInteractEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity interacts with a block.
+pub struct EntityInteractEvent;
+impl FromIntoEvent for EntityInteractEvent {
+    const EVENT_TYPE: EventType = EventType::EntityInteractEvent;
+    type Data = EntityInteractEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityInteractEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityInteractEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_knockback.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityKnockbackEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity receives knockback.
+pub struct EntityKnockbackEvent;
+impl FromIntoEvent for EntityKnockbackEvent {
+    const EVENT_TYPE: EventType = EventType::EntityKnockbackEvent;
+    type Data = EntityKnockbackEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityKnockbackEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityKnockbackEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_knockback_by_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityKnockbackByEntityEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity is knocked back by another entity.
+pub struct EntityKnockbackByEntityEvent;
+impl FromIntoEvent for EntityKnockbackByEntityEvent {
+    const EVENT_TYPE: EventType = EventType::EntityKnockbackByEntityEvent;
+    type Data = EntityKnockbackByEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityKnockbackByEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityKnockbackByEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_place.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityPlaceEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity places a block.
+pub struct EntityPlaceEvent;
+impl FromIntoEvent for EntityPlaceEvent {
+    const EVENT_TYPE: EventType = EventType::EntityPlaceEvent;
+    type Data = EntityPlaceEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityPlaceEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityPlaceEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_portal_enter.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityPortalEnterEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity enters a portal.
+pub struct EntityPortalEnterEvent;
+impl FromIntoEvent for EntityPortalEnterEvent {
+    const EVENT_TYPE: EventType = EventType::EntityPortalEnterEvent;
+    type Data = EntityPortalEnterEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityPortalEnterEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityPortalEnterEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_portal_exit.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityPortalExitEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity exits a portal.
+pub struct EntityPortalExitEvent;
+impl FromIntoEvent for EntityPortalExitEvent {
+    const EVENT_TYPE: EventType = EventType::EntityPortalExitEvent;
+    type Data = EntityPortalExitEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityPortalExitEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityPortalExitEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_pose_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityPoseChangeEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity's pose changes.
+pub struct EntityPoseChangeEvent;
+impl FromIntoEvent for EntityPoseChangeEvent {
+    const EVENT_TYPE: EventType = EventType::EntityPoseChangeEvent;
+    type Data = EntityPoseChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityPoseChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityPoseChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_potion_effect.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityPotionEffectEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a potion status effect is applied to an entity.
+pub struct EntityPotionEffectEvent;
+impl FromIntoEvent for EntityPotionEffectEvent {
+    const EVENT_TYPE: EventType = EventType::EntityPotionEffectEvent;
+    type Data = EntityPotionEffectEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityPotionEffectEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityPotionEffectEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_remove.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityRemoveEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity is removed from the world.
+pub struct EntityRemoveEvent;
+impl FromIntoEvent for EntityRemoveEvent {
+    const EVENT_TYPE: EventType = EventType::EntityRemoveEvent;
+    type Data = EntityRemoveEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityRemoveEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityRemoveEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_spell_cast.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntitySpellCastEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a spellcasting entity casts a spell.
+pub struct EntitySpellCastEvent;
+impl FromIntoEvent for EntitySpellCastEvent {
+    const EVENT_TYPE: EventType = EventType::EntitySpellCastEvent;
+    type Data = EntitySpellCastEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntitySpellCastEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntitySpellCastEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_target_block.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityTargetBlockEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity targets a block.
+pub struct EntityTargetBlockEvent;
+impl FromIntoEvent for EntityTargetBlockEvent {
+    const EVENT_TYPE: EventType = EventType::EntityTargetBlockEvent;
+    type Data = EntityTargetBlockEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityTargetBlockEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityTargetBlockEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_target_living_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityTargetLivingEntityEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity targets a living entity.
+pub struct EntityTargetLivingEntityEvent;
+impl FromIntoEvent for EntityTargetLivingEntityEvent {
+    const EVENT_TYPE: EventType = EventType::EntityTargetLivingEntityEvent;
+    type Data = EntityTargetLivingEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityTargetLivingEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityTargetLivingEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_toggle_swim.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityToggleSwimEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity starts or stops swimming.
+pub struct EntityToggleSwimEvent;
+impl FromIntoEvent for EntityToggleSwimEvent {
+    const EVENT_TYPE: EventType = EventType::EntityToggleSwimEvent;
+    type Data = EntityToggleSwimEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityToggleSwimEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityToggleSwimEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/entity_unleash.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{EntityUnleashEventData, Event, EventType};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an entity is unleashed.
+pub struct EntityUnleashEvent;
+impl FromIntoEvent for EntityUnleashEvent {
+    const EVENT_TYPE: EventType = EventType::EntityUnleashEvent;
+    type Data = EntityUnleashEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::EntityUnleashEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::EntityUnleashEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/exp_bottle.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ExpBottleEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when an experience bottle breaks.
+pub struct ExpBottleEvent;
+impl FromIntoEvent for ExpBottleEvent {
+    const EVENT_TYPE: EventType = EventType::ExpBottleEvent;
+    type Data = ExpBottleEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ExpBottleEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ExpBottleEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/explosion_prime.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ExplosionPrimeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity is primed to explode.
+pub struct ExplosionPrimeEvent;
+impl FromIntoEvent for ExplosionPrimeEvent {
+    const EVENT_TYPE: EventType = EventType::ExplosionPrimeEvent;
+    type Data = ExplosionPrimeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ExplosionPrimeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ExplosionPrimeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/firework_explode.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FireworkExplodeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a firework rocket explodes.
+pub struct FireworkExplodeEvent;
+impl FromIntoEvent for FireworkExplodeEvent {
+    const EVENT_TYPE: EventType = EventType::FireworkExplodeEvent;
+    type Data = FireworkExplodeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FireworkExplodeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FireworkExplodeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/food_level_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FoodLevelChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an entity's food level changes.
+pub struct FoodLevelChangeEvent;
+impl FromIntoEvent for FoodLevelChangeEvent {
+    const EVENT_TYPE: EventType = EventType::FoodLevelChangeEvent;
+    type Data = FoodLevelChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FoodLevelChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FoodLevelChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/horse_jump.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, HorseJumpEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a horse jumps.
+pub struct HorseJumpEvent;
+impl FromIntoEvent for HorseJumpEvent {
+    const EVENT_TYPE: EventType = EventType::HorseJumpEvent;
+    type Data = HorseJumpEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::HorseJumpEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::HorseJumpEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/item_despawn.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemDespawnEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an item entity despawns after aging.
+pub struct ItemDespawnEvent;
+impl FromIntoEvent for ItemDespawnEvent {
+    const EVENT_TYPE: EventType = EventType::ItemDespawnEvent;
+    type Data = ItemDespawnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ItemDespawnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ItemDespawnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/item_merge.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemMergeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when two item entities merge.
+pub struct ItemMergeEvent;
+impl FromIntoEvent for ItemMergeEvent {
+    const EVENT_TYPE: EventType = EventType::ItemMergeEvent;
+    type Data = ItemMergeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ItemMergeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ItemMergeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/item_spawn.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ItemSpawnEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when an item entity spawns in the world.
+pub struct ItemSpawnEvent;
+impl FromIntoEvent for ItemSpawnEvent {
+    const EVENT_TYPE: EventType = EventType::ItemSpawnEvent;
+    type Data = ItemSpawnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ItemSpawnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ItemSpawnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/lingering_potion_splash.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, LingeringPotionSplashEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a lingering potion splashes.
+pub struct LingeringPotionSplashEvent;
+impl FromIntoEvent for LingeringPotionSplashEvent {
+    const EVENT_TYPE: EventType = EventType::LingeringPotionSplashEvent;
+    type Data = LingeringPotionSplashEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::LingeringPotionSplashEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::LingeringPotionSplashEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/mod.rs

@@ -1,64 +1,229 @@
+/// Area effect cloud apply event.
+pub mod area_effect_cloud_apply;
+/// Arrow body count change event.
+pub mod arrow_body_count_change;
+/// Bat toggle sleep event.
+pub mod bat_toggle_sleep;
+/// Creature spawn event.
+pub mod creature_spawn;
+/// Creeper power event.
+pub mod creeper_power;
+/// Ender dragon change phase event.
+pub mod ender_dragon_change_phase;
 /// Entity air change event.
 pub mod entity_air_change;
+/// Entity break door event.
+pub mod entity_break_door;
 /// Entity breeding event.
 pub mod entity_breed;
+/// Entity change block event.
+pub mod entity_change_block;
 /// Entity combust (catch fire) event.
 pub mod entity_combust;
+/// Entity combust by block event.
+pub mod entity_combust_by_block;
+/// Entity combust by entity event.
+pub mod entity_combust_by_entity;
 /// Entity damage event.
 pub mod entity_damage;
+/// Entity damage by block event.
+pub mod entity_damage_by_block;
+/// Entity damage by entity event.
+pub mod entity_damage_by_entity;
 /// Entity death and player death events.
 pub mod entity_death;
 /// Entity dismount event.
 pub mod entity_dismount;
+/// Entity drop item event.
+pub mod entity_drop_item;
 /// Entity dye event.
 pub mod entity_dye;
+/// Entity enter block event.
+pub mod entity_enter_block;
 /// Entity enter love mode event.
 pub mod entity_enter_love_mode;
+/// Entity exhaustion event.
+pub mod entity_exhaustion;
 /// Entity explode event.
 pub mod entity_explode;
+/// Entity interact event.
+pub mod entity_interact;
+/// Entity knockback event.
+pub mod entity_knockback;
+/// Entity knockback by entity event.
+pub mod entity_knockback_by_entity;
 /// Entity mount event.
 pub mod entity_mount;
 /// Entity pickup item event.
 pub mod entity_pickup_item;
+/// Entity place event.
+pub mod entity_place;
 /// Entity portal travel event.
 pub mod entity_portal;
+/// Entity portal enter event.
+pub mod entity_portal_enter;
+/// Entity portal exit event.
+pub mod entity_portal_exit;
+/// Entity pose change event.
+pub mod entity_pose_change;
+/// Entity potion effect event.
+pub mod entity_potion_effect;
 /// Entity health regeneration event.
 pub mod entity_regain_health;
+/// Entity remove event.
+pub mod entity_remove;
 /// Entity resurrect event.
 pub mod entity_resurrect;
 /// Entity shoot bow event.
 pub mod entity_shoot_bow;
 /// Entity spawn event.
 pub mod entity_spawn;
+/// Entity spell cast event.
+pub mod entity_spell_cast;
 /// Entity tame event.
 pub mod entity_tame;
 /// Entity target event.
 pub mod entity_target;
+/// Entity target block event.
+pub mod entity_target_block;
+/// Entity target living entity event.
+pub mod entity_target_living_entity;
 /// Entity teleport event.
 pub mod entity_teleport;
 /// Entity toggle glide event.
 pub mod entity_toggle_glide;
+/// Entity toggle swim event.
+pub mod entity_toggle_swim;
 /// Entity transform event.
 pub mod entity_transform;
+/// Entity unleash event.
+pub mod entity_unleash;
+/// Experience bottle event.
+pub mod exp_bottle;
+/// Explosion prime event.
+pub mod explosion_prime;
+/// Firework explode event.
+pub mod firework_explode;
+/// Food level change event.
+pub mod food_level_change;
+/// Horse jump event.
+pub mod horse_jump;
+/// Item despawn event.
+pub mod item_despawn;
+/// Item merge event.
+pub mod item_merge;
+/// Item spawn event.
+pub mod item_spawn;
+/// Lingering potion splash event.
+pub mod lingering_potion_splash;
+/// Pig zap event.
+pub mod pig_zap;
+/// Pig zombie anger event.
+pub mod pig_zombie_anger;
+/// Piglin barter event.
+pub mod piglin_barter;
+/// Potion splash event.
+pub mod potion_splash;
+/// Projectile hit event.
+pub mod projectile_hit;
+/// Projectile launch event.
+pub mod projectile_launch;
+/// Sheep dye wool event.
+pub mod sheep_dye_wool;
+/// Sheep regrow wool event.
+pub mod sheep_regrow_wool;
+/// Slime split event.
+pub mod slime_split;
+/// Spawner spawn event.
+pub mod spawner_spawn;
+/// Strider temperature change event.
+pub mod strider_temperature_change;
+/// Trial spawner spawn event.
+pub mod trial_spawner_spawn;
+/// Villager acquire trade event.
+pub mod villager_acquire_trade;
+/// Villager career change event.
+pub mod villager_career_change;
+/// Villager replenish trade event.
+pub mod villager_replenish_trade;
+/// Villager reputation change event.
+pub mod villager_reputation_change;
+/// Warden anger change event.
+pub mod warden_anger_change;
 
+pub use area_effect_cloud_apply::*;
+pub use arrow_body_count_change::*;
+pub use bat_toggle_sleep::*;
+pub use creature_spawn::*;
+pub use creeper_power::*;
+pub use ender_dragon_change_phase::*;
 pub use entity_air_change::*;
+pub use entity_break_door::*;
 pub use entity_breed::*;
+pub use entity_change_block::*;
 pub use entity_combust::*;
+pub use entity_combust_by_block::*;
+pub use entity_combust_by_entity::*;
 pub use entity_damage::*;
+pub use entity_damage_by_block::*;
+pub use entity_damage_by_entity::*;
 pub use entity_death::*;
 pub use entity_dismount::*;
+pub use entity_drop_item::*;
 pub use entity_dye::*;
+pub use entity_enter_block::*;
 pub use entity_enter_love_mode::*;
+pub use entity_exhaustion::*;
 pub use entity_explode::*;
+pub use entity_interact::*;
+pub use entity_knockback::*;
+pub use entity_knockback_by_entity::*;
 pub use entity_mount::*;
 pub use entity_pickup_item::*;
+pub use entity_place::*;
 pub use entity_portal::*;
+pub use entity_portal_enter::*;
+pub use entity_portal_exit::*;
+pub use entity_pose_change::*;
+pub use entity_potion_effect::*;
 pub use entity_regain_health::*;
+pub use entity_remove::*;
 pub use entity_resurrect::*;
 pub use entity_shoot_bow::*;
 pub use entity_spawn::*;
+pub use entity_spell_cast::*;
 pub use entity_tame::*;
 pub use entity_target::*;
+pub use entity_target_block::*;
+pub use entity_target_living_entity::*;
 pub use entity_teleport::*;
 pub use entity_toggle_glide::*;
+pub use entity_toggle_swim::*;
 pub use entity_transform::*;
+pub use entity_unleash::*;
+pub use exp_bottle::*;
+pub use explosion_prime::*;
+pub use firework_explode::*;
+pub use food_level_change::*;
+pub use horse_jump::*;
+pub use item_despawn::*;
+pub use item_merge::*;
+pub use item_spawn::*;
+pub use lingering_potion_splash::*;
+pub use pig_zap::*;
+pub use pig_zombie_anger::*;
+pub use piglin_barter::*;
+pub use potion_splash::*;
+pub use projectile_hit::*;
+pub use projectile_launch::*;
+pub use sheep_dye_wool::*;
+pub use sheep_regrow_wool::*;
+pub use slime_split::*;
+pub use spawner_spawn::*;
+pub use strider_temperature_change::*;
+pub use trial_spawner_spawn::*;
+pub use villager_acquire_trade::*;
+pub use villager_career_change::*;
+pub use villager_replenish_trade::*;
+pub use villager_reputation_change::*;
+pub use warden_anger_change::*;

crates/pumpkin-plugin-api/src/events/entity/pig_zap.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, PigZapEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a pig transforms into a zombie pigman due to lightning.
+pub struct PigZapEvent;
+impl FromIntoEvent for PigZapEvent {
+    const EVENT_TYPE: EventType = EventType::PigZapEvent;
+    type Data = PigZapEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::PigZapEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::PigZapEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/pig_zombie_anger.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, PigZombieAngerEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a zombie pigman becomes angry.
+pub struct PigZombieAngerEvent;
+impl FromIntoEvent for PigZombieAngerEvent {
+    const EVENT_TYPE: EventType = EventType::PigZombieAngerEvent;
+    type Data = PigZombieAngerEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::PigZombieAngerEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::PigZombieAngerEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/piglin_barter.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, PiglinBarterEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a piglin barters.
+pub struct PiglinBarterEvent;
+impl FromIntoEvent for PiglinBarterEvent {
+    const EVENT_TYPE: EventType = EventType::PiglinBarterEvent;
+    type Data = PiglinBarterEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::PiglinBarterEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::PiglinBarterEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/potion_splash.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, PotionSplashEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a potion splashes.
+pub struct PotionSplashEvent;
+impl FromIntoEvent for PotionSplashEvent {
+    const EVENT_TYPE: EventType = EventType::PotionSplashEvent;
+    type Data = PotionSplashEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::PotionSplashEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::PotionSplashEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/projectile_hit.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ProjectileHitEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a projectile hits an entity or block.
+pub struct ProjectileHitEvent;
+impl FromIntoEvent for ProjectileHitEvent {
+    const EVENT_TYPE: EventType = EventType::ProjectileHitEvent;
+    type Data = ProjectileHitEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ProjectileHitEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ProjectileHitEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/projectile_launch.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, ProjectileLaunchEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a projectile is launched.
+pub struct ProjectileLaunchEvent;
+impl FromIntoEvent for ProjectileLaunchEvent {
+    const EVENT_TYPE: EventType = EventType::ProjectileLaunchEvent;
+    type Data = ProjectileLaunchEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::ProjectileLaunchEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::ProjectileLaunchEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/sheep_dye_wool.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, SheepDyeWoolEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a sheep has its wool dyed.
+pub struct SheepDyeWoolEvent;
+impl FromIntoEvent for SheepDyeWoolEvent {
+    const EVENT_TYPE: EventType = EventType::SheepDyeWoolEvent;
+    type Data = SheepDyeWoolEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::SheepDyeWoolEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::SheepDyeWoolEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/sheep_regrow_wool.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, SheepRegrowWoolEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a sheep regrows its wool.
+pub struct SheepRegrowWoolEvent;
+impl FromIntoEvent for SheepRegrowWoolEvent {
+    const EVENT_TYPE: EventType = EventType::SheepRegrowWoolEvent;
+    type Data = SheepRegrowWoolEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::SheepRegrowWoolEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::SheepRegrowWoolEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/slime_split.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, SlimeSplitEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a slime splits into smaller slimes.
+pub struct SlimeSplitEvent;
+impl FromIntoEvent for SlimeSplitEvent {
+    const EVENT_TYPE: EventType = EventType::SlimeSplitEvent;
+    type Data = SlimeSplitEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::SlimeSplitEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::SlimeSplitEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/spawner_spawn.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, SpawnerSpawnEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a spawner spawns an entity.
+pub struct SpawnerSpawnEvent;
+impl FromIntoEvent for SpawnerSpawnEvent {
+    const EVENT_TYPE: EventType = EventType::SpawnerSpawnEvent;
+    type Data = SpawnerSpawnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::SpawnerSpawnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::SpawnerSpawnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/strider_temperature_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, StriderTemperatureChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a strider's shivering status changes.
+pub struct StriderTemperatureChangeEvent;
+impl FromIntoEvent for StriderTemperatureChangeEvent {
+    const EVENT_TYPE: EventType = EventType::StriderTemperatureChangeEvent;
+    type Data = StriderTemperatureChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::StriderTemperatureChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::StriderTemperatureChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/trial_spawner_spawn.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, TrialSpawnerSpawnEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a trial spawner spawns an entity.
+pub struct TrialSpawnerSpawnEvent;
+impl FromIntoEvent for TrialSpawnerSpawnEvent {
+    const EVENT_TYPE: EventType = EventType::TrialSpawnerSpawnEvent;
+    type Data = TrialSpawnerSpawnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::TrialSpawnerSpawnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::TrialSpawnerSpawnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/villager_acquire_trade.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerAcquireTradeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a villager acquires a new trade.
+pub struct VillagerAcquireTradeEvent;
+impl FromIntoEvent for VillagerAcquireTradeEvent {
+    const EVENT_TYPE: EventType = EventType::VillagerAcquireTradeEvent;
+    type Data = VillagerAcquireTradeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::VillagerAcquireTradeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::VillagerAcquireTradeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/villager_career_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerCareerChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a villager changes its profession.
+pub struct VillagerCareerChangeEvent;
+impl FromIntoEvent for VillagerCareerChangeEvent {
+    const EVENT_TYPE: EventType = EventType::VillagerCareerChangeEvent;
+    type Data = VillagerCareerChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::VillagerCareerChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::VillagerCareerChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/villager_replenish_trade.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerReplenishTradeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a villager replenishes its trades.
+pub struct VillagerReplenishTradeEvent;
+impl FromIntoEvent for VillagerReplenishTradeEvent {
+    const EVENT_TYPE: EventType = EventType::VillagerReplenishTradeEvent;
+    type Data = VillagerReplenishTradeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::VillagerReplenishTradeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::VillagerReplenishTradeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/villager_reputation_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, VillagerReputationChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a villager's reputation changes.
+pub struct VillagerReputationChangeEvent;
+impl FromIntoEvent for VillagerReputationChangeEvent {
+    const EVENT_TYPE: EventType = EventType::VillagerReputationChangeEvent;
+    type Data = VillagerReputationChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::VillagerReputationChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::VillagerReputationChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/entity/warden_anger_change.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, WardenAngerChangeEventData};
+
+use super::super::FromIntoEvent;
+
+/// Event triggered when a warden's anger towards an entity changes.
+pub struct WardenAngerChangeEvent;
+impl FromIntoEvent for WardenAngerChangeEvent {
+    const EVENT_TYPE: EventType = EventType::WardenAngerChangeEvent;
+    type Data = WardenAngerChangeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::WardenAngerChangeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::WardenAngerChangeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/hanging/hanging_break.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingBreakEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a hanging entity is broken.
+pub struct HangingBreakEvent;
+impl FromIntoEvent for HangingBreakEvent {
+    const EVENT_TYPE: EventType = EventType::HangingBreakEvent;
+    type Data = HangingBreakEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::HangingBreakEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::HangingBreakEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/hanging/hanging_break_by_entity.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingBreakByEntityEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a hanging entity is broken by another entity.
+pub struct HangingBreakByEntityEvent;
+impl FromIntoEvent for HangingBreakByEntityEvent {
+    const EVENT_TYPE: EventType = EventType::HangingBreakByEntityEvent;
+    type Data = HangingBreakByEntityEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::HangingBreakByEntityEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::HangingBreakByEntityEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/hanging/hanging_place.rs

@@ -0,0 +1,21 @@
+use crate::wit::pumpkin::plugin::event::{Event, EventType, HangingPlaceEventData};
+
+use super::super::FromIntoEvent;
+
+/// An event that occurs when a hanging entity is placed.
+pub struct HangingPlaceEvent;
+impl FromIntoEvent for HangingPlaceEvent {
+    const EVENT_TYPE: EventType = EventType::HangingPlaceEvent;
+    type Data = HangingPlaceEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::HangingPlaceEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::HangingPlaceEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/hanging/mod.rs

@@ -0,0 +1,10 @@
+/// Hanging break event.
+pub mod hanging_break;
+/// Hanging break by entity event.
+pub mod hanging_break_by_entity;
+/// Hanging place event.
+pub mod hanging_place;
+
+pub use hanging_break::*;
+pub use hanging_break_by_entity::*;
+pub use hanging_place::*;

crates/pumpkin-plugin-api/src/events/inventory/brew.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{BrewEventData, Event, EventType};
+
+/// Event triggered when potion(s) finish brewing in a brewing stand.
+pub struct BrewEvent;
+impl FromIntoEvent for BrewEvent {
+    const EVENT_TYPE: EventType = EventType::BrewEvent;
+    type Data = BrewEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BrewEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BrewEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/brewing_stand_fuel.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{BrewingStandFuelEventData, Event, EventType};
+
+/// Event triggered when brewing stand fuel is consumed or refilled.
+pub struct BrewingStandFuelEvent;
+impl FromIntoEvent for BrewingStandFuelEvent {
+    const EVENT_TYPE: EventType = EventType::BrewingStandFuelEvent;
+    type Data = BrewingStandFuelEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::BrewingStandFuelEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::BrewingStandFuelEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/furnace_burn.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceBurnEventData};
+
+/// Event triggered when fuel is burned in a furnace.
+pub struct FurnaceBurnEvent;
+impl FromIntoEvent for FurnaceBurnEvent {
+    const EVENT_TYPE: EventType = EventType::FurnaceBurnEvent;
+    type Data = FurnaceBurnEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FurnaceBurnEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FurnaceBurnEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/furnace_extract.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceExtractEventData};
+
+/// Event triggered when a player extracts items from a furnace output slot.
+pub struct FurnaceExtractEvent;
+impl FromIntoEvent for FurnaceExtractEvent {
+    const EVENT_TYPE: EventType = EventType::FurnaceExtractEvent;
+    type Data = FurnaceExtractEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FurnaceExtractEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FurnaceExtractEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/furnace_start_smelt.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, FurnaceStartSmeltEventData};
+
+/// Event triggered when a furnace starts smelting an item.
+pub struct FurnaceStartSmeltEvent;
+impl FromIntoEvent for FurnaceStartSmeltEvent {
+    const EVENT_TYPE: EventType = EventType::FurnaceStartSmeltEvent;
+    type Data = FurnaceStartSmeltEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::FurnaceStartSmeltEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::FurnaceStartSmeltEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/hopper_inventory_search.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, HopperInventorySearchEventData};
+
+/// Event triggered when a hopper searches for a container.
+pub struct HopperInventorySearchEvent;
+impl FromIntoEvent for HopperInventorySearchEvent {
+    const EVENT_TYPE: EventType = EventType::HopperInventorySearchEvent;
+    type Data = HopperInventorySearchEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::HopperInventorySearchEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::HopperInventorySearchEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/inventory_creative.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryCreativeEventData};
+
+/// Event triggered when a player in creative mode sets an inventory slot.
+pub struct InventoryCreativeEvent;
+impl FromIntoEvent for InventoryCreativeEvent {
+    const EVENT_TYPE: EventType = EventType::InventoryCreativeEvent;
+    type Data = InventoryCreativeEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::InventoryCreativeEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::InventoryCreativeEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/inventory_interact.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryInteractEventData};
+
+/// Event triggered when a player interacts with an inventory.
+pub struct InventoryInteractEvent;
+impl FromIntoEvent for InventoryInteractEvent {
+    const EVENT_TYPE: EventType = EventType::InventoryInteractEvent;
+    type Data = InventoryInteractEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::InventoryInteractEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::InventoryInteractEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/inventory_move_item.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryMoveItemEventData};
+
+/// Event triggered when an item is moved between inventories.
+pub struct InventoryMoveItemEvent;
+impl FromIntoEvent for InventoryMoveItemEvent {
+    const EVENT_TYPE: EventType = EventType::InventoryMoveItemEvent;
+    type Data = InventoryMoveItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::InventoryMoveItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::InventoryMoveItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/inventory_pickup_item.rs

@@ -0,0 +1,20 @@
+use super::super::FromIntoEvent;
+use crate::wit::pumpkin::plugin::event::{Event, EventType, InventoryPickupItemEventData};
+
+/// Event triggered when a container inventory picks up an item entity.
+pub struct InventoryPickupItemEvent;
+impl FromIntoEvent for InventoryPickupItemEvent {
+    const EVENT_TYPE: EventType = EventType::InventoryPickupItemEvent;
+    type Data = InventoryPickupItemEventData;
+
+    fn data_from_event(event: Event) -> Self::Data {
+        match event {
+            Event::InventoryPickupItemEvent(data) => data,
+            _ => panic!("unexpected event"),
+        }
+    }
+
+    fn data_into_event(data: Self::Data) -> Event {
+        Event::InventoryPickupItemEvent(data)
+    }
+}

crates/pumpkin-plugin-api/src/events/inventory/mod.rs

@@ -1,13 +1,64 @@
+/// Brew event.
+pub mod brew;
+/// Brewing stand fuel event.
+pub mod brewing_stand_fuel;
 /// Craft item event.
 pub mod craft_item;
+/// Furnace burn event.
+pub mod furnace_burn;
+/// Furnace extract event.
+pub mod furnace_extract;
 /// Furnace smelt event.
 pub mod furnace_smelt;
+/// Furnace start smelt event.
+pub mod furnace_start_smelt;
+/// Hopper inventory search event.
+pub mod hopper_inventory_search;
+/// Inventory creative event.
+pub mod inventory_creative;
 /// Inventory drag event.
 pub mod inventory_drag;
+/// Inventory interact event.
+pub mod inventory_interact;
+/// Inventory move item event.
+pub mod inventory_move_item;
 /// Inventory open event.
 pub mod inventory_open;
+/// Inventory pickup item event.
+pub mod inventory_pickup_item;
+/// Prepare anvil event.
+pub mod prepare_anvil;
+/// Prepare grindstone event.
+pub mod prepare_grindstone;
+/// Prepare inventory result event.
+pub mod prepare_inventory_result;
+/// Prepare item craft event.
+pub mod prepare_item_craft;
+/// Prepare smithing event.
+pub mod prepare_smithing;
+/// Smith item event.
+pub mod smith_item;
+/// Trade select event.
+pub mod trade_select;
 
+pub use brew::*;
+pub use brewing_stand_fuel::*;
 pub use craft_item::*;
+pub use furnace_burn::*;
+pub use furnace_extract::*;
 pub use furnace_smelt::*;
+pub use furnace_start_smelt::*;
+pub use hopper_inventory_search::*;
+pub use inventory_creative::*;
 pub use inventory_drag::*;
+pub use inventory_interact::*;
+pub use inventory_move_item::*;
 pub use inventory_open::*;
+pub use inventory_pickup_item::*;
+pub use prepare_anvil::*;
+pub use prepare_grindstone::*;
+pub use prepare_inventory_result::*;
+pub use prepare_item_craft::*;
+pub use prepare_smithing::*;
+pub use smith_item::*;
+pub use trade_select::*;