/++

+/
module wit.pumpkin.plugin.event.imports;


import wit.common;

public import wit.pumpkin.plugin.event.common;

static import wit.pumpkin.plugin.common.imports;
static import wit.pumpkin.plugin.damage_types.imports;
static import wit.pumpkin.plugin.screens.imports;
static import wit.pumpkin.plugin.text.imports;
static import wit.pumpkin.plugin.enchantments.imports;
static import wit.pumpkin.plugin.item_stack.imports;
static import wit.pumpkin.plugin.java_dialogs.imports;
static import wit.pumpkin.plugin.uuid.imports;
static import wit.pumpkin.plugin.bedrock_packets.imports;
static import wit.pumpkin.plugin.java_packets.imports;
static import wit.pumpkin.plugin.world.imports;
static import wit.pumpkin.plugin.player.imports;

package (wit) void __wit_bindgen_component_type_force_link() pure @nogc nothrow => imported!"wit.pumpkin.plugin.plugin".__wit_bindgen_component_type_force_link();

/++

+/
alias ItemStack = wit.pumpkin.plugin.item_stack.imports.ItemStack;

/++

+/
alias Player = wit.pumpkin.plugin.player.imports.Player;

/++

+/
alias TextComponent = wit.pumpkin.plugin.text.imports.TextComponent;

/++

+/
alias World = wit.pumpkin.plugin.world.imports.World;

/++

+/
alias Dialog = wit.pumpkin.plugin.java_dialogs.imports.Dialog;

/++

+/
struct PlayerJoinEventData {
  /++

  +/
  Player player;

  /++

  +/
  TextComponent joinMessage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    joinMessage.witDrop;
  }

  PlayerJoinEventData witClone() const @nogc nothrow {
    PlayerJoinEventData clone = void;
    clone.player = this.player.witClone;
    clone.joinMessage = this.joinMessage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLeaveEventData {
  /++

  +/
  Player player;

  /++

  +/
  TextComponent leaveMessage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    leaveMessage.witDrop;
  }

  PlayerLeaveEventData witClone() const @nogc nothrow {
    PlayerLeaveEventData clone = void;
    clone.player = this.player.witClone;
    clone.leaveMessage = this.leaveMessage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLoginEventData {
  /++

  +/
  Player player;

  /++

  +/
  TextComponent kickMessage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    kickMessage.witDrop;
  }

  PlayerLoginEventData witClone() const @nogc nothrow {
    PlayerLoginEventData clone = void;
    clone.player = this.player.witClone;
    clone.kickMessage = this.kickMessage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerChatEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString message;

  /++

  +/
  WitList!(Player) recipients;

  /++

  +/
  Option!(WitList!(ubyte)) signature;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    message.witFree;
    recipients.witFree;
    signature.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    recipients.witDrop;
  }

  PlayerChatEventData witClone() const @nogc nothrow {
    PlayerChatEventData clone = void;
    clone.player = this.player.witClone;
    clone.message = this.message.witClone;
    clone.recipients = this.recipients.witClone;
    clone.signature = this.signature.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerCommandSendEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString command;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    command.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerCommandSendEventData witClone() const @nogc nothrow {
    PlayerCommandSendEventData clone = void;
    clone.player = this.player.witClone;
    clone.command = this.command.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerPermissionCheckEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString permission;

  /++

  +/
  bool permissionResult;

  void witFree() @nogc nothrow {
    permission.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerPermissionCheckEventData witClone() const @nogc nothrow {
    PlayerPermissionCheckEventData clone = void;
    clone.player = this.player.witClone;
    clone.permission = this.permission.witClone;
    clone.permissionResult = this.permissionResult.witClone;
    return clone;
  }
}

/++

+/
struct PlayerMoveEventData {
  /++

  +/
  Player player;

  /++

  +/
  Position fromPosition;

  /++

  +/
  Position toPosition;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerMoveEventData witClone() const @nogc nothrow {
    PlayerMoveEventData clone = void;
    clone.player = this.player.witClone;
    clone.fromPosition = this.fromPosition.witClone;
    clone.toPosition = this.toPosition.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerTeleportEventData {
  /++

  +/
  Player player;

  /++

  +/
  Position fromPosition;

  /++

  +/
  Position toPosition;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerTeleportEventData witClone() const @nogc nothrow {
    PlayerTeleportEventData clone = void;
    clone.player = this.player.witClone;
    clone.fromPosition = this.fromPosition.witClone;
    clone.toPosition = this.toPosition.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerChangeWorldEventData {
  /++

  +/
  Player player;

  /++

  +/
  World previousWorld;

  /++

  +/
  World newWorld;

  /++

  +/
  Position position;

  /++

  +/
  float yaw;

  /++

  +/
  float pitch;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    previousWorld.witDrop;
    newWorld.witDrop;
  }

  PlayerChangeWorldEventData witClone() const @nogc nothrow {
    PlayerChangeWorldEventData clone = void;
    clone.player = this.player.witClone;
    clone.previousWorld = this.previousWorld.witClone;
    clone.newWorld = this.newWorld.witClone;
    clone.position = this.position.witClone;
    clone.yaw = this.yaw.witClone;
    clone.pitch = this.pitch.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRespawnEventData {
  /++

  +/
  Player player;

  /++

  +/
  World previousWorld;

  /++

  +/
  World respawnedWorld;

  /++

  +/
  Position position;

  /++

  +/
  float yaw;

  /++

  +/
  float pitch;

  /++

  +/
  bool alive;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    previousWorld.witDrop;
    respawnedWorld.witDrop;
  }

  PlayerRespawnEventData witClone() const @nogc nothrow {
    PlayerRespawnEventData clone = void;
    clone.player = this.player.witClone;
    clone.previousWorld = this.previousWorld.witClone;
    clone.respawnedWorld = this.respawnedWorld.witClone;
    clone.position = this.position.witClone;
    clone.yaw = this.yaw.witClone;
    clone.pitch = this.pitch.witClone;
    clone.alive = this.alive.witClone;
    return clone;
  }
}

/++

+/
struct PlayerExpChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  int amount;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerExpChangeEventData witClone() const @nogc nothrow {
    PlayerExpChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.amount = this.amount.witClone;
    return clone;
  }
}

/++

+/
struct PlayerItemHeldEventData {
  /++

  +/
  Player player;

  /++

  +/
  ubyte previousSlot;

  /++

  +/
  ubyte newSlot;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerItemHeldEventData witClone() const @nogc nothrow {
    PlayerItemHeldEventData clone = void;
    clone.player = this.player.witClone;
    clone.previousSlot = this.previousSlot.witClone;
    clone.newSlot = this.newSlot.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerChangedMainHandEventData {
  /++

  +/
  Player player;

  /++

  +/
  Hand mainHand;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerChangedMainHandEventData witClone() const @nogc nothrow {
    PlayerChangedMainHandEventData clone = void;
    clone.player = this.player.witClone;
    clone.mainHand = this.mainHand.witClone;
    return clone;
  }
}

/++

+/
struct PlayerGamemodeChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  GameMode previousGamemode;

  /++

  +/
  GameMode newGamemode;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerGamemodeChangeEventData witClone() const @nogc nothrow {
    PlayerGamemodeChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.previousGamemode = this.previousGamemode.witClone;
    clone.newGamemode = this.newGamemode.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerCustomPayloadEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString channel;

  /++

  +/
  WitList!(ubyte) data;

  void witFree() @nogc nothrow {
    channel.witFree;
    data.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerCustomPayloadEventData witClone() const @nogc nothrow {
    PlayerCustomPayloadEventData clone = void;
    clone.player = this.player.witClone;
    clone.channel = this.channel.witClone;
    clone.data = this.data.witClone;
    return clone;
  }
}

/++

+/
struct PlayerFishEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(Uuid) caughtUuid;

  /++

  +/
  WitString caughtType;

  /++

  +/
  Uuid hookUuid;

  /++

  +/
  PlayerFishState state;

  /++

  +/
  Hand hand;

  /++

  +/
  int expToDrop;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    caughtType.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerFishEventData witClone() const @nogc nothrow {
    PlayerFishEventData clone = void;
    clone.player = this.player.witClone;
    clone.caughtUuid = this.caughtUuid.witClone;
    clone.caughtType = this.caughtType.witClone;
    clone.hookUuid = this.hookUuid.witClone;
    clone.state = this.state.witClone;
    clone.hand = this.hand.witClone;
    clone.expToDrop = this.expToDrop.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerEggThrowEventData {
  /++

  +/
  Player player;

  /++

  +/
  Uuid eggUuid;

  /++

  +/
  bool hatching;

  /++

  +/
  ubyte numHatches;

  /++

  +/
  WitString hatchingType;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    hatchingType.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerEggThrowEventData witClone() const @nogc nothrow {
    PlayerEggThrowEventData clone = void;
    clone.player = this.player.witClone;
    clone.eggUuid = this.eggUuid.witClone;
    clone.hatching = this.hatching.witClone;
    clone.numHatches = this.numHatches.witClone;
    clone.hatchingType = this.hatchingType.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerInteractEventData {
  /++

  +/
  Player player;

  /++

  +/
  InteractAction action;

  /++

  +/
  Option!(BlockPos) clickedPos;

  /++

  +/
  WitString block;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    block.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerInteractEventData witClone() const @nogc nothrow {
    PlayerInteractEventData clone = void;
    clone.player = this.player.witClone;
    clone.action = this.action.witClone;
    clone.clickedPos = this.clickedPos.witClone;
    clone.block = this.block.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerToggleSneakEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool isSneaking;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerToggleSneakEventData witClone() const @nogc nothrow {
    PlayerToggleSneakEventData clone = void;
    clone.player = this.player.witClone;
    clone.isSneaking = this.isSneaking.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerToggleFlightEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool isFlying;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerToggleFlightEventData witClone() const @nogc nothrow {
    PlayerToggleFlightEventData clone = void;
    clone.player = this.player.witClone;
    clone.isFlying = this.isFlying.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerToggleSprintEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool isSprinting;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerToggleSprintEventData witClone() const @nogc nothrow {
    PlayerToggleSprintEventData clone = void;
    clone.player = this.player.witClone;
    clone.isSprinting = this.isSprinting.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerInteractUnknownEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  EntityInteractionAction action;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerInteractUnknownEntityEventData witClone() const @nogc nothrow {
    PlayerInteractUnknownEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.action = this.action.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct InventoryClickEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(Screen) windowType;

  /++

  +/
  ClickType clickType;

  /++

  +/
  short slot;

  /++

  +/
  short rawSlot;

  /++

  +/
  Option!(ItemStack) clickedItem;

  /++

  +/
  Option!(ItemStack) cursor;

  /++

  +/
  int hotbarButton;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    clickedItem.witDrop;
    cursor.witDrop;
  }

  InventoryClickEventData witClone() const @nogc nothrow {
    InventoryClickEventData clone = void;
    clone.player = this.player.witClone;
    clone.windowType = this.windowType.witClone;
    clone.clickType = this.clickType.witClone;
    clone.slot = this.slot.witClone;
    clone.rawSlot = this.rawSlot.witClone;
    clone.clickedItem = this.clickedItem.witClone;
    clone.cursor = this.cursor.witClone;
    clone.hotbarButton = this.hotbarButton.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct InventoryCloseEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(Screen) windowType;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  InventoryCloseEventData witClone() const @nogc nothrow {
    InventoryCloseEventData clone = void;
    clone.player = this.player.witClone;
    clone.windowType = this.windowType.witClone;
    return clone;
  }
}

/++

+/
struct BlockRedstoneEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  ushort stateId;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  int oldCurrent;

  /++

  +/
  int newCurrent;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BlockRedstoneEventData witClone() const @nogc nothrow {
    BlockRedstoneEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.stateId = this.stateId.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.oldCurrent = this.oldCurrent.witClone;
    clone.newCurrent = this.newCurrent.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockBreakEventData {
  /++

  +/
  Option!(Player) player;

  /++

  +/
  WitString block;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  uint exp;

  /++

  +/
  bool shouldDrop;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    block.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  BlockBreakEventData witClone() const @nogc nothrow {
    BlockBreakEventData clone = void;
    clone.player = this.player.witClone;
    clone.block = this.block.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.exp = this.exp.witClone;
    clone.shouldDrop = this.shouldDrop.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockCanBuildEventData {
  /++

  +/
  WitString blockToBuild;

  /++

  +/
  bool buildable;

  /++

  +/
  Player player;

  /++

  +/
  WitString block;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    blockToBuild.witFree;
    block.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  BlockCanBuildEventData witClone() const @nogc nothrow {
    BlockCanBuildEventData clone = void;
    clone.blockToBuild = this.blockToBuild.witClone;
    clone.buildable = this.buildable.witClone;
    clone.player = this.player.witClone;
    clone.block = this.block.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockGrowEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  WitString oldBlock;

  /++

  +/
  ushort oldStateId;

  /++

  +/
  WitString newBlock;

  /++

  +/
  ushort newStateId;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    oldBlock.witFree;
    newBlock.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BlockGrowEventData witClone() const @nogc nothrow {
    BlockGrowEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.oldBlock = this.oldBlock.witClone;
    clone.oldStateId = this.oldStateId.witClone;
    clone.newBlock = this.newBlock.witClone;
    clone.newStateId = this.newStateId.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockPlaceEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString blockPlaced;

  /++

  +/
  WitString blockPlacedAgainst;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  bool canBuild;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    blockPlaced.witFree;
    blockPlacedAgainst.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  BlockPlaceEventData witClone() const @nogc nothrow {
    BlockPlaceEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPlaced = this.blockPlaced.witClone;
    clone.blockPlacedAgainst = this.blockPlacedAgainst.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.canBuild = this.canBuild.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BedrockFormResponseEventData {
  /++

  +/
  Player player;

  /++

  +/
  uint formId;

  /++

  +/
  Option!(WitString) responseData;

  void witFree() @nogc nothrow {
    responseData.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  BedrockFormResponseEventData witClone() const @nogc nothrow {
    BedrockFormResponseEventData clone = void;
    clone.player = this.player.witClone;
    clone.formId = this.formId.witClone;
    clone.responseData = this.responseData.witClone;
    return clone;
  }
}

/++

+/
struct DialogClickActionEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString id;

  /++

  +/
  Option!(WitList!(ubyte)) payload;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    id.witFree;
    payload.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  DialogClickActionEventData witClone() const @nogc nothrow {
    DialogClickActionEventData clone = void;
    clone.player = this.player.witClone;
    clone.id = this.id.witClone;
    clone.payload = this.payload.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct DialogShowEventData {
  /++

  +/
  Player player;

  /++

  +/
  Dialog dialog;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    dialog.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    dialog.witDrop;
  }

  DialogShowEventData witClone() const @nogc nothrow {
    DialogShowEventData clone = void;
    clone.player = this.player.witClone;
    clone.dialog = this.dialog.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct DialogClearEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  DialogClearEventData witClone() const @nogc nothrow {
    DialogClearEventData clone = void;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct ServerListPingEventData {
  /++

  +/
  WitString hostname;

  /++

  +/
  ServerListPingAddress address;

  /++

  +/
  TextComponent motd;

  /++

  +/
  uint maxPlayers;

  /++

  +/
  uint numPlayers;

  /++

  +/
  Option!(WitString) favicon;

  void witFree() @nogc nothrow {
    hostname.witFree;
    address.witFree;
    favicon.witFree;
  }

  void witDrop() @nogc nothrow {
    motd.witDrop;
  }

  ServerListPingEventData witClone() const @nogc nothrow {
    ServerListPingEventData clone = void;
    clone.hostname = this.hostname.witClone;
    clone.address = this.address.witClone;
    clone.motd = this.motd.witClone;
    clone.maxPlayers = this.maxPlayers.witClone;
    clone.numPlayers = this.numPlayers.witClone;
    clone.favicon = this.favicon.witClone;
    return clone;
  }
}

/++

+/
struct SpawnChangeEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  BlockPos previousPosition;

  /++

  +/
  float previousYaw;

  /++

  +/
  float previousPitch;

  /++

  +/
  BlockPos newPosition;

  /++

  +/
  float newYaw;

  /++

  +/
  float newPitch;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  SpawnChangeEventData witClone() const @nogc nothrow {
    SpawnChangeEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.previousPosition = this.previousPosition.witClone;
    clone.previousYaw = this.previousYaw.witClone;
    clone.previousPitch = this.previousPitch.witClone;
    clone.newPosition = this.newPosition.witClone;
    clone.newYaw = this.newYaw.witClone;
    clone.newPitch = this.newPitch.witClone;
    return clone;
  }
}

/++

+/
struct ServerBroadcastEventData {
  /++

  +/
  TextComponent message;

  /++

  +/
  TextComponent sender;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    message.witDrop;
    sender.witDrop;
  }

  ServerBroadcastEventData witClone() const @nogc nothrow {
    ServerBroadcastEventData clone = void;
    clone.message = this.message.witClone;
    clone.sender = this.sender.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PacketReceivedEventData {
  /++

  +/
  Player player;

  /++

  +/
  ServerboundPacket packet;

  /++

  +/
  int packetId;

  /++

  +/
  WitList!(ubyte) rawPayload;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    packet.witFree;
    rawPayload.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PacketReceivedEventData witClone() const @nogc nothrow {
    PacketReceivedEventData clone = void;
    clone.player = this.player.witClone;
    clone.packet = this.packet.witClone;
    clone.packetId = this.packetId.witClone;
    clone.rawPayload = this.rawPayload.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PacketSentEventData {
  /++

  +/
  Player player;

  /++

  +/
  ClientboundPacket packet;

  /++

  +/
  int packetId;

  /++

  +/
  WitList!(ubyte) rawPayload;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    packet.witFree;
    rawPayload.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PacketSentEventData witClone() const @nogc nothrow {
    PacketSentEventData clone = void;
    clone.player = this.player.witClone;
    clone.packet = this.packet.witClone;
    clone.packetId = this.packetId.witClone;
    clone.rawPayload = this.rawPayload.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerInteractEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  EntityInteractionAction action;

  /++

  +/
  bool sneaking;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerInteractEntityEventData witClone() const @nogc nothrow {
    PlayerInteractEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.action = this.action.witClone;
    clone.sneaking = this.sneaking.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct ChunkLoadEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  int chunkX;

  /++

  +/
  int chunkZ;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  ChunkLoadEventData witClone() const @nogc nothrow {
    ChunkLoadEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.chunkX = this.chunkX.witClone;
    clone.chunkZ = this.chunkZ.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct ChunkSaveEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  int chunkX;

  /++

  +/
  int chunkZ;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  ChunkSaveEventData witClone() const @nogc nothrow {
    ChunkSaveEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.chunkX = this.chunkX.witClone;
    clone.chunkZ = this.chunkZ.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct ChunkSendEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  int chunkX;

  /++

  +/
  int chunkZ;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  ChunkSendEventData witClone() const @nogc nothrow {
    ChunkSendEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.chunkX = this.chunkX.witClone;
    clone.chunkZ = this.chunkZ.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerDeathEventData {
  /++

  +/
  Player player;

  /++

  +/
  TextComponent deathMessage;

  /++

  +/
  int droppedExp;

  /++

  +/
  bool keepInventory;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    deathMessage.witDrop;
  }

  PlayerDeathEventData witClone() const @nogc nothrow {
    PlayerDeathEventData clone = void;
    clone.player = this.player.witClone;
    clone.deathMessage = this.deathMessage.witClone;
    clone.droppedExp = this.droppedExp.witClone;
    clone.keepInventory = this.keepInventory.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct EntitySpawnEventData {
  /++

  +/
  int entityId;

  /++

  +/
  WitString entityType;

  /++

  +/
  Position position;

  /++

  +/
  World targetWorld;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    entityType.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  EntitySpawnEventData witClone() const @nogc nothrow {
    EntitySpawnEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.entityType = this.entityType.witClone;
    clone.position = this.position.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct EntityDyeEventData {
  /++

  +/
  int entityId;

  /++

  +/
  WitString color;

  /++

  +/
  Option!(Player) player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    color.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  EntityDyeEventData witClone() const @nogc nothrow {
    EntityDyeEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.color = this.color.witClone;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct EntityTameEventData {
  /++

  +/
  int entityId;

  /++

  +/
  Player owner;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    owner.witDrop;
  }

  EntityTameEventData witClone() const @nogc nothrow {
    EntityTameEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.owner = this.owner.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct CreatureSpawnEventData {
  /++

  +/
  int entityId;

  /++

  +/
  WitString entityType;

  /++

  +/
  Position position;

  /++

  +/
  World targetWorld;

  /++

  +/
  WitString spawnReason;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    entityType.witFree;
    spawnReason.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  CreatureSpawnEventData witClone() const @nogc nothrow {
    CreatureSpawnEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.entityType = this.entityType.witClone;
    clone.position = this.position.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.spawnReason = this.spawnReason.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PiglinBarterEventData {
  /++

  +/
  int entityId;

  /++

  +/
  ItemStack inputItem;

  /++

  +/
  WitList!(ItemStack) outcome;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    outcome.witFree;
  }

  void witDrop() @nogc nothrow {
    inputItem.witDrop;
    outcome.witDrop;
  }

  PiglinBarterEventData witClone() const @nogc nothrow {
    PiglinBarterEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.inputItem = this.inputItem.witClone;
    clone.outcome = this.outcome.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerItemConsumeEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerItemConsumeEventData witClone() const @nogc nothrow {
    PlayerItemConsumeEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerItemDamageEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  /++

  +/
  int damage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerItemDamageEventData witClone() const @nogc nothrow {
    PlayerItemDamageEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    clone.damage = this.damage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerDropItemEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  /++

  +/
  ubyte count;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerDropItemEventData witClone() const @nogc nothrow {
    PlayerDropItemEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    clone.count = this.count.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerBedEnterEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos bedPos;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerBedEnterEventData witClone() const @nogc nothrow {
    PlayerBedEnterEventData clone = void;
    clone.player = this.player.witClone;
    clone.bedPos = this.bedPos.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerBedLeaveEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos bedPos;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerBedLeaveEventData witClone() const @nogc nothrow {
    PlayerBedLeaveEventData clone = void;
    clone.player = this.player.witClone;
    clone.bedPos = this.bedPos.witClone;
    return clone;
  }
}

/++

+/
struct PlayerBucketEmptyEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitString bucket;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    bucket.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerBucketEmptyEventData witClone() const @nogc nothrow {
    PlayerBucketEmptyEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.bucket = this.bucket.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerBucketFillEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitString bucket;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    bucket.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerBucketFillEventData witClone() const @nogc nothrow {
    PlayerBucketFillEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.bucket = this.bucket.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct AsyncPlayerChatEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString message;

  /++

  +/
  TextComponent format;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    message.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    format.witDrop;
  }

  AsyncPlayerChatEventData witClone() const @nogc nothrow {
    AsyncPlayerChatEventData clone = void;
    clone.player = this.player.witClone;
    clone.message = this.message.witClone;
    clone.format = this.format.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct AsyncPlayerPreLoginEventData {
  /++

  +/
  WitString playerName;

  /++

  +/
  WitString playerUuid;

  /++

  +/
  WitString ipAddress;

  /++

  +/
  TextComponent kickMessage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    playerName.witFree;
    playerUuid.witFree;
    ipAddress.witFree;
  }

  void witDrop() @nogc nothrow {
    kickMessage.witDrop;
  }

  AsyncPlayerPreLoginEventData witClone() const @nogc nothrow {
    AsyncPlayerPreLoginEventData clone = void;
    clone.playerName = this.playerName.witClone;
    clone.playerUuid = this.playerUuid.witClone;
    clone.ipAddress = this.ipAddress.witClone;
    clone.kickMessage = this.kickMessage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerAdvancementDoneEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString advancementId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    advancementId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerAdvancementDoneEventData witClone() const @nogc nothrow {
    PlayerAdvancementDoneEventData clone = void;
    clone.player = this.player.witClone;
    clone.advancementId = this.advancementId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerAnimationEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString animationType;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    animationType.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerAnimationEventData witClone() const @nogc nothrow {
    PlayerAnimationEventData clone = void;
    clone.player = this.player.witClone;
    clone.animationType = this.animationType.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerArmorStandManipulateEventData {
  /++

  +/
  Player player;

  /++

  +/
  int armorStandId;

  /++

  +/
  ubyte slot;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerArmorStandManipulateEventData witClone() const @nogc nothrow {
    PlayerArmorStandManipulateEventData clone = void;
    clone.player = this.player.witClone;
    clone.armorStandId = this.armorStandId.witClone;
    clone.slot = this.slot.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerBucketEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  WitString bucketItem;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    bucketItem.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerBucketEntityEventData witClone() const @nogc nothrow {
    PlayerBucketEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.bucketItem = this.bucketItem.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerChangedWorldEventData {
  /++

  +/
  Player player;

  /++

  +/
  World fromWorld;

  /++

  +/
  World toWorld;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    fromWorld.witDrop;
    toWorld.witDrop;
  }

  PlayerChangedWorldEventData witClone() const @nogc nothrow {
    PlayerChangedWorldEventData clone = void;
    clone.player = this.player.witClone;
    clone.fromWorld = this.fromWorld.witClone;
    clone.toWorld = this.toWorld.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerChannelEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString channel;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    channel.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerChannelEventData witClone() const @nogc nothrow {
    PlayerChannelEventData clone = void;
    clone.player = this.player.witClone;
    clone.channel = this.channel.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerCommandPreprocessEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString command;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    command.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerCommandPreprocessEventData witClone() const @nogc nothrow {
    PlayerCommandPreprocessEventData clone = void;
    clone.player = this.player.witClone;
    clone.command = this.command.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerEditBookEventData {
  /++

  +/
  Player player;

  /++

  +/
  uint slot;

  /++

  +/
  WitList!(WitString) pages;

  /++

  +/
  Option!(WitString) title;

  /++

  +/
  bool signing;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    pages.witFree;
    title.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerEditBookEventData witClone() const @nogc nothrow {
    PlayerEditBookEventData clone = void;
    clone.player = this.player.witClone;
    clone.slot = this.slot.witClone;
    clone.pages = this.pages.witClone;
    clone.title = this.title.witClone;
    clone.signing = this.signing.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerElytraBoostEventData {
  /++

  +/
  Player player;

  /++

  +/
  int fireworkId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerElytraBoostEventData witClone() const @nogc nothrow {
    PlayerElytraBoostEventData clone = void;
    clone.player = this.player.witClone;
    clone.fireworkId = this.fireworkId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerExpCooldownChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  int newCooldown;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerExpCooldownChangeEventData witClone() const @nogc nothrow {
    PlayerExpCooldownChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.newCooldown = this.newCooldown.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerHarvestBlockEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitList!(ItemStack) harvestedItems;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    harvestedItems.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    harvestedItems.witDrop;
  }

  PlayerHarvestBlockEventData witClone() const @nogc nothrow {
    PlayerHarvestBlockEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.harvestedItems = this.harvestedItems.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerHideEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerHideEntityEventData witClone() const @nogc nothrow {
    PlayerHideEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerItemBreakEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerItemBreakEventData witClone() const @nogc nothrow {
    PlayerItemBreakEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    return clone;
  }
}

/++

+/
struct PlayerItemMendEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  /++

  +/
  int repairAmount;

  /++

  +/
  int expConsumed;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerItemMendEventData witClone() const @nogc nothrow {
    PlayerItemMendEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    clone.repairAmount = this.repairAmount.witClone;
    clone.expConsumed = this.expConsumed.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerKickEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString reason;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    reason.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerKickEventData witClone() const @nogc nothrow {
    PlayerKickEventData clone = void;
    clone.player = this.player.witClone;
    clone.reason = this.reason.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLeashEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  int holderId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerLeashEntityEventData witClone() const @nogc nothrow {
    PlayerLeashEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.holderId = this.holderId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLevelChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  int oldLevel;

  /++

  +/
  int newLevel;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerLevelChangeEventData witClone() const @nogc nothrow {
    PlayerLevelChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.oldLevel = this.oldLevel.witClone;
    clone.newLevel = this.newLevel.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLocaleChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString newLocale;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    newLocale.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerLocaleChangeEventData witClone() const @nogc nothrow {
    PlayerLocaleChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.newLocale = this.newLocale.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerNameEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  TextComponent name;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    name.witDrop;
  }

  PlayerNameEntityEventData witClone() const @nogc nothrow {
    PlayerNameEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.name = this.name.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerOpenSignEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  bool isFront;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerOpenSignEventData witClone() const @nogc nothrow {
    PlayerOpenSignEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.isFront = this.isFront.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerPortalEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos fromPos;

  /++

  +/
  Option!(BlockPos) toPos;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerPortalEventData witClone() const @nogc nothrow {
    PlayerPortalEventData clone = void;
    clone.player = this.player.witClone;
    clone.fromPos = this.fromPos.witClone;
    clone.toPos = this.toPos.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerPreLoginEventData {
  /++

  +/
  WitString playerName;

  /++

  +/
  WitString playerUuid;

  /++

  +/
  WitString ipAddress;

  /++

  +/
  TextComponent kickMessage;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    playerName.witFree;
    playerUuid.witFree;
    ipAddress.witFree;
  }

  void witDrop() @nogc nothrow {
    kickMessage.witDrop;
  }

  PlayerPreLoginEventData witClone() const @nogc nothrow {
    PlayerPreLoginEventData clone = void;
    clone.playerName = this.playerName.witClone;
    clone.playerUuid = this.playerUuid.witClone;
    clone.ipAddress = this.ipAddress.witClone;
    clone.kickMessage = this.kickMessage.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRiptideEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString itemName;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemName.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerRiptideEventData witClone() const @nogc nothrow {
    PlayerRiptideEventData clone = void;
    clone.player = this.player.witClone;
    clone.itemName = this.itemName.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerShearEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  ubyte hand;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerShearEntityEventData witClone() const @nogc nothrow {
    PlayerShearEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.hand = this.hand.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerShowEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerShowEntityEventData witClone() const @nogc nothrow {
    PlayerShowEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerSpawnChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(BlockPos) newSpawn;

  /++

  +/
  bool forced;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerSpawnChangeEventData witClone() const @nogc nothrow {
    PlayerSpawnChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.newSpawn = this.newSpawn.witClone;
    clone.forced = this.forced.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerStatisticIncrementEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString statisticId;

  /++

  +/
  int amount;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    statisticId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerStatisticIncrementEventData witClone() const @nogc nothrow {
    PlayerStatisticIncrementEventData clone = void;
    clone.player = this.player.witClone;
    clone.statisticId = this.statisticId.witClone;
    clone.amount = this.amount.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerSwapHandsEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerSwapHandsEventData witClone() const @nogc nothrow {
    PlayerSwapHandsEventData clone = void;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerTakeLecternBookEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  ItemStack book;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    book.witDrop;
  }

  PlayerTakeLecternBookEventData witClone() const @nogc nothrow {
    PlayerTakeLecternBookEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.book = this.book.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerUnleashEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerUnleashEntityEventData witClone() const @nogc nothrow {
    PlayerUnleashEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerVelocityEventData {
  /++

  +/
  Player player;

  /++

  +/
  Position velocity;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerVelocityEventData witClone() const @nogc nothrow {
    PlayerVelocityEventData clone = void;
    clone.player = this.player.witClone;
    clone.velocity = this.velocity.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerInputEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString input;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    input.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerInputEventData witClone() const @nogc nothrow {
    PlayerInputEventData clone = void;
    clone.player = this.player.witClone;
    clone.input = this.input.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerInteractAtEntityEventData {
  /++

  +/
  Player player;

  /++

  +/
  int entityId;

  /++

  +/
  double clickedX;

  /++

  +/
  double clickedY;

  /++

  +/
  double clickedZ;

  /++

  +/
  ubyte hand;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerInteractAtEntityEventData witClone() const @nogc nothrow {
    PlayerInteractAtEntityEventData clone = void;
    clone.player = this.player.witClone;
    clone.entityId = this.entityId.witClone;
    clone.clickedX = this.clickedX.witClone;
    clone.clickedY = this.clickedY.witClone;
    clone.clickedZ = this.clickedZ.witClone;
    clone.hand = this.hand.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerLinksSendEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitList!(WitString) links;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    links.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerLinksSendEventData witClone() const @nogc nothrow {
    PlayerLinksSendEventData clone = void;
    clone.player = this.player.witClone;
    clone.links = this.links.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerPickupArrowEventData {
  /++

  +/
  Player player;

  /++

  +/
  int arrowId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerPickupArrowEventData witClone() const @nogc nothrow {
    PlayerPickupArrowEventData clone = void;
    clone.player = this.player.witClone;
    clone.arrowId = this.arrowId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRecipeBookClickEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString recipeId;

  /++

  +/
  bool makeAll;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    recipeId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerRecipeBookClickEventData witClone() const @nogc nothrow {
    PlayerRecipeBookClickEventData clone = void;
    clone.player = this.player.witClone;
    clone.recipeId = this.recipeId.witClone;
    clone.makeAll = this.makeAll.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRecipeBookSettingsChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString bookType;

  /++

  +/
  bool isOpen;

  /++

  +/
  bool isFiltering;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    bookType.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerRecipeBookSettingsChangeEventData witClone() const @nogc nothrow {
    PlayerRecipeBookSettingsChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.bookType = this.bookType.witClone;
    clone.isOpen = this.isOpen.witClone;
    clone.isFiltering = this.isFiltering.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRecipeDiscoverEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString recipeId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    recipeId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerRecipeDiscoverEventData witClone() const @nogc nothrow {
    PlayerRecipeDiscoverEventData clone = void;
    clone.player = this.player.witClone;
    clone.recipeId = this.recipeId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerRegisterChannelEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString channel;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    channel.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerRegisterChannelEventData witClone() const @nogc nothrow {
    PlayerRegisterChannelEventData clone = void;
    clone.player = this.player.witClone;
    clone.channel = this.channel.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerResourcePackStatusEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString packId;

  /++

  +/
  WitString status;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    packId.witFree;
    status.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerResourcePackStatusEventData witClone() const @nogc nothrow {
    PlayerResourcePackStatusEventData clone = void;
    clone.player = this.player.witClone;
    clone.packId = this.packId.witClone;
    clone.status = this.status.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerSpawnLocationEventData {
  /++

  +/
  Player player;

  /++

  +/
  Position spawnPos;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerSpawnLocationEventData witClone() const @nogc nothrow {
    PlayerSpawnLocationEventData clone = void;
    clone.player = this.player.witClone;
    clone.spawnPos = this.spawnPos.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PlayerUnregisterChannelEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString channel;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    channel.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PlayerUnregisterChannelEventData witClone() const @nogc nothrow {
    PlayerUnregisterChannelEventData clone = void;
    clone.player = this.player.witClone;
    clone.channel = this.channel.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockDamageEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  bool instaBreak;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  BlockDamageEventData witClone() const @nogc nothrow {
    BlockDamageEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.instaBreak = this.instaBreak.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct SignChangeEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitList!(WitString) lines;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    lines.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  SignChangeEventData witClone() const @nogc nothrow {
    SignChangeEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.lines = this.lines.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct HangingPlaceEventData {
  /++

  +/
  int entityId;

  /++

  +/
  Option!(Player) player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitString blockFace;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    blockFace.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  HangingPlaceEventData witClone() const @nogc nothrow {
    HangingPlaceEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.blockFace = this.blockFace.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BellResonateEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BellResonateEventData witClone() const @nogc nothrow {
    BellResonateEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BellRingEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  Option!(int) entityId;

  /++

  +/
  Option!(WitString) direction;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    direction.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BellRingEventData witClone() const @nogc nothrow {
    BellRingEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.entityId = this.entityId.witClone;
    clone.direction = this.direction.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockBrushEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  Player player;

  /++

  +/
  ItemStack item;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    player.witDrop;
    item.witDrop;
  }

  BlockBrushEventData witClone() const @nogc nothrow {
    BlockBrushEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.player = this.player.witClone;
    clone.item = this.item.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockCookEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ItemStack source;

  /++

  +/
  ItemStack result;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    source.witDrop;
    result.witDrop;
  }

  BlockCookEventData witClone() const @nogc nothrow {
    BlockCookEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.source = this.source.witClone;
    clone.result = this.result.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockDamageAbortEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ItemStack itemInHand;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    targetWorld.witDrop;
    itemInHand.witDrop;
  }

  BlockDamageAbortEventData witClone() const @nogc nothrow {
    BlockDamageAbortEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.itemInHand = this.itemInHand.witClone;
    return clone;
  }
}

/++

+/
struct BlockDispenseArmorEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int targetEntityId;

  /++

  +/
  ItemStack item;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    item.witDrop;
  }

  BlockDispenseArmorEventData witClone() const @nogc nothrow {
    BlockDispenseArmorEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.targetEntityId = this.targetEntityId.witClone;
    clone.item = this.item.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockDispenseLootEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  WitList!(ItemStack) items;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    items.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    items.witDrop;
  }

  BlockDispenseLootEventData witClone() const @nogc nothrow {
    BlockDispenseLootEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.items = this.items.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockDropItemEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  Option!(Player) player;

  /++

  +/
  WitList!(ItemStack) items;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    items.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    player.witDrop;
    items.witDrop;
  }

  BlockDropItemEventData witClone() const @nogc nothrow {
    BlockDropItemEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.player = this.player.witClone;
    clone.items = this.items.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockExpEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int exp;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BlockExpEventData witClone() const @nogc nothrow {
    BlockExpEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.exp = this.exp.witClone;
    return clone;
  }
}

/++

+/
struct BlockFertilizeEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  Option!(Player) player;

  /++

  +/
  WitList!(Tuple!(BlockPos, ushort)) changedBlocks;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    changedBlocks.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    player.witDrop;
  }

  BlockFertilizeEventData witClone() const @nogc nothrow {
    BlockFertilizeEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.player = this.player.witClone;
    clone.changedBlocks = this.changedBlocks.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockMultiPlaceEventData {
  /++

  +/
  Player player;

  /++

  +/
  World targetWorld;

  /++

  +/
  WitList!(Tuple!(BlockPos, ushort)) placedBlocks;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    placedBlocks.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    targetWorld.witDrop;
  }

  BlockMultiPlaceEventData witClone() const @nogc nothrow {
    BlockMultiPlaceEventData clone = void;
    clone.player = this.player.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.placedBlocks = this.placedBlocks.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockReceiveGameEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  WitString gameEvent;

  /++

  +/
  Option!(int) sourceEntityId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    gameEvent.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BlockReceiveGameEventData witClone() const @nogc nothrow {
    BlockReceiveGameEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.gameEvent = this.gameEvent.witClone;
    clone.sourceEntityId = this.sourceEntityId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockShearEntityEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int targetEntityId;

  /++

  +/
  ItemStack item;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    item.witDrop;
  }

  BlockShearEntityEventData witClone() const @nogc nothrow {
    BlockShearEntityEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.targetEntityId = this.targetEntityId.witClone;
    clone.item = this.item.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BlockSpreadEventData {
  /++

  +/
  BlockPos sourcePos;

  /++

  +/
  BlockPos targetPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ushort newStateId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BlockSpreadEventData witClone() const @nogc nothrow {
    BlockSpreadEventData clone = void;
    clone.sourcePos = this.sourcePos.witClone;
    clone.targetPos = this.targetPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.newStateId = this.newStateId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct BrewingStartEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int brewingTime;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  BrewingStartEventData witClone() const @nogc nothrow {
    BrewingStartEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.brewingTime = this.brewingTime.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct CampfireStartEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ItemStack item;

  /++

  +/
  ubyte slot;

  /++

  +/
  int cookingTime;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    item.witDrop;
  }

  CampfireStartEventData witClone() const @nogc nothrow {
    CampfireStartEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.item = this.item.witClone;
    clone.slot = this.slot.witClone;
    clone.cookingTime = this.cookingTime.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct CauldronLevelChangeEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int oldLevel;

  /++

  +/
  int newLevel;

  /++

  +/
  WitString reason;

  /++

  +/
  Option!(int) entityId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    reason.witFree;
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  CauldronLevelChangeEventData witClone() const @nogc nothrow {
    CauldronLevelChangeEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.oldLevel = this.oldLevel.witClone;
    clone.newLevel = this.newLevel.witClone;
    clone.reason = this.reason.witClone;
    clone.entityId = this.entityId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct CrafterCraftEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ItemStack result;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    result.witDrop;
  }

  CrafterCraftEventData witClone() const @nogc nothrow {
    CrafterCraftEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.result = this.result.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct EntityBlockFormEventData {
  /++

  +/
  int entityId;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ushort newStateId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  EntityBlockFormEventData witClone() const @nogc nothrow {
    EntityBlockFormEventData clone = void;
    clone.entityId = this.entityId.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.newStateId = this.newStateId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct FluidLevelChangeEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ushort newStateId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  FluidLevelChangeEventData witClone() const @nogc nothrow {
    FluidLevelChangeEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.newStateId = this.newStateId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct InventoryBlockStartEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  InventoryBlockStartEventData witClone() const @nogc nothrow {
    InventoryBlockStartEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    return clone;
  }
}

/++

+/
struct LeavesDecayEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  LeavesDecayEventData witClone() const @nogc nothrow {
    LeavesDecayEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct MoistureChangeEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int newMoisture;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  MoistureChangeEventData witClone() const @nogc nothrow {
    MoistureChangeEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.newMoisture = this.newMoisture.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct SculkBloomEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  int charge;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  SculkBloomEventData witClone() const @nogc nothrow {
    SculkBloomEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.charge = this.charge.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct VaultDisplayItemEventData {
  /++

  +/
  BlockPos blockPos;

  /++

  +/
  World targetWorld;

  /++

  +/
  ItemStack item;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
    item.witDrop;
  }

  VaultDisplayItemEventData witClone() const @nogc nothrow {
    VaultDisplayItemEventData clone = void;
    clone.blockPos = this.blockPos.witClone;
    clone.targetWorld = this.targetWorld.witClone;
    clone.item = this.item.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct WeatherChangeEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  bool toWeatherState;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  WeatherChangeEventData witClone() const @nogc nothrow {
    WeatherChangeEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.toWeatherState = this.toWeatherState.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct ThunderChangeEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  bool toThunderState;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  ThunderChangeEventData witClone() const @nogc nothrow {
    ThunderChangeEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.toThunderState = this.toThunderState.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct WorldLoadEventData {
  /++

  +/
  World targetWorld;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  WorldLoadEventData witClone() const @nogc nothrow {
    WorldLoadEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    return clone;
  }
}

/++

+/
struct WorldUnloadEventData {
  /++

  +/
  World targetWorld;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  WorldUnloadEventData witClone() const @nogc nothrow {
    WorldUnloadEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct WorldInitEventData {
  /++

  +/
  World targetWorld;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    targetWorld.witDrop;
  }

  WorldInitEventData witClone() const @nogc nothrow {
    WorldInitEventData clone = void;
    clone.targetWorld = this.targetWorld.witClone;
    return clone;
  }
}

/++

+/
struct InventoryOpenEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  InventoryOpenEventData witClone() const @nogc nothrow {
    InventoryOpenEventData clone = void;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct InventoryDragEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  InventoryDragEventData witClone() const @nogc nothrow {
    InventoryDragEventData clone = void;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct CraftItemEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString recipeId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    recipeId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  CraftItemEventData witClone() const @nogc nothrow {
    CraftItemEventData clone = void;
    clone.player = this.player.witClone;
    clone.recipeId = this.recipeId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct FurnaceExtractEventData {
  /++

  +/
  Player player;

  /++

  +/
  BlockPos blockPos;

  /++

  +/
  WitString itemId;

  /++

  +/
  uint itemAmount;

  /++

  +/
  float expGained;

  void witFree() @nogc nothrow {
    itemId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  FurnaceExtractEventData witClone() const @nogc nothrow {
    FurnaceExtractEventData clone = void;
    clone.player = this.player.witClone;
    clone.blockPos = this.blockPos.witClone;
    clone.itemId = this.itemId.witClone;
    clone.itemAmount = this.itemAmount.witClone;
    clone.expGained = this.expGained.witClone;
    return clone;
  }
}

/++

+/
struct InventoryCreativeEventData {
  /++

  +/
  Player player;

  /++

  +/
  short slot;

  /++

  +/
  WitString itemId;

  /++

  +/
  ubyte itemCount;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    itemId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  InventoryCreativeEventData witClone() const @nogc nothrow {
    InventoryCreativeEventData clone = void;
    clone.player = this.player.witClone;
    clone.slot = this.slot.witClone;
    clone.itemId = this.itemId.witClone;
    clone.itemCount = this.itemCount.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct InventoryInteractEventData {
  /++

  +/
  Player player;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  InventoryInteractEventData witClone() const @nogc nothrow {
    InventoryInteractEventData clone = void;
    clone.player = this.player.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PrepareAnvilEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString renameText;

  /++

  +/
  uint repairCost;

  void witFree() @nogc nothrow {
    renameText.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PrepareAnvilEventData witClone() const @nogc nothrow {
    PrepareAnvilEventData clone = void;
    clone.player = this.player.witClone;
    clone.renameText = this.renameText.witClone;
    clone.repairCost = this.repairCost.witClone;
    return clone;
  }
}

/++

+/
struct PrepareGrindstoneEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(WitString) resultItem;

  void witFree() @nogc nothrow {
    resultItem.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PrepareGrindstoneEventData witClone() const @nogc nothrow {
    PrepareGrindstoneEventData clone = void;
    clone.player = this.player.witClone;
    clone.resultItem = this.resultItem.witClone;
    return clone;
  }
}

/++

+/
struct PrepareInventoryResultEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(WitString) resultItem;

  void witFree() @nogc nothrow {
    resultItem.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PrepareInventoryResultEventData witClone() const @nogc nothrow {
    PrepareInventoryResultEventData clone = void;
    clone.player = this.player.witClone;
    clone.resultItem = this.resultItem.witClone;
    return clone;
  }
}

/++

+/
struct PrepareItemCraftEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString recipeId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    recipeId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PrepareItemCraftEventData witClone() const @nogc nothrow {
    PrepareItemCraftEventData clone = void;
    clone.player = this.player.witClone;
    clone.recipeId = this.recipeId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PrepareSmithingEventData {
  /++

  +/
  Player player;

  /++

  +/
  Option!(WitString) resultItem;

  void witFree() @nogc nothrow {
    resultItem.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  PrepareSmithingEventData witClone() const @nogc nothrow {
    PrepareSmithingEventData clone = void;
    clone.player = this.player.witClone;
    clone.resultItem = this.resultItem.witClone;
    return clone;
  }
}

/++

+/
struct SmithItemEventData {
  /++

  +/
  Player player;

  /++

  +/
  WitString recipeId;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    recipeId.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  SmithItemEventData witClone() const @nogc nothrow {
    SmithItemEventData clone = void;
    clone.player = this.player.witClone;
    clone.recipeId = this.recipeId.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct TradeSelectEventData {
  /++

  +/
  Player player;

  /++

  +/
  ubyte slotIndex;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
  }

  TradeSelectEventData witClone() const @nogc nothrow {
    TradeSelectEventData clone = void;
    clone.player = this.player.witClone;
    clone.slotIndex = this.slotIndex.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct PrepareItemEnchantEventData {
  /++

  +/
  Player player;

  /++

  +/
  ItemStack item;

  /++

  +/
  WitList!(EnchantmentOffer) offers;

  /++

  +/
  int bookshelfCount;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    offers.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    item.witDrop;
  }

  PrepareItemEnchantEventData witClone() const @nogc nothrow {
    PrepareItemEnchantEventData clone = void;
    clone.player = this.player.witClone;
    clone.item = this.item.witClone;
    clone.offers = this.offers.witClone;
    clone.bookshelfCount = this.bookshelfCount.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct EnchantItemEventData {
  /++

  +/
  Player player;

  /++

  +/
  ItemStack item;

  /++

  +/
  int option;

  /++

  +/
  int cost;

  /++

  +/
  WitList!(EnchantmentValue) enchantmentsToAdd;

  /++

  +/
  bool cancelled;

  void witFree() @nogc nothrow {
    enchantmentsToAdd.witFree;
  }

  void witDrop() @nogc nothrow {
    player.witDrop;
    item.witDrop;
  }

  EnchantItemEventData witClone() const @nogc nothrow {
    EnchantItemEventData clone = void;
    clone.player = this.player.witClone;
    clone.item = this.item.witClone;
    clone.option = this.option.witClone;
    clone.cost = this.cost.witClone;
    clone.enchantmentsToAdd = this.enchantmentsToAdd.witClone;
    clone.cancelled = this.cancelled.witClone;
    return clone;
  }
}

/++

+/
struct Event {
  mixin WitVariant!(
    PlayerJoinEventData, // playerJoinEvent
    PlayerLeaveEventData, // playerLeaveEvent
    PlayerLoginEventData, // playerLoginEvent
    PlayerChatEventData, // playerChatEvent
    PlayerCommandSendEventData, // playerCommandSendEvent
    PlayerPermissionCheckEventData, // playerPermissionCheckEvent
    PlayerMoveEventData, // playerMoveEvent
    PlayerTeleportEventData, // playerTeleportEvent
    PlayerChangeWorldEventData, // playerChangeWorldEvent
    PlayerRespawnEventData, // playerRespawnEvent
    PlayerExpChangeEventData, // playerExpChangeEvent
    PlayerItemHeldEventData, // playerItemHeldEvent
    PlayerChangedMainHandEventData, // playerChangedMainHandEvent
    PlayerGamemodeChangeEventData, // playerGamemodeChangeEvent
    PlayerCustomPayloadEventData, // playerCustomPayloadEvent
    PlayerFishEventData, // playerFishEvent
    PlayerEggThrowEventData, // playerEggThrowEvent
    PlayerInteractUnknownEntityEventData, // playerInteractUnknownEntityEvent
    PlayerInteractEntityEventData, // playerInteractEntityEvent
    PlayerInteractEventData, // playerInteractEvent
    PlayerToggleSneakEventData, // playerToggleSneakEvent
    PlayerToggleFlightEventData, // playerToggleFlightEvent
    PlayerToggleSprintEventData, // playerToggleSprintEvent
    InventoryClickEventData, // inventoryClickEvent
    InventoryCloseEventData, // inventoryCloseEvent
    BlockRedstoneEventData, // blockRedstoneEvent
    BlockBreakEventData, // blockBreakEvent
    BlockBurnEventData, // blockBurnEvent
    BlockCanBuildEventData, // blockCanBuildEvent
    BlockGrowEventData, // blockGrowEvent
    BlockPlaceEventData, // blockPlaceEvent
    DialogClickActionEventData, // dialogClickActionEvent
    DialogShowEventData, // dialogShowEvent
    DialogClearEventData, // dialogClearEvent
    BedrockFormResponseEventData, // bedrockFormResponseEvent
    ServerCommandEventData, // serverCommandEvent
    ServerListPingEventData, // serverListPingEvent
    ServerLoadEventData, // serverLoadEvent
    SpawnChangeEventData, // spawnChangeEvent
    ServerBroadcastEventData, // serverBroadcastEvent
    ServerTickStartEventData, // serverTickStartEvent
    ServerTickEndEventData, // serverTickEndEvent
    PacketReceivedEventData, // packetReceivedEvent
    PacketSentEventData, // packetSentEvent
    ChunkLoadEventData, // chunkLoadEvent
    ChunkSaveEventData, // chunkSaveEvent
    ChunkSendEventData, // chunkSendEvent
    EntityDamageEventData, // entityDamageEvent
    EntityDeathEventData, // entityDeathEvent
    PlayerDeathEventData, // playerDeathEvent
    EntitySpawnEventData, // entitySpawnEvent
    EntityCombustEventData, // entityCombustEvent
    EntityRegainHealthEventData, // entityRegainHealthEvent
    EntityAirChangeEventData, // entityAirChangeEvent
    EntityBreedEventData, // entityBreedEvent
    EntityDismountEventData, // entityDismountEvent
    EntityDyeEventData, // entityDyeEvent
    EntityEnterLoveModeEventData, // entityEnterLoveModeEvent
    EntityExplodeEventData, // entityExplodeEvent
    EntityMountEventData, // entityMountEvent
    EntityPickupItemEventData, // entityPickupItemEvent
    EntityPortalEventData, // entityPortalEvent
    EntityResurrectEventData, // entityResurrectEvent
    EntityShootBowEventData, // entityShootBowEvent
    EntityTameEventData, // entityTameEvent
    EntityTargetEventData, // entityTargetEvent
    EntityTeleportEventData, // entityTeleportEvent
    EntityToggleGlideEventData, // entityToggleGlideEvent
    EntityTransformEventData, // entityTransformEvent
    PlayerItemConsumeEventData, // playerItemConsumeEvent
    PlayerItemDamageEventData, // playerItemDamageEvent
    PlayerDropItemEventData, // playerDropItemEvent
    PlayerBedEnterEventData, // playerBedEnterEvent
    PlayerBedLeaveEventData, // playerBedLeaveEvent
    PlayerBucketEmptyEventData, // playerBucketEmptyEvent
    PlayerBucketFillEventData, // playerBucketFillEvent
    BlockDamageEventData, // blockDamageEvent
    BlockIgniteEventData, // blockIgniteEvent
    BlockFromToEventData, // blockFromToEvent
    BlockFormEventData, // blockFormEvent
    BlockFadeEventData, // blockFadeEvent
    BlockDispenseEventData, // blockDispenseEvent
    BlockExplodeEventData, // blockExplodeEvent
    BlockPhysicsEventData, // blockPhysicsEvent
    BlockPistonExtendEventData, // blockPistonExtendEvent
    BlockPistonRetractEventData, // blockPistonRetractEvent
    NotePlayEventData, // notePlayEvent
    SignChangeEventData, // signChangeEvent
    SpongeAbsorbEventData, // spongeAbsorbEvent
    TntPrimeEventData, // tntPrimeEvent
    WeatherChangeEventData, // weatherChangeEvent
    ThunderChangeEventData, // thunderChangeEvent
    WorldLoadEventData, // worldLoadEvent
    WorldUnloadEventData, // worldUnloadEvent
    AsyncStructureGenerateEventData, // asyncStructureGenerateEvent
    AsyncStructureSpawnEventData, // asyncStructureSpawnEvent
    ChunkPopulateEventData, // chunkPopulateEvent
    ChunkUnloadEventData, // chunkUnloadEvent
    EntitiesLoadEventData, // entitiesLoadEvent
    EntitiesUnloadEventData, // entitiesUnloadEvent
    GenericGameEventData, // genericGameEvent
    LootGenerateEventData, // lootGenerateEvent
    PortalCreateEventData, // portalCreateEvent
    StructureGrowEventData, // structureGrowEvent
    TimeSkipEventData, // timeSkipEvent
    WorldInitEventData, // worldInitEvent
    WorldSaveEventData, // worldSaveEvent
    InventoryOpenEventData, // inventoryOpenEvent
    InventoryDragEventData, // inventoryDragEvent
    CraftItemEventData, // craftItemEvent
    FurnaceSmeltEventData, // furnaceSmeltEvent
    BrewEventData, // brewEvent
    BrewingStandFuelEventData, // brewingStandFuelEvent
    FurnaceBurnEventData, // furnaceBurnEvent
    FurnaceExtractEventData, // furnaceExtractEvent
    FurnaceStartSmeltEventData, // furnaceStartSmeltEvent
    HopperInventorySearchEventData, // hopperInventorySearchEvent
    InventoryCreativeEventData, // inventoryCreativeEvent
    InventoryInteractEventData, // inventoryInteractEvent
    InventoryMoveItemEventData, // inventoryMoveItemEvent
    InventoryPickupItemEventData, // inventoryPickupItemEvent
    PrepareAnvilEventData, // prepareAnvilEvent
    PrepareGrindstoneEventData, // prepareGrindstoneEvent
    PrepareInventoryResultEventData, // prepareInventoryResultEvent
    PrepareItemCraftEventData, // prepareItemCraftEvent
    PrepareSmithingEventData, // prepareSmithingEvent
    SmithItemEventData, // smithItemEvent
    TradeSelectEventData, // tradeSelectEvent
    VehicleBlockCollisionEventData, // vehicleBlockCollisionEvent
    VehicleCollisionEventData, // vehicleCollisionEvent
    VehicleCreateEventData, // vehicleCreateEvent
    VehicleDamageEventData, // vehicleDamageEvent
    VehicleDestroyEventData, // vehicleDestroyEvent
    VehicleEnterEventData, // vehicleEnterEvent
    VehicleEntityCollisionEventData, // vehicleEntityCollisionEvent
    VehicleExitEventData, // vehicleExitEvent
    VehicleMoveEventData, // vehicleMoveEvent
    VehicleUpdateEventData, // vehicleUpdateEvent
    PrepareItemEnchantEventData, // prepareItemEnchantEvent
    EnchantItemEventData, // enchantItemEvent
    MapInitializeEventData, // mapInitializeEvent
    HangingBreakEventData, // hangingBreakEvent
    HangingBreakByEntityEventData, // hangingBreakByEntityEvent
    HangingPlaceEventData, // hangingPlaceEvent
    BellResonateEventData, // bellResonateEvent
    BellRingEventData, // bellRingEvent
    BlockBrushEventData, // blockBrushEvent
    BlockCookEventData, // blockCookEvent
    BlockDamageAbortEventData, // blockDamageAbortEvent
    BlockDispenseArmorEventData, // blockDispenseArmorEvent
    BlockDispenseLootEventData, // blockDispenseLootEvent
    BlockDropItemEventData, // blockDropItemEvent
    BlockExpEventData, // blockExpEvent
    BlockFertilizeEventData, // blockFertilizeEvent
    BlockMultiPlaceEventData, // blockMultiPlaceEvent
    BlockReceiveGameEventData, // blockReceiveGameEvent
    BlockShearEntityEventData, // blockShearEntityEvent
    BlockSpreadEventData, // blockSpreadEvent
    BrewingStartEventData, // brewingStartEvent
    CampfireStartEventData, // campfireStartEvent
    CauldronLevelChangeEventData, // cauldronLevelChangeEvent
    CrafterCraftEventData, // crafterCraftEvent
    EntityBlockFormEventData, // entityBlockFormEvent
    FluidLevelChangeEventData, // fluidLevelChangeEvent
    InventoryBlockStartEventData, // inventoryBlockStartEvent
    LeavesDecayEventData, // leavesDecayEvent
    MoistureChangeEventData, // moistureChangeEvent
    SculkBloomEventData, // sculkBloomEvent
    VaultDisplayItemEventData, // vaultDisplayItemEvent
    CreatureSpawnEventData, // creatureSpawnEvent
    EnderDragonChangePhaseEventData, // enderDragonChangePhaseEvent
    EntityBreakDoorEventData, // entityBreakDoorEvent
    EntityChangeBlockEventData, // entityChangeBlockEvent
    EntityDamageByBlockEventData, // entityDamageByBlockEvent
    EntityDamageByEntityEventData, // entityDamageByEntityEvent
    EntityDropItemEventData, // entityDropItemEvent
    EntityEnterBlockEventData, // entityEnterBlockEvent
    EntityExhaustionEventData, // entityExhaustionEvent
    EntityInteractEventData, // entityInteractEvent
    EntityKnockbackEventData, // entityKnockbackEvent
    EntityPlaceEventData, // entityPlaceEvent
    EntityPoseChangeEventData, // entityPoseChangeEvent
    EntityPotionEffectEventData, // entityPotionEffectEvent
    EntitySpellCastEventData, // entitySpellCastEvent
    EntityTargetLivingEntityEventData, // entityTargetLivingEntityEvent
    EntityToggleSwimEventData, // entityToggleSwimEvent
    ExplosionPrimeEventData, // explosionPrimeEvent
    FireworkExplodeEventData, // fireworkExplodeEvent
    FoodLevelChangeEventData, // foodLevelChangeEvent
    ItemDespawnEventData, // itemDespawnEvent
    ItemMergeEventData, // itemMergeEvent
    ItemSpawnEventData, // itemSpawnEvent
    PiglinBarterEventData, // piglinBarterEvent
    ProjectileHitEventData, // projectileHitEvent
    ProjectileLaunchEventData, // projectileLaunchEvent
    SheepDyeWoolEventData, // sheepDyeWoolEvent
    SheepRegrowWoolEventData, // sheepRegrowWoolEvent
    SlimeSplitEventData, // slimeSplitEvent
    StriderTemperatureChangeEventData, // striderTemperatureChangeEvent
    VillagerAcquireTradeEventData, // villagerAcquireTradeEvent
    VillagerCareerChangeEventData, // villagerCareerChangeEvent
    VillagerReplenishTradeEventData, // villagerReplenishTradeEvent
    WardenAngerChangeEventData, // wardenAngerChangeEvent
    AreaEffectCloudApplyEventData, // areaEffectCloudApplyEvent
    ArrowBodyCountChangeEventData, // arrowBodyCountChangeEvent
    BatToggleSleepEventData, // batToggleSleepEvent
    CreeperPowerEventData, // creeperPowerEvent
    EntityCombustByBlockEventData, // entityCombustByBlockEvent
    EntityCombustByEntityEventData, // entityCombustByEntityEvent
    EntityKnockbackByEntityEventData, // entityKnockbackByEntityEvent
    EntityPortalEnterEventData, // entityPortalEnterEvent
    EntityPortalExitEventData, // entityPortalExitEvent
    EntityRemoveEventData, // entityRemoveEvent
    EntityTargetBlockEventData, // entityTargetBlockEvent
    EntityUnleashEventData, // entityUnleashEvent
    ExpBottleEventData, // expBottleEvent
    HorseJumpEventData, // horseJumpEvent
    LingeringPotionSplashEventData, // lingeringPotionSplashEvent
    PigZapEventData, // pigZapEvent
    PigZombieAngerEventData, // pigZombieAngerEvent
    PotionSplashEventData, // potionSplashEvent
    SpawnerSpawnEventData, // spawnerSpawnEvent
    TrialSpawnerSpawnEventData, // trialSpawnerSpawnEvent
    VillagerReputationChangeEventData, // villagerReputationChangeEvent
    AsyncPlayerChatEventData, // asyncPlayerChatEvent
    AsyncPlayerPreLoginEventData, // asyncPlayerPreLoginEvent
    PlayerAdvancementDoneEventData, // playerAdvancementDoneEvent
    PlayerAnimationEventData, // playerAnimationEvent
    PlayerArmorStandManipulateEventData, // playerArmorStandManipulateEvent
    PlayerBucketEntityEventData, // playerBucketEntityEvent
    PlayerChangedWorldEventData, // playerChangedWorldEvent
    PlayerChannelEventData, // playerChannelEvent
    PlayerCommandPreprocessEventData, // playerCommandPreprocessEvent
    PlayerEditBookEventData, // playerEditBookEvent
    PlayerElytraBoostEventData, // playerElytraBoostEvent
    PlayerExpCooldownChangeEventData, // playerExpCooldownChangeEvent
    PlayerHarvestBlockEventData, // playerHarvestBlockEvent
    PlayerHideEntityEventData, // playerHideEntityEvent
    PlayerItemBreakEventData, // playerItemBreakEvent
    PlayerItemMendEventData, // playerItemMendEvent
    PlayerKickEventData, // playerKickEvent
    PlayerLeashEntityEventData, // playerLeashEntityEvent
    PlayerLevelChangeEventData, // playerLevelChangeEvent
    PlayerLocaleChangeEventData, // playerLocaleChangeEvent
    PlayerNameEntityEventData, // playerNameEntityEvent
    PlayerOpenSignEventData, // playerOpenSignEvent
    PlayerPortalEventData, // playerPortalEvent
    PlayerPreLoginEventData, // playerPreLoginEvent
    PlayerRiptideEventData, // playerRiptideEvent
    PlayerShearEntityEventData, // playerShearEntityEvent
    PlayerShowEntityEventData, // playerShowEntityEvent
    PlayerSpawnChangeEventData, // playerSpawnChangeEvent
    PlayerStatisticIncrementEventData, // playerStatisticIncrementEvent
    PlayerSwapHandsEventData, // playerSwapHandsEvent
    PlayerTakeLecternBookEventData, // playerTakeLecternBookEvent
    PlayerUnleashEntityEventData, // playerUnleashEntityEvent
    PlayerVelocityEventData, // playerVelocityEvent
    PlayerInputEventData, // playerInputEvent
    PlayerInteractAtEntityEventData, // playerInteractAtEntityEvent
    PlayerLinksSendEventData, // playerLinksSendEvent
    PlayerPickupArrowEventData, // playerPickupArrowEvent
    PlayerRecipeBookClickEventData, // playerRecipeBookClickEvent
    PlayerRecipeBookSettingsChangeEventData, // playerRecipeBookSettingsChangeEvent
    PlayerRecipeDiscoverEventData, // playerRecipeDiscoverEvent
    PlayerRegisterChannelEventData, // playerRegisterChannelEvent
    PlayerResourcePackStatusEventData, // playerResourcePackStatusEvent
    PlayerSpawnLocationEventData, // playerSpawnLocationEvent
    PlayerUnregisterChannelEventData, // playerUnregisterChannelEvent
    RaidFinishEventData, // raidFinishEvent
    RaidSpawnWaveEventData, // raidSpawnWaveEvent
    RaidStopEventData, // raidStopEvent
    RaidTriggerEventData, // raidTriggerEvent
    LightningStrikeEventData, // lightningStrikeEvent
  );

public:
  enum Tag : ushort {
    /++

    +/
    playerJoinEvent,

    /++

    +/
    playerLeaveEvent,

    /++

    +/
    playerLoginEvent,

    /++

    +/
    playerChatEvent,

    /++

    +/
    playerCommandSendEvent,

    /++

    +/
    playerPermissionCheckEvent,

    /++

    +/
    playerMoveEvent,

    /++

    +/
    playerTeleportEvent,

    /++

    +/
    playerChangeWorldEvent,

    /++

    +/
    playerRespawnEvent,

    /++

    +/
    playerExpChangeEvent,

    /++

    +/
    playerItemHeldEvent,

    /++

    +/
    playerChangedMainHandEvent,

    /++

    +/
    playerGamemodeChangeEvent,

    /++

    +/
    playerCustomPayloadEvent,

    /++

    +/
    playerFishEvent,

    /++

    +/
    playerEggThrowEvent,

    /++

    +/
    playerInteractUnknownEntityEvent,

    /++

    +/
    playerInteractEntityEvent,

    /++

    +/
    playerInteractEvent,

    /++

    +/
    playerToggleSneakEvent,

    /++

    +/
    playerToggleFlightEvent,

    /++

    +/
    playerToggleSprintEvent,

    /++

    +/
    inventoryClickEvent,

    /++

    +/
    inventoryCloseEvent,

    /++

    +/
    blockRedstoneEvent,

    /++

    +/
    blockBreakEvent,

    /++

    +/
    blockBurnEvent,

    /++

    +/
    blockCanBuildEvent,

    /++

    +/
    blockGrowEvent,

    /++

    +/
    blockPlaceEvent,

    /++

    +/
    dialogClickActionEvent,

    /++

    +/
    dialogShowEvent,

    /++

    +/
    dialogClearEvent,

    /++

    +/
    bedrockFormResponseEvent,

    /++

    +/
    serverCommandEvent,

    /++

    +/
    serverListPingEvent,

    /++

    +/
    serverLoadEvent,

    /++

    +/
    spawnChangeEvent,

    /++

    +/
    serverBroadcastEvent,

    /++

    +/
    serverTickStartEvent,

    /++

    +/
    serverTickEndEvent,

    /++

    +/
    packetReceivedEvent,

    /++

    +/
    packetSentEvent,

    /++

    +/
    chunkLoadEvent,

    /++

    +/
    chunkSaveEvent,

    /++

    +/
    chunkSendEvent,

    /++

    +/
    entityDamageEvent,

    /++

    +/
    entityDeathEvent,

    /++

    +/
    playerDeathEvent,

    /++

    +/
    entitySpawnEvent,

    /++

    +/
    entityCombustEvent,

    /++

    +/
    entityRegainHealthEvent,

    /++

    +/
    entityAirChangeEvent,

    /++

    +/
    entityBreedEvent,

    /++

    +/
    entityDismountEvent,

    /++

    +/
    entityDyeEvent,

    /++

    +/
    entityEnterLoveModeEvent,

    /++

    +/
    entityExplodeEvent,

    /++

    +/
    entityMountEvent,

    /++

    +/
    entityPickupItemEvent,

    /++

    +/
    entityPortalEvent,

    /++

    +/
    entityResurrectEvent,

    /++

    +/
    entityShootBowEvent,

    /++

    +/
    entityTameEvent,

    /++

    +/
    entityTargetEvent,

    /++

    +/
    entityTeleportEvent,

    /++

    +/
    entityToggleGlideEvent,

    /++

    +/
    entityTransformEvent,

    /++

    +/
    playerItemConsumeEvent,

    /++

    +/
    playerItemDamageEvent,

    /++

    +/
    playerDropItemEvent,

    /++

    +/
    playerBedEnterEvent,

    /++

    +/
    playerBedLeaveEvent,

    /++

    +/
    playerBucketEmptyEvent,

    /++

    +/
    playerBucketFillEvent,

    /++

    +/
    blockDamageEvent,

    /++

    +/
    blockIgniteEvent,

    /++

    +/
    blockFromToEvent,

    /++

    +/
    blockFormEvent,

    /++

    +/
    blockFadeEvent,

    /++

    +/
    blockDispenseEvent,

    /++

    +/
    blockExplodeEvent,

    /++

    +/
    blockPhysicsEvent,

    /++

    +/
    blockPistonExtendEvent,

    /++

    +/
    blockPistonRetractEvent,

    /++

    +/
    notePlayEvent,

    /++

    +/
    signChangeEvent,

    /++

    +/
    spongeAbsorbEvent,

    /++

    +/
    tntPrimeEvent,

    /++

    +/
    weatherChangeEvent,

    /++

    +/
    thunderChangeEvent,

    /++

    +/
    worldLoadEvent,

    /++

    +/
    worldUnloadEvent,

    /++

    +/
    asyncStructureGenerateEvent,

    /++

    +/
    asyncStructureSpawnEvent,

    /++

    +/
    chunkPopulateEvent,

    /++

    +/
    chunkUnloadEvent,

    /++

    +/
    entitiesLoadEvent,

    /++

    +/
    entitiesUnloadEvent,

    /++

    +/
    genericGameEvent,

    /++

    +/
    lootGenerateEvent,

    /++

    +/
    portalCreateEvent,

    /++

    +/
    structureGrowEvent,

    /++

    +/
    timeSkipEvent,

    /++

    +/
    worldInitEvent,

    /++

    +/
    worldSaveEvent,

    /++

    +/
    inventoryOpenEvent,

    /++

    +/
    inventoryDragEvent,

    /++

    +/
    craftItemEvent,

    /++

    +/
    furnaceSmeltEvent,

    /++

    +/
    brewEvent,

    /++

    +/
    brewingStandFuelEvent,

    /++

    +/
    furnaceBurnEvent,

    /++

    +/
    furnaceExtractEvent,

    /++

    +/
    furnaceStartSmeltEvent,

    /++

    +/
    hopperInventorySearchEvent,

    /++

    +/
    inventoryCreativeEvent,

    /++

    +/
    inventoryInteractEvent,

    /++

    +/
    inventoryMoveItemEvent,

    /++

    +/
    inventoryPickupItemEvent,

    /++

    +/
    prepareAnvilEvent,

    /++

    +/
    prepareGrindstoneEvent,

    /++

    +/
    prepareInventoryResultEvent,

    /++

    +/
    prepareItemCraftEvent,

    /++

    +/
    prepareSmithingEvent,

    /++

    +/
    smithItemEvent,

    /++

    +/
    tradeSelectEvent,

    /++

    +/
    vehicleBlockCollisionEvent,

    /++

    +/
    vehicleCollisionEvent,

    /++

    +/
    vehicleCreateEvent,

    /++

    +/
    vehicleDamageEvent,

    /++

    +/
    vehicleDestroyEvent,

    /++

    +/
    vehicleEnterEvent,

    /++

    +/
    vehicleEntityCollisionEvent,

    /++

    +/
    vehicleExitEvent,

    /++

    +/
    vehicleMoveEvent,

    /++

    +/
    vehicleUpdateEvent,

    /++

    +/
    prepareItemEnchantEvent,

    /++

    +/
    enchantItemEvent,

    /++

    +/
    mapInitializeEvent,

    /++

    +/
    hangingBreakEvent,

    /++

    +/
    hangingBreakByEntityEvent,

    /++

    +/
    hangingPlaceEvent,

    /++

    +/
    bellResonateEvent,

    /++

    +/
    bellRingEvent,

    /++

    +/
    blockBrushEvent,

    /++

    +/
    blockCookEvent,

    /++

    +/
    blockDamageAbortEvent,

    /++

    +/
    blockDispenseArmorEvent,

    /++

    +/
    blockDispenseLootEvent,

    /++

    +/
    blockDropItemEvent,

    /++

    +/
    blockExpEvent,

    /++

    +/
    blockFertilizeEvent,

    /++

    +/
    blockMultiPlaceEvent,

    /++

    +/
    blockReceiveGameEvent,

    /++

    +/
    blockShearEntityEvent,

    /++

    +/
    blockSpreadEvent,

    /++

    +/
    brewingStartEvent,

    /++

    +/
    campfireStartEvent,

    /++

    +/
    cauldronLevelChangeEvent,

    /++

    +/
    crafterCraftEvent,

    /++

    +/
    entityBlockFormEvent,

    /++

    +/
    fluidLevelChangeEvent,

    /++

    +/
    inventoryBlockStartEvent,

    /++

    +/
    leavesDecayEvent,

    /++

    +/
    moistureChangeEvent,

    /++

    +/
    sculkBloomEvent,

    /++

    +/
    vaultDisplayItemEvent,

    /++

    +/
    creatureSpawnEvent,

    /++

    +/
    enderDragonChangePhaseEvent,

    /++

    +/
    entityBreakDoorEvent,

    /++

    +/
    entityChangeBlockEvent,

    /++

    +/
    entityDamageByBlockEvent,

    /++

    +/
    entityDamageByEntityEvent,

    /++

    +/
    entityDropItemEvent,

    /++

    +/
    entityEnterBlockEvent,

    /++

    +/
    entityExhaustionEvent,

    /++

    +/
    entityInteractEvent,

    /++

    +/
    entityKnockbackEvent,

    /++

    +/
    entityPlaceEvent,

    /++

    +/
    entityPoseChangeEvent,

    /++

    +/
    entityPotionEffectEvent,

    /++

    +/
    entitySpellCastEvent,

    /++

    +/
    entityTargetLivingEntityEvent,

    /++

    +/
    entityToggleSwimEvent,

    /++

    +/
    explosionPrimeEvent,

    /++

    +/
    fireworkExplodeEvent,

    /++

    +/
    foodLevelChangeEvent,

    /++

    +/
    itemDespawnEvent,

    /++

    +/
    itemMergeEvent,

    /++

    +/
    itemSpawnEvent,

    /++

    +/
    piglinBarterEvent,

    /++

    +/
    projectileHitEvent,

    /++

    +/
    projectileLaunchEvent,

    /++

    +/
    sheepDyeWoolEvent,

    /++

    +/
    sheepRegrowWoolEvent,

    /++

    +/
    slimeSplitEvent,

    /++

    +/
    striderTemperatureChangeEvent,

    /++

    +/
    villagerAcquireTradeEvent,

    /++

    +/
    villagerCareerChangeEvent,

    /++

    +/
    villagerReplenishTradeEvent,

    /++

    +/
    wardenAngerChangeEvent,

    /++

    +/
    areaEffectCloudApplyEvent,

    /++

    +/
    arrowBodyCountChangeEvent,

    /++

    +/
    batToggleSleepEvent,

    /++

    +/
    creeperPowerEvent,

    /++

    +/
    entityCombustByBlockEvent,

    /++

    +/
    entityCombustByEntityEvent,

    /++

    +/
    entityKnockbackByEntityEvent,

    /++

    +/
    entityPortalEnterEvent,

    /++

    +/
    entityPortalExitEvent,

    /++

    +/
    entityRemoveEvent,

    /++

    +/
    entityTargetBlockEvent,

    /++

    +/
    entityUnleashEvent,

    /++

    +/
    expBottleEvent,

    /++

    +/
    horseJumpEvent,

    /++

    +/
    lingeringPotionSplashEvent,

    /++

    +/
    pigZapEvent,

    /++

    +/
    pigZombieAngerEvent,

    /++

    +/
    potionSplashEvent,

    /++

    +/
    spawnerSpawnEvent,

    /++

    +/
    trialSpawnerSpawnEvent,

    /++

    +/
    villagerReputationChangeEvent,

    /++

    +/
    asyncPlayerChatEvent,

    /++

    +/
    asyncPlayerPreLoginEvent,

    /++

    +/
    playerAdvancementDoneEvent,

    /++

    +/
    playerAnimationEvent,

    /++

    +/
    playerArmorStandManipulateEvent,

    /++

    +/
    playerBucketEntityEvent,

    /++

    +/
    playerChangedWorldEvent,

    /++

    +/
    playerChannelEvent,

    /++

    +/
    playerCommandPreprocessEvent,

    /++

    +/
    playerEditBookEvent,

    /++

    +/
    playerElytraBoostEvent,

    /++

    +/
    playerExpCooldownChangeEvent,

    /++

    +/
    playerHarvestBlockEvent,

    /++

    +/
    playerHideEntityEvent,

    /++

    +/
    playerItemBreakEvent,

    /++

    +/
    playerItemMendEvent,

    /++

    +/
    playerKickEvent,

    /++

    +/
    playerLeashEntityEvent,

    /++

    +/
    playerLevelChangeEvent,

    /++

    +/
    playerLocaleChangeEvent,

    /++

    +/
    playerNameEntityEvent,

    /++

    +/
    playerOpenSignEvent,

    /++

    +/
    playerPortalEvent,

    /++

    +/
    playerPreLoginEvent,

    /++

    +/
    playerRiptideEvent,

    /++

    +/
    playerShearEntityEvent,

    /++

    +/
    playerShowEntityEvent,

    /++

    +/
    playerSpawnChangeEvent,

    /++

    +/
    playerStatisticIncrementEvent,

    /++

    +/
    playerSwapHandsEvent,

    /++

    +/
    playerTakeLecternBookEvent,

    /++

    +/
    playerUnleashEntityEvent,

    /++

    +/
    playerVelocityEvent,

    /++

    +/
    playerInputEvent,

    /++

    +/
    playerInteractAtEntityEvent,

    /++

    +/
    playerLinksSendEvent,

    /++

    +/
    playerPickupArrowEvent,

    /++

    +/
    playerRecipeBookClickEvent,

    /++

    +/
    playerRecipeBookSettingsChangeEvent,

    /++

    +/
    playerRecipeDiscoverEvent,

    /++

    +/
    playerRegisterChannelEvent,

    /++

    +/
    playerResourcePackStatusEvent,

    /++

    +/
    playerSpawnLocationEvent,

    /++

    +/
    playerUnregisterChannelEvent,

    /++

    +/
    raidFinishEvent,

    /++

    +/
    raidSpawnWaveEvent,

    /++

    +/
    raidStopEvent,

    /++

    +/
    raidTriggerEvent,

    /++

    +/
    lightningStrikeEvent,
  }
  pragma(inline, true) Tag tag() const @safe @nogc nothrow pure => _tag;

  /++

  +/
  alias playerJoinEvent = _create!(Tag.playerJoinEvent);
  /// ditto
  pragma(inline, true) bool isPlayerJoinEvent() const => _tag == Tag.playerJoinEvent;
  ///ditto
  alias getPlayerJoinEvent = _get!(Tag.playerJoinEvent);

  /++

  +/
  alias playerLeaveEvent = _create!(Tag.playerLeaveEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLeaveEvent() const => _tag == Tag.playerLeaveEvent;
  ///ditto
  alias getPlayerLeaveEvent = _get!(Tag.playerLeaveEvent);

  /++

  +/
  alias playerLoginEvent = _create!(Tag.playerLoginEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLoginEvent() const => _tag == Tag.playerLoginEvent;
  ///ditto
  alias getPlayerLoginEvent = _get!(Tag.playerLoginEvent);

  /++

  +/
  alias playerChatEvent = _create!(Tag.playerChatEvent);
  /// ditto
  pragma(inline, true) bool isPlayerChatEvent() const => _tag == Tag.playerChatEvent;
  ///ditto
  alias getPlayerChatEvent = _get!(Tag.playerChatEvent);

  /++

  +/
  alias playerCommandSendEvent = _create!(Tag.playerCommandSendEvent);
  /// ditto
  pragma(inline, true) bool isPlayerCommandSendEvent() const => _tag == Tag.playerCommandSendEvent;
  ///ditto
  alias getPlayerCommandSendEvent = _get!(Tag.playerCommandSendEvent);

  /++

  +/
  alias playerPermissionCheckEvent = _create!(Tag.playerPermissionCheckEvent);
  /// ditto
  pragma(inline, true) bool isPlayerPermissionCheckEvent() const => _tag == Tag.playerPermissionCheckEvent;
  ///ditto
  alias getPlayerPermissionCheckEvent = _get!(Tag.playerPermissionCheckEvent);

  /++

  +/
  alias playerMoveEvent = _create!(Tag.playerMoveEvent);
  /// ditto
  pragma(inline, true) bool isPlayerMoveEvent() const => _tag == Tag.playerMoveEvent;
  ///ditto
  alias getPlayerMoveEvent = _get!(Tag.playerMoveEvent);

  /++

  +/
  alias playerTeleportEvent = _create!(Tag.playerTeleportEvent);
  /// ditto
  pragma(inline, true) bool isPlayerTeleportEvent() const => _tag == Tag.playerTeleportEvent;
  ///ditto
  alias getPlayerTeleportEvent = _get!(Tag.playerTeleportEvent);

  /++

  +/
  alias playerChangeWorldEvent = _create!(Tag.playerChangeWorldEvent);
  /// ditto
  pragma(inline, true) bool isPlayerChangeWorldEvent() const => _tag == Tag.playerChangeWorldEvent;
  ///ditto
  alias getPlayerChangeWorldEvent = _get!(Tag.playerChangeWorldEvent);

  /++

  +/
  alias playerRespawnEvent = _create!(Tag.playerRespawnEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRespawnEvent() const => _tag == Tag.playerRespawnEvent;
  ///ditto
  alias getPlayerRespawnEvent = _get!(Tag.playerRespawnEvent);

  /++

  +/
  alias playerExpChangeEvent = _create!(Tag.playerExpChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerExpChangeEvent() const => _tag == Tag.playerExpChangeEvent;
  ///ditto
  alias getPlayerExpChangeEvent = _get!(Tag.playerExpChangeEvent);

  /++

  +/
  alias playerItemHeldEvent = _create!(Tag.playerItemHeldEvent);
  /// ditto
  pragma(inline, true) bool isPlayerItemHeldEvent() const => _tag == Tag.playerItemHeldEvent;
  ///ditto
  alias getPlayerItemHeldEvent = _get!(Tag.playerItemHeldEvent);

  /++

  +/
  alias playerChangedMainHandEvent = _create!(Tag.playerChangedMainHandEvent);
  /// ditto
  pragma(inline, true) bool isPlayerChangedMainHandEvent() const => _tag == Tag.playerChangedMainHandEvent;
  ///ditto
  alias getPlayerChangedMainHandEvent = _get!(Tag.playerChangedMainHandEvent);

  /++

  +/
  alias playerGamemodeChangeEvent = _create!(Tag.playerGamemodeChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerGamemodeChangeEvent() const => _tag == Tag.playerGamemodeChangeEvent;
  ///ditto
  alias getPlayerGamemodeChangeEvent = _get!(Tag.playerGamemodeChangeEvent);

  /++

  +/
  alias playerCustomPayloadEvent = _create!(Tag.playerCustomPayloadEvent);
  /// ditto
  pragma(inline, true) bool isPlayerCustomPayloadEvent() const => _tag == Tag.playerCustomPayloadEvent;
  ///ditto
  alias getPlayerCustomPayloadEvent = _get!(Tag.playerCustomPayloadEvent);

  /++

  +/
  alias playerFishEvent = _create!(Tag.playerFishEvent);
  /// ditto
  pragma(inline, true) bool isPlayerFishEvent() const => _tag == Tag.playerFishEvent;
  ///ditto
  alias getPlayerFishEvent = _get!(Tag.playerFishEvent);

  /++

  +/
  alias playerEggThrowEvent = _create!(Tag.playerEggThrowEvent);
  /// ditto
  pragma(inline, true) bool isPlayerEggThrowEvent() const => _tag == Tag.playerEggThrowEvent;
  ///ditto
  alias getPlayerEggThrowEvent = _get!(Tag.playerEggThrowEvent);

  /++

  +/
  alias playerInteractUnknownEntityEvent = _create!(Tag.playerInteractUnknownEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerInteractUnknownEntityEvent() const => _tag == Tag.playerInteractUnknownEntityEvent;
  ///ditto
  alias getPlayerInteractUnknownEntityEvent = _get!(Tag.playerInteractUnknownEntityEvent);

  /++

  +/
  alias playerInteractEntityEvent = _create!(Tag.playerInteractEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerInteractEntityEvent() const => _tag == Tag.playerInteractEntityEvent;
  ///ditto
  alias getPlayerInteractEntityEvent = _get!(Tag.playerInteractEntityEvent);

  /++

  +/
  alias playerInteractEvent = _create!(Tag.playerInteractEvent);
  /// ditto
  pragma(inline, true) bool isPlayerInteractEvent() const => _tag == Tag.playerInteractEvent;
  ///ditto
  alias getPlayerInteractEvent = _get!(Tag.playerInteractEvent);

  /++

  +/
  alias playerToggleSneakEvent = _create!(Tag.playerToggleSneakEvent);
  /// ditto
  pragma(inline, true) bool isPlayerToggleSneakEvent() const => _tag == Tag.playerToggleSneakEvent;
  ///ditto
  alias getPlayerToggleSneakEvent = _get!(Tag.playerToggleSneakEvent);

  /++

  +/
  alias playerToggleFlightEvent = _create!(Tag.playerToggleFlightEvent);
  /// ditto
  pragma(inline, true) bool isPlayerToggleFlightEvent() const => _tag == Tag.playerToggleFlightEvent;
  ///ditto
  alias getPlayerToggleFlightEvent = _get!(Tag.playerToggleFlightEvent);

  /++

  +/
  alias playerToggleSprintEvent = _create!(Tag.playerToggleSprintEvent);
  /// ditto
  pragma(inline, true) bool isPlayerToggleSprintEvent() const => _tag == Tag.playerToggleSprintEvent;
  ///ditto
  alias getPlayerToggleSprintEvent = _get!(Tag.playerToggleSprintEvent);

  /++

  +/
  alias inventoryClickEvent = _create!(Tag.inventoryClickEvent);
  /// ditto
  pragma(inline, true) bool isInventoryClickEvent() const => _tag == Tag.inventoryClickEvent;
  ///ditto
  alias getInventoryClickEvent = _get!(Tag.inventoryClickEvent);

  /++

  +/
  alias inventoryCloseEvent = _create!(Tag.inventoryCloseEvent);
  /// ditto
  pragma(inline, true) bool isInventoryCloseEvent() const => _tag == Tag.inventoryCloseEvent;
  ///ditto
  alias getInventoryCloseEvent = _get!(Tag.inventoryCloseEvent);

  /++

  +/
  alias blockRedstoneEvent = _create!(Tag.blockRedstoneEvent);
  /// ditto
  pragma(inline, true) bool isBlockRedstoneEvent() const => _tag == Tag.blockRedstoneEvent;
  ///ditto
  alias getBlockRedstoneEvent = _get!(Tag.blockRedstoneEvent);

  /++

  +/
  alias blockBreakEvent = _create!(Tag.blockBreakEvent);
  /// ditto
  pragma(inline, true) bool isBlockBreakEvent() const => _tag == Tag.blockBreakEvent;
  ///ditto
  alias getBlockBreakEvent = _get!(Tag.blockBreakEvent);

  /++

  +/
  alias blockBurnEvent = _create!(Tag.blockBurnEvent);
  /// ditto
  pragma(inline, true) bool isBlockBurnEvent() const => _tag == Tag.blockBurnEvent;
  ///ditto
  alias getBlockBurnEvent = _get!(Tag.blockBurnEvent);

  /++

  +/
  alias blockCanBuildEvent = _create!(Tag.blockCanBuildEvent);
  /// ditto
  pragma(inline, true) bool isBlockCanBuildEvent() const => _tag == Tag.blockCanBuildEvent;
  ///ditto
  alias getBlockCanBuildEvent = _get!(Tag.blockCanBuildEvent);

  /++

  +/
  alias blockGrowEvent = _create!(Tag.blockGrowEvent);
  /// ditto
  pragma(inline, true) bool isBlockGrowEvent() const => _tag == Tag.blockGrowEvent;
  ///ditto
  alias getBlockGrowEvent = _get!(Tag.blockGrowEvent);

  /++

  +/
  alias blockPlaceEvent = _create!(Tag.blockPlaceEvent);
  /// ditto
  pragma(inline, true) bool isBlockPlaceEvent() const => _tag == Tag.blockPlaceEvent;
  ///ditto
  alias getBlockPlaceEvent = _get!(Tag.blockPlaceEvent);

  /++

  +/
  alias dialogClickActionEvent = _create!(Tag.dialogClickActionEvent);
  /// ditto
  pragma(inline, true) bool isDialogClickActionEvent() const => _tag == Tag.dialogClickActionEvent;
  ///ditto
  alias getDialogClickActionEvent = _get!(Tag.dialogClickActionEvent);

  /++

  +/
  alias dialogShowEvent = _create!(Tag.dialogShowEvent);
  /// ditto
  pragma(inline, true) bool isDialogShowEvent() const => _tag == Tag.dialogShowEvent;
  ///ditto
  alias getDialogShowEvent = _get!(Tag.dialogShowEvent);

  /++

  +/
  alias dialogClearEvent = _create!(Tag.dialogClearEvent);
  /// ditto
  pragma(inline, true) bool isDialogClearEvent() const => _tag == Tag.dialogClearEvent;
  ///ditto
  alias getDialogClearEvent = _get!(Tag.dialogClearEvent);

  /++

  +/
  alias bedrockFormResponseEvent = _create!(Tag.bedrockFormResponseEvent);
  /// ditto
  pragma(inline, true) bool isBedrockFormResponseEvent() const => _tag == Tag.bedrockFormResponseEvent;
  ///ditto
  alias getBedrockFormResponseEvent = _get!(Tag.bedrockFormResponseEvent);

  /++

  +/
  alias serverCommandEvent = _create!(Tag.serverCommandEvent);
  /// ditto
  pragma(inline, true) bool isServerCommandEvent() const => _tag == Tag.serverCommandEvent;
  ///ditto
  alias getServerCommandEvent = _get!(Tag.serverCommandEvent);

  /++

  +/
  alias serverListPingEvent = _create!(Tag.serverListPingEvent);
  /// ditto
  pragma(inline, true) bool isServerListPingEvent() const => _tag == Tag.serverListPingEvent;
  ///ditto
  alias getServerListPingEvent = _get!(Tag.serverListPingEvent);

  /++

  +/
  alias serverLoadEvent = _create!(Tag.serverLoadEvent);
  /// ditto
  pragma(inline, true) bool isServerLoadEvent() const => _tag == Tag.serverLoadEvent;
  ///ditto
  alias getServerLoadEvent = _get!(Tag.serverLoadEvent);

  /++

  +/
  alias spawnChangeEvent = _create!(Tag.spawnChangeEvent);
  /// ditto
  pragma(inline, true) bool isSpawnChangeEvent() const => _tag == Tag.spawnChangeEvent;
  ///ditto
  alias getSpawnChangeEvent = _get!(Tag.spawnChangeEvent);

  /++

  +/
  alias serverBroadcastEvent = _create!(Tag.serverBroadcastEvent);
  /// ditto
  pragma(inline, true) bool isServerBroadcastEvent() const => _tag == Tag.serverBroadcastEvent;
  ///ditto
  alias getServerBroadcastEvent = _get!(Tag.serverBroadcastEvent);

  /++

  +/
  alias serverTickStartEvent = _create!(Tag.serverTickStartEvent);
  /// ditto
  pragma(inline, true) bool isServerTickStartEvent() const => _tag == Tag.serverTickStartEvent;
  ///ditto
  alias getServerTickStartEvent = _get!(Tag.serverTickStartEvent);

  /++

  +/
  alias serverTickEndEvent = _create!(Tag.serverTickEndEvent);
  /// ditto
  pragma(inline, true) bool isServerTickEndEvent() const => _tag == Tag.serverTickEndEvent;
  ///ditto
  alias getServerTickEndEvent = _get!(Tag.serverTickEndEvent);

  /++

  +/
  alias packetReceivedEvent = _create!(Tag.packetReceivedEvent);
  /// ditto
  pragma(inline, true) bool isPacketReceivedEvent() const => _tag == Tag.packetReceivedEvent;
  ///ditto
  alias getPacketReceivedEvent = _get!(Tag.packetReceivedEvent);

  /++

  +/
  alias packetSentEvent = _create!(Tag.packetSentEvent);
  /// ditto
  pragma(inline, true) bool isPacketSentEvent() const => _tag == Tag.packetSentEvent;
  ///ditto
  alias getPacketSentEvent = _get!(Tag.packetSentEvent);

  /++

  +/
  alias chunkLoadEvent = _create!(Tag.chunkLoadEvent);
  /// ditto
  pragma(inline, true) bool isChunkLoadEvent() const => _tag == Tag.chunkLoadEvent;
  ///ditto
  alias getChunkLoadEvent = _get!(Tag.chunkLoadEvent);

  /++

  +/
  alias chunkSaveEvent = _create!(Tag.chunkSaveEvent);
  /// ditto
  pragma(inline, true) bool isChunkSaveEvent() const => _tag == Tag.chunkSaveEvent;
  ///ditto
  alias getChunkSaveEvent = _get!(Tag.chunkSaveEvent);

  /++

  +/
  alias chunkSendEvent = _create!(Tag.chunkSendEvent);
  /// ditto
  pragma(inline, true) bool isChunkSendEvent() const => _tag == Tag.chunkSendEvent;
  ///ditto
  alias getChunkSendEvent = _get!(Tag.chunkSendEvent);

  /++

  +/
  alias entityDamageEvent = _create!(Tag.entityDamageEvent);
  /// ditto
  pragma(inline, true) bool isEntityDamageEvent() const => _tag == Tag.entityDamageEvent;
  ///ditto
  alias getEntityDamageEvent = _get!(Tag.entityDamageEvent);

  /++

  +/
  alias entityDeathEvent = _create!(Tag.entityDeathEvent);
  /// ditto
  pragma(inline, true) bool isEntityDeathEvent() const => _tag == Tag.entityDeathEvent;
  ///ditto
  alias getEntityDeathEvent = _get!(Tag.entityDeathEvent);

  /++

  +/
  alias playerDeathEvent = _create!(Tag.playerDeathEvent);
  /// ditto
  pragma(inline, true) bool isPlayerDeathEvent() const => _tag == Tag.playerDeathEvent;
  ///ditto
  alias getPlayerDeathEvent = _get!(Tag.playerDeathEvent);

  /++

  +/
  alias entitySpawnEvent = _create!(Tag.entitySpawnEvent);
  /// ditto
  pragma(inline, true) bool isEntitySpawnEvent() const => _tag == Tag.entitySpawnEvent;
  ///ditto
  alias getEntitySpawnEvent = _get!(Tag.entitySpawnEvent);

  /++

  +/
  alias entityCombustEvent = _create!(Tag.entityCombustEvent);
  /// ditto
  pragma(inline, true) bool isEntityCombustEvent() const => _tag == Tag.entityCombustEvent;
  ///ditto
  alias getEntityCombustEvent = _get!(Tag.entityCombustEvent);

  /++

  +/
  alias entityRegainHealthEvent = _create!(Tag.entityRegainHealthEvent);
  /// ditto
  pragma(inline, true) bool isEntityRegainHealthEvent() const => _tag == Tag.entityRegainHealthEvent;
  ///ditto
  alias getEntityRegainHealthEvent = _get!(Tag.entityRegainHealthEvent);

  /++

  +/
  alias entityAirChangeEvent = _create!(Tag.entityAirChangeEvent);
  /// ditto
  pragma(inline, true) bool isEntityAirChangeEvent() const => _tag == Tag.entityAirChangeEvent;
  ///ditto
  alias getEntityAirChangeEvent = _get!(Tag.entityAirChangeEvent);

  /++

  +/
  alias entityBreedEvent = _create!(Tag.entityBreedEvent);
  /// ditto
  pragma(inline, true) bool isEntityBreedEvent() const => _tag == Tag.entityBreedEvent;
  ///ditto
  alias getEntityBreedEvent = _get!(Tag.entityBreedEvent);

  /++

  +/
  alias entityDismountEvent = _create!(Tag.entityDismountEvent);
  /// ditto
  pragma(inline, true) bool isEntityDismountEvent() const => _tag == Tag.entityDismountEvent;
  ///ditto
  alias getEntityDismountEvent = _get!(Tag.entityDismountEvent);

  /++

  +/
  alias entityDyeEvent = _create!(Tag.entityDyeEvent);
  /// ditto
  pragma(inline, true) bool isEntityDyeEvent() const => _tag == Tag.entityDyeEvent;
  ///ditto
  alias getEntityDyeEvent = _get!(Tag.entityDyeEvent);

  /++

  +/
  alias entityEnterLoveModeEvent = _create!(Tag.entityEnterLoveModeEvent);
  /// ditto
  pragma(inline, true) bool isEntityEnterLoveModeEvent() const => _tag == Tag.entityEnterLoveModeEvent;
  ///ditto
  alias getEntityEnterLoveModeEvent = _get!(Tag.entityEnterLoveModeEvent);

  /++

  +/
  alias entityExplodeEvent = _create!(Tag.entityExplodeEvent);
  /// ditto
  pragma(inline, true) bool isEntityExplodeEvent() const => _tag == Tag.entityExplodeEvent;
  ///ditto
  alias getEntityExplodeEvent = _get!(Tag.entityExplodeEvent);

  /++

  +/
  alias entityMountEvent = _create!(Tag.entityMountEvent);
  /// ditto
  pragma(inline, true) bool isEntityMountEvent() const => _tag == Tag.entityMountEvent;
  ///ditto
  alias getEntityMountEvent = _get!(Tag.entityMountEvent);

  /++

  +/
  alias entityPickupItemEvent = _create!(Tag.entityPickupItemEvent);
  /// ditto
  pragma(inline, true) bool isEntityPickupItemEvent() const => _tag == Tag.entityPickupItemEvent;
  ///ditto
  alias getEntityPickupItemEvent = _get!(Tag.entityPickupItemEvent);

  /++

  +/
  alias entityPortalEvent = _create!(Tag.entityPortalEvent);
  /// ditto
  pragma(inline, true) bool isEntityPortalEvent() const => _tag == Tag.entityPortalEvent;
  ///ditto
  alias getEntityPortalEvent = _get!(Tag.entityPortalEvent);

  /++

  +/
  alias entityResurrectEvent = _create!(Tag.entityResurrectEvent);
  /// ditto
  pragma(inline, true) bool isEntityResurrectEvent() const => _tag == Tag.entityResurrectEvent;
  ///ditto
  alias getEntityResurrectEvent = _get!(Tag.entityResurrectEvent);

  /++

  +/
  alias entityShootBowEvent = _create!(Tag.entityShootBowEvent);
  /// ditto
  pragma(inline, true) bool isEntityShootBowEvent() const => _tag == Tag.entityShootBowEvent;
  ///ditto
  alias getEntityShootBowEvent = _get!(Tag.entityShootBowEvent);

  /++

  +/
  alias entityTameEvent = _create!(Tag.entityTameEvent);
  /// ditto
  pragma(inline, true) bool isEntityTameEvent() const => _tag == Tag.entityTameEvent;
  ///ditto
  alias getEntityTameEvent = _get!(Tag.entityTameEvent);

  /++

  +/
  alias entityTargetEvent = _create!(Tag.entityTargetEvent);
  /// ditto
  pragma(inline, true) bool isEntityTargetEvent() const => _tag == Tag.entityTargetEvent;
  ///ditto
  alias getEntityTargetEvent = _get!(Tag.entityTargetEvent);

  /++

  +/
  alias entityTeleportEvent = _create!(Tag.entityTeleportEvent);
  /// ditto
  pragma(inline, true) bool isEntityTeleportEvent() const => _tag == Tag.entityTeleportEvent;
  ///ditto
  alias getEntityTeleportEvent = _get!(Tag.entityTeleportEvent);

  /++

  +/
  alias entityToggleGlideEvent = _create!(Tag.entityToggleGlideEvent);
  /// ditto
  pragma(inline, true) bool isEntityToggleGlideEvent() const => _tag == Tag.entityToggleGlideEvent;
  ///ditto
  alias getEntityToggleGlideEvent = _get!(Tag.entityToggleGlideEvent);

  /++

  +/
  alias entityTransformEvent = _create!(Tag.entityTransformEvent);
  /// ditto
  pragma(inline, true) bool isEntityTransformEvent() const => _tag == Tag.entityTransformEvent;
  ///ditto
  alias getEntityTransformEvent = _get!(Tag.entityTransformEvent);

  /++

  +/
  alias playerItemConsumeEvent = _create!(Tag.playerItemConsumeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerItemConsumeEvent() const => _tag == Tag.playerItemConsumeEvent;
  ///ditto
  alias getPlayerItemConsumeEvent = _get!(Tag.playerItemConsumeEvent);

  /++

  +/
  alias playerItemDamageEvent = _create!(Tag.playerItemDamageEvent);
  /// ditto
  pragma(inline, true) bool isPlayerItemDamageEvent() const => _tag == Tag.playerItemDamageEvent;
  ///ditto
  alias getPlayerItemDamageEvent = _get!(Tag.playerItemDamageEvent);

  /++

  +/
  alias playerDropItemEvent = _create!(Tag.playerDropItemEvent);
  /// ditto
  pragma(inline, true) bool isPlayerDropItemEvent() const => _tag == Tag.playerDropItemEvent;
  ///ditto
  alias getPlayerDropItemEvent = _get!(Tag.playerDropItemEvent);

  /++

  +/
  alias playerBedEnterEvent = _create!(Tag.playerBedEnterEvent);
  /// ditto
  pragma(inline, true) bool isPlayerBedEnterEvent() const => _tag == Tag.playerBedEnterEvent;
  ///ditto
  alias getPlayerBedEnterEvent = _get!(Tag.playerBedEnterEvent);

  /++

  +/
  alias playerBedLeaveEvent = _create!(Tag.playerBedLeaveEvent);
  /// ditto
  pragma(inline, true) bool isPlayerBedLeaveEvent() const => _tag == Tag.playerBedLeaveEvent;
  ///ditto
  alias getPlayerBedLeaveEvent = _get!(Tag.playerBedLeaveEvent);

  /++

  +/
  alias playerBucketEmptyEvent = _create!(Tag.playerBucketEmptyEvent);
  /// ditto
  pragma(inline, true) bool isPlayerBucketEmptyEvent() const => _tag == Tag.playerBucketEmptyEvent;
  ///ditto
  alias getPlayerBucketEmptyEvent = _get!(Tag.playerBucketEmptyEvent);

  /++

  +/
  alias playerBucketFillEvent = _create!(Tag.playerBucketFillEvent);
  /// ditto
  pragma(inline, true) bool isPlayerBucketFillEvent() const => _tag == Tag.playerBucketFillEvent;
  ///ditto
  alias getPlayerBucketFillEvent = _get!(Tag.playerBucketFillEvent);

  /++

  +/
  alias blockDamageEvent = _create!(Tag.blockDamageEvent);
  /// ditto
  pragma(inline, true) bool isBlockDamageEvent() const => _tag == Tag.blockDamageEvent;
  ///ditto
  alias getBlockDamageEvent = _get!(Tag.blockDamageEvent);

  /++

  +/
  alias blockIgniteEvent = _create!(Tag.blockIgniteEvent);
  /// ditto
  pragma(inline, true) bool isBlockIgniteEvent() const => _tag == Tag.blockIgniteEvent;
  ///ditto
  alias getBlockIgniteEvent = _get!(Tag.blockIgniteEvent);

  /++

  +/
  alias blockFromToEvent = _create!(Tag.blockFromToEvent);
  /// ditto
  pragma(inline, true) bool isBlockFromToEvent() const => _tag == Tag.blockFromToEvent;
  ///ditto
  alias getBlockFromToEvent = _get!(Tag.blockFromToEvent);

  /++

  +/
  alias blockFormEvent = _create!(Tag.blockFormEvent);
  /// ditto
  pragma(inline, true) bool isBlockFormEvent() const => _tag == Tag.blockFormEvent;
  ///ditto
  alias getBlockFormEvent = _get!(Tag.blockFormEvent);

  /++

  +/
  alias blockFadeEvent = _create!(Tag.blockFadeEvent);
  /// ditto
  pragma(inline, true) bool isBlockFadeEvent() const => _tag == Tag.blockFadeEvent;
  ///ditto
  alias getBlockFadeEvent = _get!(Tag.blockFadeEvent);

  /++

  +/
  alias blockDispenseEvent = _create!(Tag.blockDispenseEvent);
  /// ditto
  pragma(inline, true) bool isBlockDispenseEvent() const => _tag == Tag.blockDispenseEvent;
  ///ditto
  alias getBlockDispenseEvent = _get!(Tag.blockDispenseEvent);

  /++

  +/
  alias blockExplodeEvent = _create!(Tag.blockExplodeEvent);
  /// ditto
  pragma(inline, true) bool isBlockExplodeEvent() const => _tag == Tag.blockExplodeEvent;
  ///ditto
  alias getBlockExplodeEvent = _get!(Tag.blockExplodeEvent);

  /++

  +/
  alias blockPhysicsEvent = _create!(Tag.blockPhysicsEvent);
  /// ditto
  pragma(inline, true) bool isBlockPhysicsEvent() const => _tag == Tag.blockPhysicsEvent;
  ///ditto
  alias getBlockPhysicsEvent = _get!(Tag.blockPhysicsEvent);

  /++

  +/
  alias blockPistonExtendEvent = _create!(Tag.blockPistonExtendEvent);
  /// ditto
  pragma(inline, true) bool isBlockPistonExtendEvent() const => _tag == Tag.blockPistonExtendEvent;
  ///ditto
  alias getBlockPistonExtendEvent = _get!(Tag.blockPistonExtendEvent);

  /++

  +/
  alias blockPistonRetractEvent = _create!(Tag.blockPistonRetractEvent);
  /// ditto
  pragma(inline, true) bool isBlockPistonRetractEvent() const => _tag == Tag.blockPistonRetractEvent;
  ///ditto
  alias getBlockPistonRetractEvent = _get!(Tag.blockPistonRetractEvent);

  /++

  +/
  alias notePlayEvent = _create!(Tag.notePlayEvent);
  /// ditto
  pragma(inline, true) bool isNotePlayEvent() const => _tag == Tag.notePlayEvent;
  ///ditto
  alias getNotePlayEvent = _get!(Tag.notePlayEvent);

  /++

  +/
  alias signChangeEvent = _create!(Tag.signChangeEvent);
  /// ditto
  pragma(inline, true) bool isSignChangeEvent() const => _tag == Tag.signChangeEvent;
  ///ditto
  alias getSignChangeEvent = _get!(Tag.signChangeEvent);

  /++

  +/
  alias spongeAbsorbEvent = _create!(Tag.spongeAbsorbEvent);
  /// ditto
  pragma(inline, true) bool isSpongeAbsorbEvent() const => _tag == Tag.spongeAbsorbEvent;
  ///ditto
  alias getSpongeAbsorbEvent = _get!(Tag.spongeAbsorbEvent);

  /++

  +/
  alias tntPrimeEvent = _create!(Tag.tntPrimeEvent);
  /// ditto
  pragma(inline, true) bool isTntPrimeEvent() const => _tag == Tag.tntPrimeEvent;
  ///ditto
  alias getTntPrimeEvent = _get!(Tag.tntPrimeEvent);

  /++

  +/
  alias weatherChangeEvent = _create!(Tag.weatherChangeEvent);
  /// ditto
  pragma(inline, true) bool isWeatherChangeEvent() const => _tag == Tag.weatherChangeEvent;
  ///ditto
  alias getWeatherChangeEvent = _get!(Tag.weatherChangeEvent);

  /++

  +/
  alias thunderChangeEvent = _create!(Tag.thunderChangeEvent);
  /// ditto
  pragma(inline, true) bool isThunderChangeEvent() const => _tag == Tag.thunderChangeEvent;
  ///ditto
  alias getThunderChangeEvent = _get!(Tag.thunderChangeEvent);

  /++

  +/
  alias worldLoadEvent = _create!(Tag.worldLoadEvent);
  /// ditto
  pragma(inline, true) bool isWorldLoadEvent() const => _tag == Tag.worldLoadEvent;
  ///ditto
  alias getWorldLoadEvent = _get!(Tag.worldLoadEvent);

  /++

  +/
  alias worldUnloadEvent = _create!(Tag.worldUnloadEvent);
  /// ditto
  pragma(inline, true) bool isWorldUnloadEvent() const => _tag == Tag.worldUnloadEvent;
  ///ditto
  alias getWorldUnloadEvent = _get!(Tag.worldUnloadEvent);

  /++

  +/
  alias asyncStructureGenerateEvent = _create!(Tag.asyncStructureGenerateEvent);
  /// ditto
  pragma(inline, true) bool isAsyncStructureGenerateEvent() const => _tag == Tag.asyncStructureGenerateEvent;
  ///ditto
  alias getAsyncStructureGenerateEvent = _get!(Tag.asyncStructureGenerateEvent);

  /++

  +/
  alias asyncStructureSpawnEvent = _create!(Tag.asyncStructureSpawnEvent);
  /// ditto
  pragma(inline, true) bool isAsyncStructureSpawnEvent() const => _tag == Tag.asyncStructureSpawnEvent;
  ///ditto
  alias getAsyncStructureSpawnEvent = _get!(Tag.asyncStructureSpawnEvent);

  /++

  +/
  alias chunkPopulateEvent = _create!(Tag.chunkPopulateEvent);
  /// ditto
  pragma(inline, true) bool isChunkPopulateEvent() const => _tag == Tag.chunkPopulateEvent;
  ///ditto
  alias getChunkPopulateEvent = _get!(Tag.chunkPopulateEvent);

  /++

  +/
  alias chunkUnloadEvent = _create!(Tag.chunkUnloadEvent);
  /// ditto
  pragma(inline, true) bool isChunkUnloadEvent() const => _tag == Tag.chunkUnloadEvent;
  ///ditto
  alias getChunkUnloadEvent = _get!(Tag.chunkUnloadEvent);

  /++

  +/
  alias entitiesLoadEvent = _create!(Tag.entitiesLoadEvent);
  /// ditto
  pragma(inline, true) bool isEntitiesLoadEvent() const => _tag == Tag.entitiesLoadEvent;
  ///ditto
  alias getEntitiesLoadEvent = _get!(Tag.entitiesLoadEvent);

  /++

  +/
  alias entitiesUnloadEvent = _create!(Tag.entitiesUnloadEvent);
  /// ditto
  pragma(inline, true) bool isEntitiesUnloadEvent() const => _tag == Tag.entitiesUnloadEvent;
  ///ditto
  alias getEntitiesUnloadEvent = _get!(Tag.entitiesUnloadEvent);

  /++

  +/
  alias genericGameEvent = _create!(Tag.genericGameEvent);
  /// ditto
  pragma(inline, true) bool isGenericGameEvent() const => _tag == Tag.genericGameEvent;
  ///ditto
  alias getGenericGameEvent = _get!(Tag.genericGameEvent);

  /++

  +/
  alias lootGenerateEvent = _create!(Tag.lootGenerateEvent);
  /// ditto
  pragma(inline, true) bool isLootGenerateEvent() const => _tag == Tag.lootGenerateEvent;
  ///ditto
  alias getLootGenerateEvent = _get!(Tag.lootGenerateEvent);

  /++

  +/
  alias portalCreateEvent = _create!(Tag.portalCreateEvent);
  /// ditto
  pragma(inline, true) bool isPortalCreateEvent() const => _tag == Tag.portalCreateEvent;
  ///ditto
  alias getPortalCreateEvent = _get!(Tag.portalCreateEvent);

  /++

  +/
  alias structureGrowEvent = _create!(Tag.structureGrowEvent);
  /// ditto
  pragma(inline, true) bool isStructureGrowEvent() const => _tag == Tag.structureGrowEvent;
  ///ditto
  alias getStructureGrowEvent = _get!(Tag.structureGrowEvent);

  /++

  +/
  alias timeSkipEvent = _create!(Tag.timeSkipEvent);
  /// ditto
  pragma(inline, true) bool isTimeSkipEvent() const => _tag == Tag.timeSkipEvent;
  ///ditto
  alias getTimeSkipEvent = _get!(Tag.timeSkipEvent);

  /++

  +/
  alias worldInitEvent = _create!(Tag.worldInitEvent);
  /// ditto
  pragma(inline, true) bool isWorldInitEvent() const => _tag == Tag.worldInitEvent;
  ///ditto
  alias getWorldInitEvent = _get!(Tag.worldInitEvent);

  /++

  +/
  alias worldSaveEvent = _create!(Tag.worldSaveEvent);
  /// ditto
  pragma(inline, true) bool isWorldSaveEvent() const => _tag == Tag.worldSaveEvent;
  ///ditto
  alias getWorldSaveEvent = _get!(Tag.worldSaveEvent);

  /++

  +/
  alias inventoryOpenEvent = _create!(Tag.inventoryOpenEvent);
  /// ditto
  pragma(inline, true) bool isInventoryOpenEvent() const => _tag == Tag.inventoryOpenEvent;
  ///ditto
  alias getInventoryOpenEvent = _get!(Tag.inventoryOpenEvent);

  /++

  +/
  alias inventoryDragEvent = _create!(Tag.inventoryDragEvent);
  /// ditto
  pragma(inline, true) bool isInventoryDragEvent() const => _tag == Tag.inventoryDragEvent;
  ///ditto
  alias getInventoryDragEvent = _get!(Tag.inventoryDragEvent);

  /++

  +/
  alias craftItemEvent = _create!(Tag.craftItemEvent);
  /// ditto
  pragma(inline, true) bool isCraftItemEvent() const => _tag == Tag.craftItemEvent;
  ///ditto
  alias getCraftItemEvent = _get!(Tag.craftItemEvent);

  /++

  +/
  alias furnaceSmeltEvent = _create!(Tag.furnaceSmeltEvent);
  /// ditto
  pragma(inline, true) bool isFurnaceSmeltEvent() const => _tag == Tag.furnaceSmeltEvent;
  ///ditto
  alias getFurnaceSmeltEvent = _get!(Tag.furnaceSmeltEvent);

  /++

  +/
  alias brewEvent = _create!(Tag.brewEvent);
  /// ditto
  pragma(inline, true) bool isBrewEvent() const => _tag == Tag.brewEvent;
  ///ditto
  alias getBrewEvent = _get!(Tag.brewEvent);

  /++

  +/
  alias brewingStandFuelEvent = _create!(Tag.brewingStandFuelEvent);
  /// ditto
  pragma(inline, true) bool isBrewingStandFuelEvent() const => _tag == Tag.brewingStandFuelEvent;
  ///ditto
  alias getBrewingStandFuelEvent = _get!(Tag.brewingStandFuelEvent);

  /++

  +/
  alias furnaceBurnEvent = _create!(Tag.furnaceBurnEvent);
  /// ditto
  pragma(inline, true) bool isFurnaceBurnEvent() const => _tag == Tag.furnaceBurnEvent;
  ///ditto
  alias getFurnaceBurnEvent = _get!(Tag.furnaceBurnEvent);

  /++

  +/
  alias furnaceExtractEvent = _create!(Tag.furnaceExtractEvent);
  /// ditto
  pragma(inline, true) bool isFurnaceExtractEvent() const => _tag == Tag.furnaceExtractEvent;
  ///ditto
  alias getFurnaceExtractEvent = _get!(Tag.furnaceExtractEvent);

  /++

  +/
  alias furnaceStartSmeltEvent = _create!(Tag.furnaceStartSmeltEvent);
  /// ditto
  pragma(inline, true) bool isFurnaceStartSmeltEvent() const => _tag == Tag.furnaceStartSmeltEvent;
  ///ditto
  alias getFurnaceStartSmeltEvent = _get!(Tag.furnaceStartSmeltEvent);

  /++

  +/
  alias hopperInventorySearchEvent = _create!(Tag.hopperInventorySearchEvent);
  /// ditto
  pragma(inline, true) bool isHopperInventorySearchEvent() const => _tag == Tag.hopperInventorySearchEvent;
  ///ditto
  alias getHopperInventorySearchEvent = _get!(Tag.hopperInventorySearchEvent);

  /++

  +/
  alias inventoryCreativeEvent = _create!(Tag.inventoryCreativeEvent);
  /// ditto
  pragma(inline, true) bool isInventoryCreativeEvent() const => _tag == Tag.inventoryCreativeEvent;
  ///ditto
  alias getInventoryCreativeEvent = _get!(Tag.inventoryCreativeEvent);

  /++

  +/
  alias inventoryInteractEvent = _create!(Tag.inventoryInteractEvent);
  /// ditto
  pragma(inline, true) bool isInventoryInteractEvent() const => _tag == Tag.inventoryInteractEvent;
  ///ditto
  alias getInventoryInteractEvent = _get!(Tag.inventoryInteractEvent);

  /++

  +/
  alias inventoryMoveItemEvent = _create!(Tag.inventoryMoveItemEvent);
  /// ditto
  pragma(inline, true) bool isInventoryMoveItemEvent() const => _tag == Tag.inventoryMoveItemEvent;
  ///ditto
  alias getInventoryMoveItemEvent = _get!(Tag.inventoryMoveItemEvent);

  /++

  +/
  alias inventoryPickupItemEvent = _create!(Tag.inventoryPickupItemEvent);
  /// ditto
  pragma(inline, true) bool isInventoryPickupItemEvent() const => _tag == Tag.inventoryPickupItemEvent;
  ///ditto
  alias getInventoryPickupItemEvent = _get!(Tag.inventoryPickupItemEvent);

  /++

  +/
  alias prepareAnvilEvent = _create!(Tag.prepareAnvilEvent);
  /// ditto
  pragma(inline, true) bool isPrepareAnvilEvent() const => _tag == Tag.prepareAnvilEvent;
  ///ditto
  alias getPrepareAnvilEvent = _get!(Tag.prepareAnvilEvent);

  /++

  +/
  alias prepareGrindstoneEvent = _create!(Tag.prepareGrindstoneEvent);
  /// ditto
  pragma(inline, true) bool isPrepareGrindstoneEvent() const => _tag == Tag.prepareGrindstoneEvent;
  ///ditto
  alias getPrepareGrindstoneEvent = _get!(Tag.prepareGrindstoneEvent);

  /++

  +/
  alias prepareInventoryResultEvent = _create!(Tag.prepareInventoryResultEvent);
  /// ditto
  pragma(inline, true) bool isPrepareInventoryResultEvent() const => _tag == Tag.prepareInventoryResultEvent;
  ///ditto
  alias getPrepareInventoryResultEvent = _get!(Tag.prepareInventoryResultEvent);

  /++

  +/
  alias prepareItemCraftEvent = _create!(Tag.prepareItemCraftEvent);
  /// ditto
  pragma(inline, true) bool isPrepareItemCraftEvent() const => _tag == Tag.prepareItemCraftEvent;
  ///ditto
  alias getPrepareItemCraftEvent = _get!(Tag.prepareItemCraftEvent);

  /++

  +/
  alias prepareSmithingEvent = _create!(Tag.prepareSmithingEvent);
  /// ditto
  pragma(inline, true) bool isPrepareSmithingEvent() const => _tag == Tag.prepareSmithingEvent;
  ///ditto
  alias getPrepareSmithingEvent = _get!(Tag.prepareSmithingEvent);

  /++

  +/
  alias smithItemEvent = _create!(Tag.smithItemEvent);
  /// ditto
  pragma(inline, true) bool isSmithItemEvent() const => _tag == Tag.smithItemEvent;
  ///ditto
  alias getSmithItemEvent = _get!(Tag.smithItemEvent);

  /++

  +/
  alias tradeSelectEvent = _create!(Tag.tradeSelectEvent);
  /// ditto
  pragma(inline, true) bool isTradeSelectEvent() const => _tag == Tag.tradeSelectEvent;
  ///ditto
  alias getTradeSelectEvent = _get!(Tag.tradeSelectEvent);

  /++

  +/
  alias vehicleBlockCollisionEvent = _create!(Tag.vehicleBlockCollisionEvent);
  /// ditto
  pragma(inline, true) bool isVehicleBlockCollisionEvent() const => _tag == Tag.vehicleBlockCollisionEvent;
  ///ditto
  alias getVehicleBlockCollisionEvent = _get!(Tag.vehicleBlockCollisionEvent);

  /++

  +/
  alias vehicleCollisionEvent = _create!(Tag.vehicleCollisionEvent);
  /// ditto
  pragma(inline, true) bool isVehicleCollisionEvent() const => _tag == Tag.vehicleCollisionEvent;
  ///ditto
  alias getVehicleCollisionEvent = _get!(Tag.vehicleCollisionEvent);

  /++

  +/
  alias vehicleCreateEvent = _create!(Tag.vehicleCreateEvent);
  /// ditto
  pragma(inline, true) bool isVehicleCreateEvent() const => _tag == Tag.vehicleCreateEvent;
  ///ditto
  alias getVehicleCreateEvent = _get!(Tag.vehicleCreateEvent);

  /++

  +/
  alias vehicleDamageEvent = _create!(Tag.vehicleDamageEvent);
  /// ditto
  pragma(inline, true) bool isVehicleDamageEvent() const => _tag == Tag.vehicleDamageEvent;
  ///ditto
  alias getVehicleDamageEvent = _get!(Tag.vehicleDamageEvent);

  /++

  +/
  alias vehicleDestroyEvent = _create!(Tag.vehicleDestroyEvent);
  /// ditto
  pragma(inline, true) bool isVehicleDestroyEvent() const => _tag == Tag.vehicleDestroyEvent;
  ///ditto
  alias getVehicleDestroyEvent = _get!(Tag.vehicleDestroyEvent);

  /++

  +/
  alias vehicleEnterEvent = _create!(Tag.vehicleEnterEvent);
  /// ditto
  pragma(inline, true) bool isVehicleEnterEvent() const => _tag == Tag.vehicleEnterEvent;
  ///ditto
  alias getVehicleEnterEvent = _get!(Tag.vehicleEnterEvent);

  /++

  +/
  alias vehicleEntityCollisionEvent = _create!(Tag.vehicleEntityCollisionEvent);
  /// ditto
  pragma(inline, true) bool isVehicleEntityCollisionEvent() const => _tag == Tag.vehicleEntityCollisionEvent;
  ///ditto
  alias getVehicleEntityCollisionEvent = _get!(Tag.vehicleEntityCollisionEvent);

  /++

  +/
  alias vehicleExitEvent = _create!(Tag.vehicleExitEvent);
  /// ditto
  pragma(inline, true) bool isVehicleExitEvent() const => _tag == Tag.vehicleExitEvent;
  ///ditto
  alias getVehicleExitEvent = _get!(Tag.vehicleExitEvent);

  /++

  +/
  alias vehicleMoveEvent = _create!(Tag.vehicleMoveEvent);
  /// ditto
  pragma(inline, true) bool isVehicleMoveEvent() const => _tag == Tag.vehicleMoveEvent;
  ///ditto
  alias getVehicleMoveEvent = _get!(Tag.vehicleMoveEvent);

  /++

  +/
  alias vehicleUpdateEvent = _create!(Tag.vehicleUpdateEvent);
  /// ditto
  pragma(inline, true) bool isVehicleUpdateEvent() const => _tag == Tag.vehicleUpdateEvent;
  ///ditto
  alias getVehicleUpdateEvent = _get!(Tag.vehicleUpdateEvent);

  /++

  +/
  alias prepareItemEnchantEvent = _create!(Tag.prepareItemEnchantEvent);
  /// ditto
  pragma(inline, true) bool isPrepareItemEnchantEvent() const => _tag == Tag.prepareItemEnchantEvent;
  ///ditto
  alias getPrepareItemEnchantEvent = _get!(Tag.prepareItemEnchantEvent);

  /++

  +/
  alias enchantItemEvent = _create!(Tag.enchantItemEvent);
  /// ditto
  pragma(inline, true) bool isEnchantItemEvent() const => _tag == Tag.enchantItemEvent;
  ///ditto
  alias getEnchantItemEvent = _get!(Tag.enchantItemEvent);

  /++

  +/
  alias mapInitializeEvent = _create!(Tag.mapInitializeEvent);
  /// ditto
  pragma(inline, true) bool isMapInitializeEvent() const => _tag == Tag.mapInitializeEvent;
  ///ditto
  alias getMapInitializeEvent = _get!(Tag.mapInitializeEvent);

  /++

  +/
  alias hangingBreakEvent = _create!(Tag.hangingBreakEvent);
  /// ditto
  pragma(inline, true) bool isHangingBreakEvent() const => _tag == Tag.hangingBreakEvent;
  ///ditto
  alias getHangingBreakEvent = _get!(Tag.hangingBreakEvent);

  /++

  +/
  alias hangingBreakByEntityEvent = _create!(Tag.hangingBreakByEntityEvent);
  /// ditto
  pragma(inline, true) bool isHangingBreakByEntityEvent() const => _tag == Tag.hangingBreakByEntityEvent;
  ///ditto
  alias getHangingBreakByEntityEvent = _get!(Tag.hangingBreakByEntityEvent);

  /++

  +/
  alias hangingPlaceEvent = _create!(Tag.hangingPlaceEvent);
  /// ditto
  pragma(inline, true) bool isHangingPlaceEvent() const => _tag == Tag.hangingPlaceEvent;
  ///ditto
  alias getHangingPlaceEvent = _get!(Tag.hangingPlaceEvent);

  /++

  +/
  alias bellResonateEvent = _create!(Tag.bellResonateEvent);
  /// ditto
  pragma(inline, true) bool isBellResonateEvent() const => _tag == Tag.bellResonateEvent;
  ///ditto
  alias getBellResonateEvent = _get!(Tag.bellResonateEvent);

  /++

  +/
  alias bellRingEvent = _create!(Tag.bellRingEvent);
  /// ditto
  pragma(inline, true) bool isBellRingEvent() const => _tag == Tag.bellRingEvent;
  ///ditto
  alias getBellRingEvent = _get!(Tag.bellRingEvent);

  /++

  +/
  alias blockBrushEvent = _create!(Tag.blockBrushEvent);
  /// ditto
  pragma(inline, true) bool isBlockBrushEvent() const => _tag == Tag.blockBrushEvent;
  ///ditto
  alias getBlockBrushEvent = _get!(Tag.blockBrushEvent);

  /++

  +/
  alias blockCookEvent = _create!(Tag.blockCookEvent);
  /// ditto
  pragma(inline, true) bool isBlockCookEvent() const => _tag == Tag.blockCookEvent;
  ///ditto
  alias getBlockCookEvent = _get!(Tag.blockCookEvent);

  /++

  +/
  alias blockDamageAbortEvent = _create!(Tag.blockDamageAbortEvent);
  /// ditto
  pragma(inline, true) bool isBlockDamageAbortEvent() const => _tag == Tag.blockDamageAbortEvent;
  ///ditto
  alias getBlockDamageAbortEvent = _get!(Tag.blockDamageAbortEvent);

  /++

  +/
  alias blockDispenseArmorEvent = _create!(Tag.blockDispenseArmorEvent);
  /// ditto
  pragma(inline, true) bool isBlockDispenseArmorEvent() const => _tag == Tag.blockDispenseArmorEvent;
  ///ditto
  alias getBlockDispenseArmorEvent = _get!(Tag.blockDispenseArmorEvent);

  /++

  +/
  alias blockDispenseLootEvent = _create!(Tag.blockDispenseLootEvent);
  /// ditto
  pragma(inline, true) bool isBlockDispenseLootEvent() const => _tag == Tag.blockDispenseLootEvent;
  ///ditto
  alias getBlockDispenseLootEvent = _get!(Tag.blockDispenseLootEvent);

  /++

  +/
  alias blockDropItemEvent = _create!(Tag.blockDropItemEvent);
  /// ditto
  pragma(inline, true) bool isBlockDropItemEvent() const => _tag == Tag.blockDropItemEvent;
  ///ditto
  alias getBlockDropItemEvent = _get!(Tag.blockDropItemEvent);

  /++

  +/
  alias blockExpEvent = _create!(Tag.blockExpEvent);
  /// ditto
  pragma(inline, true) bool isBlockExpEvent() const => _tag == Tag.blockExpEvent;
  ///ditto
  alias getBlockExpEvent = _get!(Tag.blockExpEvent);

  /++

  +/
  alias blockFertilizeEvent = _create!(Tag.blockFertilizeEvent);
  /// ditto
  pragma(inline, true) bool isBlockFertilizeEvent() const => _tag == Tag.blockFertilizeEvent;
  ///ditto
  alias getBlockFertilizeEvent = _get!(Tag.blockFertilizeEvent);

  /++

  +/
  alias blockMultiPlaceEvent = _create!(Tag.blockMultiPlaceEvent);
  /// ditto
  pragma(inline, true) bool isBlockMultiPlaceEvent() const => _tag == Tag.blockMultiPlaceEvent;
  ///ditto
  alias getBlockMultiPlaceEvent = _get!(Tag.blockMultiPlaceEvent);

  /++

  +/
  alias blockReceiveGameEvent = _create!(Tag.blockReceiveGameEvent);
  /// ditto
  pragma(inline, true) bool isBlockReceiveGameEvent() const => _tag == Tag.blockReceiveGameEvent;
  ///ditto
  alias getBlockReceiveGameEvent = _get!(Tag.blockReceiveGameEvent);

  /++

  +/
  alias blockShearEntityEvent = _create!(Tag.blockShearEntityEvent);
  /// ditto
  pragma(inline, true) bool isBlockShearEntityEvent() const => _tag == Tag.blockShearEntityEvent;
  ///ditto
  alias getBlockShearEntityEvent = _get!(Tag.blockShearEntityEvent);

  /++

  +/
  alias blockSpreadEvent = _create!(Tag.blockSpreadEvent);
  /// ditto
  pragma(inline, true) bool isBlockSpreadEvent() const => _tag == Tag.blockSpreadEvent;
  ///ditto
  alias getBlockSpreadEvent = _get!(Tag.blockSpreadEvent);

  /++

  +/
  alias brewingStartEvent = _create!(Tag.brewingStartEvent);
  /// ditto
  pragma(inline, true) bool isBrewingStartEvent() const => _tag == Tag.brewingStartEvent;
  ///ditto
  alias getBrewingStartEvent = _get!(Tag.brewingStartEvent);

  /++

  +/
  alias campfireStartEvent = _create!(Tag.campfireStartEvent);
  /// ditto
  pragma(inline, true) bool isCampfireStartEvent() const => _tag == Tag.campfireStartEvent;
  ///ditto
  alias getCampfireStartEvent = _get!(Tag.campfireStartEvent);

  /++

  +/
  alias cauldronLevelChangeEvent = _create!(Tag.cauldronLevelChangeEvent);
  /// ditto
  pragma(inline, true) bool isCauldronLevelChangeEvent() const => _tag == Tag.cauldronLevelChangeEvent;
  ///ditto
  alias getCauldronLevelChangeEvent = _get!(Tag.cauldronLevelChangeEvent);

  /++

  +/
  alias crafterCraftEvent = _create!(Tag.crafterCraftEvent);
  /// ditto
  pragma(inline, true) bool isCrafterCraftEvent() const => _tag == Tag.crafterCraftEvent;
  ///ditto
  alias getCrafterCraftEvent = _get!(Tag.crafterCraftEvent);

  /++

  +/
  alias entityBlockFormEvent = _create!(Tag.entityBlockFormEvent);
  /// ditto
  pragma(inline, true) bool isEntityBlockFormEvent() const => _tag == Tag.entityBlockFormEvent;
  ///ditto
  alias getEntityBlockFormEvent = _get!(Tag.entityBlockFormEvent);

  /++

  +/
  alias fluidLevelChangeEvent = _create!(Tag.fluidLevelChangeEvent);
  /// ditto
  pragma(inline, true) bool isFluidLevelChangeEvent() const => _tag == Tag.fluidLevelChangeEvent;
  ///ditto
  alias getFluidLevelChangeEvent = _get!(Tag.fluidLevelChangeEvent);

  /++

  +/
  alias inventoryBlockStartEvent = _create!(Tag.inventoryBlockStartEvent);
  /// ditto
  pragma(inline, true) bool isInventoryBlockStartEvent() const => _tag == Tag.inventoryBlockStartEvent;
  ///ditto
  alias getInventoryBlockStartEvent = _get!(Tag.inventoryBlockStartEvent);

  /++

  +/
  alias leavesDecayEvent = _create!(Tag.leavesDecayEvent);
  /// ditto
  pragma(inline, true) bool isLeavesDecayEvent() const => _tag == Tag.leavesDecayEvent;
  ///ditto
  alias getLeavesDecayEvent = _get!(Tag.leavesDecayEvent);

  /++

  +/
  alias moistureChangeEvent = _create!(Tag.moistureChangeEvent);
  /// ditto
  pragma(inline, true) bool isMoistureChangeEvent() const => _tag == Tag.moistureChangeEvent;
  ///ditto
  alias getMoistureChangeEvent = _get!(Tag.moistureChangeEvent);

  /++

  +/
  alias sculkBloomEvent = _create!(Tag.sculkBloomEvent);
  /// ditto
  pragma(inline, true) bool isSculkBloomEvent() const => _tag == Tag.sculkBloomEvent;
  ///ditto
  alias getSculkBloomEvent = _get!(Tag.sculkBloomEvent);

  /++

  +/
  alias vaultDisplayItemEvent = _create!(Tag.vaultDisplayItemEvent);
  /// ditto
  pragma(inline, true) bool isVaultDisplayItemEvent() const => _tag == Tag.vaultDisplayItemEvent;
  ///ditto
  alias getVaultDisplayItemEvent = _get!(Tag.vaultDisplayItemEvent);

  /++

  +/
  alias creatureSpawnEvent = _create!(Tag.creatureSpawnEvent);
  /// ditto
  pragma(inline, true) bool isCreatureSpawnEvent() const => _tag == Tag.creatureSpawnEvent;
  ///ditto
  alias getCreatureSpawnEvent = _get!(Tag.creatureSpawnEvent);

  /++

  +/
  alias enderDragonChangePhaseEvent = _create!(Tag.enderDragonChangePhaseEvent);
  /// ditto
  pragma(inline, true) bool isEnderDragonChangePhaseEvent() const => _tag == Tag.enderDragonChangePhaseEvent;
  ///ditto
  alias getEnderDragonChangePhaseEvent = _get!(Tag.enderDragonChangePhaseEvent);

  /++

  +/
  alias entityBreakDoorEvent = _create!(Tag.entityBreakDoorEvent);
  /// ditto
  pragma(inline, true) bool isEntityBreakDoorEvent() const => _tag == Tag.entityBreakDoorEvent;
  ///ditto
  alias getEntityBreakDoorEvent = _get!(Tag.entityBreakDoorEvent);

  /++

  +/
  alias entityChangeBlockEvent = _create!(Tag.entityChangeBlockEvent);
  /// ditto
  pragma(inline, true) bool isEntityChangeBlockEvent() const => _tag == Tag.entityChangeBlockEvent;
  ///ditto
  alias getEntityChangeBlockEvent = _get!(Tag.entityChangeBlockEvent);

  /++

  +/
  alias entityDamageByBlockEvent = _create!(Tag.entityDamageByBlockEvent);
  /// ditto
  pragma(inline, true) bool isEntityDamageByBlockEvent() const => _tag == Tag.entityDamageByBlockEvent;
  ///ditto
  alias getEntityDamageByBlockEvent = _get!(Tag.entityDamageByBlockEvent);

  /++

  +/
  alias entityDamageByEntityEvent = _create!(Tag.entityDamageByEntityEvent);
  /// ditto
  pragma(inline, true) bool isEntityDamageByEntityEvent() const => _tag == Tag.entityDamageByEntityEvent;
  ///ditto
  alias getEntityDamageByEntityEvent = _get!(Tag.entityDamageByEntityEvent);

  /++

  +/
  alias entityDropItemEvent = _create!(Tag.entityDropItemEvent);
  /// ditto
  pragma(inline, true) bool isEntityDropItemEvent() const => _tag == Tag.entityDropItemEvent;
  ///ditto
  alias getEntityDropItemEvent = _get!(Tag.entityDropItemEvent);

  /++

  +/
  alias entityEnterBlockEvent = _create!(Tag.entityEnterBlockEvent);
  /// ditto
  pragma(inline, true) bool isEntityEnterBlockEvent() const => _tag == Tag.entityEnterBlockEvent;
  ///ditto
  alias getEntityEnterBlockEvent = _get!(Tag.entityEnterBlockEvent);

  /++

  +/
  alias entityExhaustionEvent = _create!(Tag.entityExhaustionEvent);
  /// ditto
  pragma(inline, true) bool isEntityExhaustionEvent() const => _tag == Tag.entityExhaustionEvent;
  ///ditto
  alias getEntityExhaustionEvent = _get!(Tag.entityExhaustionEvent);

  /++

  +/
  alias entityInteractEvent = _create!(Tag.entityInteractEvent);
  /// ditto
  pragma(inline, true) bool isEntityInteractEvent() const => _tag == Tag.entityInteractEvent;
  ///ditto
  alias getEntityInteractEvent = _get!(Tag.entityInteractEvent);

  /++

  +/
  alias entityKnockbackEvent = _create!(Tag.entityKnockbackEvent);
  /// ditto
  pragma(inline, true) bool isEntityKnockbackEvent() const => _tag == Tag.entityKnockbackEvent;
  ///ditto
  alias getEntityKnockbackEvent = _get!(Tag.entityKnockbackEvent);

  /++

  +/
  alias entityPlaceEvent = _create!(Tag.entityPlaceEvent);
  /// ditto
  pragma(inline, true) bool isEntityPlaceEvent() const => _tag == Tag.entityPlaceEvent;
  ///ditto
  alias getEntityPlaceEvent = _get!(Tag.entityPlaceEvent);

  /++

  +/
  alias entityPoseChangeEvent = _create!(Tag.entityPoseChangeEvent);
  /// ditto
  pragma(inline, true) bool isEntityPoseChangeEvent() const => _tag == Tag.entityPoseChangeEvent;
  ///ditto
  alias getEntityPoseChangeEvent = _get!(Tag.entityPoseChangeEvent);

  /++

  +/
  alias entityPotionEffectEvent = _create!(Tag.entityPotionEffectEvent);
  /// ditto
  pragma(inline, true) bool isEntityPotionEffectEvent() const => _tag == Tag.entityPotionEffectEvent;
  ///ditto
  alias getEntityPotionEffectEvent = _get!(Tag.entityPotionEffectEvent);

  /++

  +/
  alias entitySpellCastEvent = _create!(Tag.entitySpellCastEvent);
  /// ditto
  pragma(inline, true) bool isEntitySpellCastEvent() const => _tag == Tag.entitySpellCastEvent;
  ///ditto
  alias getEntitySpellCastEvent = _get!(Tag.entitySpellCastEvent);

  /++

  +/
  alias entityTargetLivingEntityEvent = _create!(Tag.entityTargetLivingEntityEvent);
  /// ditto
  pragma(inline, true) bool isEntityTargetLivingEntityEvent() const => _tag == Tag.entityTargetLivingEntityEvent;
  ///ditto
  alias getEntityTargetLivingEntityEvent = _get!(Tag.entityTargetLivingEntityEvent);

  /++

  +/
  alias entityToggleSwimEvent = _create!(Tag.entityToggleSwimEvent);
  /// ditto
  pragma(inline, true) bool isEntityToggleSwimEvent() const => _tag == Tag.entityToggleSwimEvent;
  ///ditto
  alias getEntityToggleSwimEvent = _get!(Tag.entityToggleSwimEvent);

  /++

  +/
  alias explosionPrimeEvent = _create!(Tag.explosionPrimeEvent);
  /// ditto
  pragma(inline, true) bool isExplosionPrimeEvent() const => _tag == Tag.explosionPrimeEvent;
  ///ditto
  alias getExplosionPrimeEvent = _get!(Tag.explosionPrimeEvent);

  /++

  +/
  alias fireworkExplodeEvent = _create!(Tag.fireworkExplodeEvent);
  /// ditto
  pragma(inline, true) bool isFireworkExplodeEvent() const => _tag == Tag.fireworkExplodeEvent;
  ///ditto
  alias getFireworkExplodeEvent = _get!(Tag.fireworkExplodeEvent);

  /++

  +/
  alias foodLevelChangeEvent = _create!(Tag.foodLevelChangeEvent);
  /// ditto
  pragma(inline, true) bool isFoodLevelChangeEvent() const => _tag == Tag.foodLevelChangeEvent;
  ///ditto
  alias getFoodLevelChangeEvent = _get!(Tag.foodLevelChangeEvent);

  /++

  +/
  alias itemDespawnEvent = _create!(Tag.itemDespawnEvent);
  /// ditto
  pragma(inline, true) bool isItemDespawnEvent() const => _tag == Tag.itemDespawnEvent;
  ///ditto
  alias getItemDespawnEvent = _get!(Tag.itemDespawnEvent);

  /++

  +/
  alias itemMergeEvent = _create!(Tag.itemMergeEvent);
  /// ditto
  pragma(inline, true) bool isItemMergeEvent() const => _tag == Tag.itemMergeEvent;
  ///ditto
  alias getItemMergeEvent = _get!(Tag.itemMergeEvent);

  /++

  +/
  alias itemSpawnEvent = _create!(Tag.itemSpawnEvent);
  /// ditto
  pragma(inline, true) bool isItemSpawnEvent() const => _tag == Tag.itemSpawnEvent;
  ///ditto
  alias getItemSpawnEvent = _get!(Tag.itemSpawnEvent);

  /++

  +/
  alias piglinBarterEvent = _create!(Tag.piglinBarterEvent);
  /// ditto
  pragma(inline, true) bool isPiglinBarterEvent() const => _tag == Tag.piglinBarterEvent;
  ///ditto
  alias getPiglinBarterEvent = _get!(Tag.piglinBarterEvent);

  /++

  +/
  alias projectileHitEvent = _create!(Tag.projectileHitEvent);
  /// ditto
  pragma(inline, true) bool isProjectileHitEvent() const => _tag == Tag.projectileHitEvent;
  ///ditto
  alias getProjectileHitEvent = _get!(Tag.projectileHitEvent);

  /++

  +/
  alias projectileLaunchEvent = _create!(Tag.projectileLaunchEvent);
  /// ditto
  pragma(inline, true) bool isProjectileLaunchEvent() const => _tag == Tag.projectileLaunchEvent;
  ///ditto
  alias getProjectileLaunchEvent = _get!(Tag.projectileLaunchEvent);

  /++

  +/
  alias sheepDyeWoolEvent = _create!(Tag.sheepDyeWoolEvent);
  /// ditto
  pragma(inline, true) bool isSheepDyeWoolEvent() const => _tag == Tag.sheepDyeWoolEvent;
  ///ditto
  alias getSheepDyeWoolEvent = _get!(Tag.sheepDyeWoolEvent);

  /++

  +/
  alias sheepRegrowWoolEvent = _create!(Tag.sheepRegrowWoolEvent);
  /// ditto
  pragma(inline, true) bool isSheepRegrowWoolEvent() const => _tag == Tag.sheepRegrowWoolEvent;
  ///ditto
  alias getSheepRegrowWoolEvent = _get!(Tag.sheepRegrowWoolEvent);

  /++

  +/
  alias slimeSplitEvent = _create!(Tag.slimeSplitEvent);
  /// ditto
  pragma(inline, true) bool isSlimeSplitEvent() const => _tag == Tag.slimeSplitEvent;
  ///ditto
  alias getSlimeSplitEvent = _get!(Tag.slimeSplitEvent);

  /++

  +/
  alias striderTemperatureChangeEvent = _create!(Tag.striderTemperatureChangeEvent);
  /// ditto
  pragma(inline, true) bool isStriderTemperatureChangeEvent() const => _tag == Tag.striderTemperatureChangeEvent;
  ///ditto
  alias getStriderTemperatureChangeEvent = _get!(Tag.striderTemperatureChangeEvent);

  /++

  +/
  alias villagerAcquireTradeEvent = _create!(Tag.villagerAcquireTradeEvent);
  /// ditto
  pragma(inline, true) bool isVillagerAcquireTradeEvent() const => _tag == Tag.villagerAcquireTradeEvent;
  ///ditto
  alias getVillagerAcquireTradeEvent = _get!(Tag.villagerAcquireTradeEvent);

  /++

  +/
  alias villagerCareerChangeEvent = _create!(Tag.villagerCareerChangeEvent);
  /// ditto
  pragma(inline, true) bool isVillagerCareerChangeEvent() const => _tag == Tag.villagerCareerChangeEvent;
  ///ditto
  alias getVillagerCareerChangeEvent = _get!(Tag.villagerCareerChangeEvent);

  /++

  +/
  alias villagerReplenishTradeEvent = _create!(Tag.villagerReplenishTradeEvent);
  /// ditto
  pragma(inline, true) bool isVillagerReplenishTradeEvent() const => _tag == Tag.villagerReplenishTradeEvent;
  ///ditto
  alias getVillagerReplenishTradeEvent = _get!(Tag.villagerReplenishTradeEvent);

  /++

  +/
  alias wardenAngerChangeEvent = _create!(Tag.wardenAngerChangeEvent);
  /// ditto
  pragma(inline, true) bool isWardenAngerChangeEvent() const => _tag == Tag.wardenAngerChangeEvent;
  ///ditto
  alias getWardenAngerChangeEvent = _get!(Tag.wardenAngerChangeEvent);

  /++

  +/
  alias areaEffectCloudApplyEvent = _create!(Tag.areaEffectCloudApplyEvent);
  /// ditto
  pragma(inline, true) bool isAreaEffectCloudApplyEvent() const => _tag == Tag.areaEffectCloudApplyEvent;
  ///ditto
  alias getAreaEffectCloudApplyEvent = _get!(Tag.areaEffectCloudApplyEvent);

  /++

  +/
  alias arrowBodyCountChangeEvent = _create!(Tag.arrowBodyCountChangeEvent);
  /// ditto
  pragma(inline, true) bool isArrowBodyCountChangeEvent() const => _tag == Tag.arrowBodyCountChangeEvent;
  ///ditto
  alias getArrowBodyCountChangeEvent = _get!(Tag.arrowBodyCountChangeEvent);

  /++

  +/
  alias batToggleSleepEvent = _create!(Tag.batToggleSleepEvent);
  /// ditto
  pragma(inline, true) bool isBatToggleSleepEvent() const => _tag == Tag.batToggleSleepEvent;
  ///ditto
  alias getBatToggleSleepEvent = _get!(Tag.batToggleSleepEvent);

  /++

  +/
  alias creeperPowerEvent = _create!(Tag.creeperPowerEvent);
  /// ditto
  pragma(inline, true) bool isCreeperPowerEvent() const => _tag == Tag.creeperPowerEvent;
  ///ditto
  alias getCreeperPowerEvent = _get!(Tag.creeperPowerEvent);

  /++

  +/
  alias entityCombustByBlockEvent = _create!(Tag.entityCombustByBlockEvent);
  /// ditto
  pragma(inline, true) bool isEntityCombustByBlockEvent() const => _tag == Tag.entityCombustByBlockEvent;
  ///ditto
  alias getEntityCombustByBlockEvent = _get!(Tag.entityCombustByBlockEvent);

  /++

  +/
  alias entityCombustByEntityEvent = _create!(Tag.entityCombustByEntityEvent);
  /// ditto
  pragma(inline, true) bool isEntityCombustByEntityEvent() const => _tag == Tag.entityCombustByEntityEvent;
  ///ditto
  alias getEntityCombustByEntityEvent = _get!(Tag.entityCombustByEntityEvent);

  /++

  +/
  alias entityKnockbackByEntityEvent = _create!(Tag.entityKnockbackByEntityEvent);
  /// ditto
  pragma(inline, true) bool isEntityKnockbackByEntityEvent() const => _tag == Tag.entityKnockbackByEntityEvent;
  ///ditto
  alias getEntityKnockbackByEntityEvent = _get!(Tag.entityKnockbackByEntityEvent);

  /++

  +/
  alias entityPortalEnterEvent = _create!(Tag.entityPortalEnterEvent);
  /// ditto
  pragma(inline, true) bool isEntityPortalEnterEvent() const => _tag == Tag.entityPortalEnterEvent;
  ///ditto
  alias getEntityPortalEnterEvent = _get!(Tag.entityPortalEnterEvent);

  /++

  +/
  alias entityPortalExitEvent = _create!(Tag.entityPortalExitEvent);
  /// ditto
  pragma(inline, true) bool isEntityPortalExitEvent() const => _tag == Tag.entityPortalExitEvent;
  ///ditto
  alias getEntityPortalExitEvent = _get!(Tag.entityPortalExitEvent);

  /++

  +/
  alias entityRemoveEvent = _create!(Tag.entityRemoveEvent);
  /// ditto
  pragma(inline, true) bool isEntityRemoveEvent() const => _tag == Tag.entityRemoveEvent;
  ///ditto
  alias getEntityRemoveEvent = _get!(Tag.entityRemoveEvent);

  /++

  +/
  alias entityTargetBlockEvent = _create!(Tag.entityTargetBlockEvent);
  /// ditto
  pragma(inline, true) bool isEntityTargetBlockEvent() const => _tag == Tag.entityTargetBlockEvent;
  ///ditto
  alias getEntityTargetBlockEvent = _get!(Tag.entityTargetBlockEvent);

  /++

  +/
  alias entityUnleashEvent = _create!(Tag.entityUnleashEvent);
  /// ditto
  pragma(inline, true) bool isEntityUnleashEvent() const => _tag == Tag.entityUnleashEvent;
  ///ditto
  alias getEntityUnleashEvent = _get!(Tag.entityUnleashEvent);

  /++

  +/
  alias expBottleEvent = _create!(Tag.expBottleEvent);
  /// ditto
  pragma(inline, true) bool isExpBottleEvent() const => _tag == Tag.expBottleEvent;
  ///ditto
  alias getExpBottleEvent = _get!(Tag.expBottleEvent);

  /++

  +/
  alias horseJumpEvent = _create!(Tag.horseJumpEvent);
  /// ditto
  pragma(inline, true) bool isHorseJumpEvent() const => _tag == Tag.horseJumpEvent;
  ///ditto
  alias getHorseJumpEvent = _get!(Tag.horseJumpEvent);

  /++

  +/
  alias lingeringPotionSplashEvent = _create!(Tag.lingeringPotionSplashEvent);
  /// ditto
  pragma(inline, true) bool isLingeringPotionSplashEvent() const => _tag == Tag.lingeringPotionSplashEvent;
  ///ditto
  alias getLingeringPotionSplashEvent = _get!(Tag.lingeringPotionSplashEvent);

  /++

  +/
  alias pigZapEvent = _create!(Tag.pigZapEvent);
  /// ditto
  pragma(inline, true) bool isPigZapEvent() const => _tag == Tag.pigZapEvent;
  ///ditto
  alias getPigZapEvent = _get!(Tag.pigZapEvent);

  /++

  +/
  alias pigZombieAngerEvent = _create!(Tag.pigZombieAngerEvent);
  /// ditto
  pragma(inline, true) bool isPigZombieAngerEvent() const => _tag == Tag.pigZombieAngerEvent;
  ///ditto
  alias getPigZombieAngerEvent = _get!(Tag.pigZombieAngerEvent);

  /++

  +/
  alias potionSplashEvent = _create!(Tag.potionSplashEvent);
  /// ditto
  pragma(inline, true) bool isPotionSplashEvent() const => _tag == Tag.potionSplashEvent;
  ///ditto
  alias getPotionSplashEvent = _get!(Tag.potionSplashEvent);

  /++

  +/
  alias spawnerSpawnEvent = _create!(Tag.spawnerSpawnEvent);
  /// ditto
  pragma(inline, true) bool isSpawnerSpawnEvent() const => _tag == Tag.spawnerSpawnEvent;
  ///ditto
  alias getSpawnerSpawnEvent = _get!(Tag.spawnerSpawnEvent);

  /++

  +/
  alias trialSpawnerSpawnEvent = _create!(Tag.trialSpawnerSpawnEvent);
  /// ditto
  pragma(inline, true) bool isTrialSpawnerSpawnEvent() const => _tag == Tag.trialSpawnerSpawnEvent;
  ///ditto
  alias getTrialSpawnerSpawnEvent = _get!(Tag.trialSpawnerSpawnEvent);

  /++

  +/
  alias villagerReputationChangeEvent = _create!(Tag.villagerReputationChangeEvent);
  /// ditto
  pragma(inline, true) bool isVillagerReputationChangeEvent() const => _tag == Tag.villagerReputationChangeEvent;
  ///ditto
  alias getVillagerReputationChangeEvent = _get!(Tag.villagerReputationChangeEvent);

  /++

  +/
  alias asyncPlayerChatEvent = _create!(Tag.asyncPlayerChatEvent);
  /// ditto
  pragma(inline, true) bool isAsyncPlayerChatEvent() const => _tag == Tag.asyncPlayerChatEvent;
  ///ditto
  alias getAsyncPlayerChatEvent = _get!(Tag.asyncPlayerChatEvent);

  /++

  +/
  alias asyncPlayerPreLoginEvent = _create!(Tag.asyncPlayerPreLoginEvent);
  /// ditto
  pragma(inline, true) bool isAsyncPlayerPreLoginEvent() const => _tag == Tag.asyncPlayerPreLoginEvent;
  ///ditto
  alias getAsyncPlayerPreLoginEvent = _get!(Tag.asyncPlayerPreLoginEvent);

  /++

  +/
  alias playerAdvancementDoneEvent = _create!(Tag.playerAdvancementDoneEvent);
  /// ditto
  pragma(inline, true) bool isPlayerAdvancementDoneEvent() const => _tag == Tag.playerAdvancementDoneEvent;
  ///ditto
  alias getPlayerAdvancementDoneEvent = _get!(Tag.playerAdvancementDoneEvent);

  /++

  +/
  alias playerAnimationEvent = _create!(Tag.playerAnimationEvent);
  /// ditto
  pragma(inline, true) bool isPlayerAnimationEvent() const => _tag == Tag.playerAnimationEvent;
  ///ditto
  alias getPlayerAnimationEvent = _get!(Tag.playerAnimationEvent);

  /++

  +/
  alias playerArmorStandManipulateEvent = _create!(Tag.playerArmorStandManipulateEvent);
  /// ditto
  pragma(inline, true) bool isPlayerArmorStandManipulateEvent() const => _tag == Tag.playerArmorStandManipulateEvent;
  ///ditto
  alias getPlayerArmorStandManipulateEvent = _get!(Tag.playerArmorStandManipulateEvent);

  /++

  +/
  alias playerBucketEntityEvent = _create!(Tag.playerBucketEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerBucketEntityEvent() const => _tag == Tag.playerBucketEntityEvent;
  ///ditto
  alias getPlayerBucketEntityEvent = _get!(Tag.playerBucketEntityEvent);

  /++

  +/
  alias playerChangedWorldEvent = _create!(Tag.playerChangedWorldEvent);
  /// ditto
  pragma(inline, true) bool isPlayerChangedWorldEvent() const => _tag == Tag.playerChangedWorldEvent;
  ///ditto
  alias getPlayerChangedWorldEvent = _get!(Tag.playerChangedWorldEvent);

  /++

  +/
  alias playerChannelEvent = _create!(Tag.playerChannelEvent);
  /// ditto
  pragma(inline, true) bool isPlayerChannelEvent() const => _tag == Tag.playerChannelEvent;
  ///ditto
  alias getPlayerChannelEvent = _get!(Tag.playerChannelEvent);

  /++

  +/
  alias playerCommandPreprocessEvent = _create!(Tag.playerCommandPreprocessEvent);
  /// ditto
  pragma(inline, true) bool isPlayerCommandPreprocessEvent() const => _tag == Tag.playerCommandPreprocessEvent;
  ///ditto
  alias getPlayerCommandPreprocessEvent = _get!(Tag.playerCommandPreprocessEvent);

  /++

  +/
  alias playerEditBookEvent = _create!(Tag.playerEditBookEvent);
  /// ditto
  pragma(inline, true) bool isPlayerEditBookEvent() const => _tag == Tag.playerEditBookEvent;
  ///ditto
  alias getPlayerEditBookEvent = _get!(Tag.playerEditBookEvent);

  /++

  +/
  alias playerElytraBoostEvent = _create!(Tag.playerElytraBoostEvent);
  /// ditto
  pragma(inline, true) bool isPlayerElytraBoostEvent() const => _tag == Tag.playerElytraBoostEvent;
  ///ditto
  alias getPlayerElytraBoostEvent = _get!(Tag.playerElytraBoostEvent);

  /++

  +/
  alias playerExpCooldownChangeEvent = _create!(Tag.playerExpCooldownChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerExpCooldownChangeEvent() const => _tag == Tag.playerExpCooldownChangeEvent;
  ///ditto
  alias getPlayerExpCooldownChangeEvent = _get!(Tag.playerExpCooldownChangeEvent);

  /++

  +/
  alias playerHarvestBlockEvent = _create!(Tag.playerHarvestBlockEvent);
  /// ditto
  pragma(inline, true) bool isPlayerHarvestBlockEvent() const => _tag == Tag.playerHarvestBlockEvent;
  ///ditto
  alias getPlayerHarvestBlockEvent = _get!(Tag.playerHarvestBlockEvent);

  /++

  +/
  alias playerHideEntityEvent = _create!(Tag.playerHideEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerHideEntityEvent() const => _tag == Tag.playerHideEntityEvent;
  ///ditto
  alias getPlayerHideEntityEvent = _get!(Tag.playerHideEntityEvent);

  /++

  +/
  alias playerItemBreakEvent = _create!(Tag.playerItemBreakEvent);
  /// ditto
  pragma(inline, true) bool isPlayerItemBreakEvent() const => _tag == Tag.playerItemBreakEvent;
  ///ditto
  alias getPlayerItemBreakEvent = _get!(Tag.playerItemBreakEvent);

  /++

  +/
  alias playerItemMendEvent = _create!(Tag.playerItemMendEvent);
  /// ditto
  pragma(inline, true) bool isPlayerItemMendEvent() const => _tag == Tag.playerItemMendEvent;
  ///ditto
  alias getPlayerItemMendEvent = _get!(Tag.playerItemMendEvent);

  /++

  +/
  alias playerKickEvent = _create!(Tag.playerKickEvent);
  /// ditto
  pragma(inline, true) bool isPlayerKickEvent() const => _tag == Tag.playerKickEvent;
  ///ditto
  alias getPlayerKickEvent = _get!(Tag.playerKickEvent);

  /++

  +/
  alias playerLeashEntityEvent = _create!(Tag.playerLeashEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLeashEntityEvent() const => _tag == Tag.playerLeashEntityEvent;
  ///ditto
  alias getPlayerLeashEntityEvent = _get!(Tag.playerLeashEntityEvent);

  /++

  +/
  alias playerLevelChangeEvent = _create!(Tag.playerLevelChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLevelChangeEvent() const => _tag == Tag.playerLevelChangeEvent;
  ///ditto
  alias getPlayerLevelChangeEvent = _get!(Tag.playerLevelChangeEvent);

  /++

  +/
  alias playerLocaleChangeEvent = _create!(Tag.playerLocaleChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLocaleChangeEvent() const => _tag == Tag.playerLocaleChangeEvent;
  ///ditto
  alias getPlayerLocaleChangeEvent = _get!(Tag.playerLocaleChangeEvent);

  /++

  +/
  alias playerNameEntityEvent = _create!(Tag.playerNameEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerNameEntityEvent() const => _tag == Tag.playerNameEntityEvent;
  ///ditto
  alias getPlayerNameEntityEvent = _get!(Tag.playerNameEntityEvent);

  /++

  +/
  alias playerOpenSignEvent = _create!(Tag.playerOpenSignEvent);
  /// ditto
  pragma(inline, true) bool isPlayerOpenSignEvent() const => _tag == Tag.playerOpenSignEvent;
  ///ditto
  alias getPlayerOpenSignEvent = _get!(Tag.playerOpenSignEvent);

  /++

  +/
  alias playerPortalEvent = _create!(Tag.playerPortalEvent);
  /// ditto
  pragma(inline, true) bool isPlayerPortalEvent() const => _tag == Tag.playerPortalEvent;
  ///ditto
  alias getPlayerPortalEvent = _get!(Tag.playerPortalEvent);

  /++

  +/
  alias playerPreLoginEvent = _create!(Tag.playerPreLoginEvent);
  /// ditto
  pragma(inline, true) bool isPlayerPreLoginEvent() const => _tag == Tag.playerPreLoginEvent;
  ///ditto
  alias getPlayerPreLoginEvent = _get!(Tag.playerPreLoginEvent);

  /++

  +/
  alias playerRiptideEvent = _create!(Tag.playerRiptideEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRiptideEvent() const => _tag == Tag.playerRiptideEvent;
  ///ditto
  alias getPlayerRiptideEvent = _get!(Tag.playerRiptideEvent);

  /++

  +/
  alias playerShearEntityEvent = _create!(Tag.playerShearEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerShearEntityEvent() const => _tag == Tag.playerShearEntityEvent;
  ///ditto
  alias getPlayerShearEntityEvent = _get!(Tag.playerShearEntityEvent);

  /++

  +/
  alias playerShowEntityEvent = _create!(Tag.playerShowEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerShowEntityEvent() const => _tag == Tag.playerShowEntityEvent;
  ///ditto
  alias getPlayerShowEntityEvent = _get!(Tag.playerShowEntityEvent);

  /++

  +/
  alias playerSpawnChangeEvent = _create!(Tag.playerSpawnChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerSpawnChangeEvent() const => _tag == Tag.playerSpawnChangeEvent;
  ///ditto
  alias getPlayerSpawnChangeEvent = _get!(Tag.playerSpawnChangeEvent);

  /++

  +/
  alias playerStatisticIncrementEvent = _create!(Tag.playerStatisticIncrementEvent);
  /// ditto
  pragma(inline, true) bool isPlayerStatisticIncrementEvent() const => _tag == Tag.playerStatisticIncrementEvent;
  ///ditto
  alias getPlayerStatisticIncrementEvent = _get!(Tag.playerStatisticIncrementEvent);

  /++

  +/
  alias playerSwapHandsEvent = _create!(Tag.playerSwapHandsEvent);
  /// ditto
  pragma(inline, true) bool isPlayerSwapHandsEvent() const => _tag == Tag.playerSwapHandsEvent;
  ///ditto
  alias getPlayerSwapHandsEvent = _get!(Tag.playerSwapHandsEvent);

  /++

  +/
  alias playerTakeLecternBookEvent = _create!(Tag.playerTakeLecternBookEvent);
  /// ditto
  pragma(inline, true) bool isPlayerTakeLecternBookEvent() const => _tag == Tag.playerTakeLecternBookEvent;
  ///ditto
  alias getPlayerTakeLecternBookEvent = _get!(Tag.playerTakeLecternBookEvent);

  /++

  +/
  alias playerUnleashEntityEvent = _create!(Tag.playerUnleashEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerUnleashEntityEvent() const => _tag == Tag.playerUnleashEntityEvent;
  ///ditto
  alias getPlayerUnleashEntityEvent = _get!(Tag.playerUnleashEntityEvent);

  /++

  +/
  alias playerVelocityEvent = _create!(Tag.playerVelocityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerVelocityEvent() const => _tag == Tag.playerVelocityEvent;
  ///ditto
  alias getPlayerVelocityEvent = _get!(Tag.playerVelocityEvent);

  /++

  +/
  alias playerInputEvent = _create!(Tag.playerInputEvent);
  /// ditto
  pragma(inline, true) bool isPlayerInputEvent() const => _tag == Tag.playerInputEvent;
  ///ditto
  alias getPlayerInputEvent = _get!(Tag.playerInputEvent);

  /++

  +/
  alias playerInteractAtEntityEvent = _create!(Tag.playerInteractAtEntityEvent);
  /// ditto
  pragma(inline, true) bool isPlayerInteractAtEntityEvent() const => _tag == Tag.playerInteractAtEntityEvent;
  ///ditto
  alias getPlayerInteractAtEntityEvent = _get!(Tag.playerInteractAtEntityEvent);

  /++

  +/
  alias playerLinksSendEvent = _create!(Tag.playerLinksSendEvent);
  /// ditto
  pragma(inline, true) bool isPlayerLinksSendEvent() const => _tag == Tag.playerLinksSendEvent;
  ///ditto
  alias getPlayerLinksSendEvent = _get!(Tag.playerLinksSendEvent);

  /++

  +/
  alias playerPickupArrowEvent = _create!(Tag.playerPickupArrowEvent);
  /// ditto
  pragma(inline, true) bool isPlayerPickupArrowEvent() const => _tag == Tag.playerPickupArrowEvent;
  ///ditto
  alias getPlayerPickupArrowEvent = _get!(Tag.playerPickupArrowEvent);

  /++

  +/
  alias playerRecipeBookClickEvent = _create!(Tag.playerRecipeBookClickEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRecipeBookClickEvent() const => _tag == Tag.playerRecipeBookClickEvent;
  ///ditto
  alias getPlayerRecipeBookClickEvent = _get!(Tag.playerRecipeBookClickEvent);

  /++

  +/
  alias playerRecipeBookSettingsChangeEvent = _create!(Tag.playerRecipeBookSettingsChangeEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRecipeBookSettingsChangeEvent() const => _tag == Tag.playerRecipeBookSettingsChangeEvent;
  ///ditto
  alias getPlayerRecipeBookSettingsChangeEvent = _get!(Tag.playerRecipeBookSettingsChangeEvent);

  /++

  +/
  alias playerRecipeDiscoverEvent = _create!(Tag.playerRecipeDiscoverEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRecipeDiscoverEvent() const => _tag == Tag.playerRecipeDiscoverEvent;
  ///ditto
  alias getPlayerRecipeDiscoverEvent = _get!(Tag.playerRecipeDiscoverEvent);

  /++

  +/
  alias playerRegisterChannelEvent = _create!(Tag.playerRegisterChannelEvent);
  /// ditto
  pragma(inline, true) bool isPlayerRegisterChannelEvent() const => _tag == Tag.playerRegisterChannelEvent;
  ///ditto
  alias getPlayerRegisterChannelEvent = _get!(Tag.playerRegisterChannelEvent);

  /++

  +/
  alias playerResourcePackStatusEvent = _create!(Tag.playerResourcePackStatusEvent);
  /// ditto
  pragma(inline, true) bool isPlayerResourcePackStatusEvent() const => _tag == Tag.playerResourcePackStatusEvent;
  ///ditto
  alias getPlayerResourcePackStatusEvent = _get!(Tag.playerResourcePackStatusEvent);

  /++

  +/
  alias playerSpawnLocationEvent = _create!(Tag.playerSpawnLocationEvent);
  /// ditto
  pragma(inline, true) bool isPlayerSpawnLocationEvent() const => _tag == Tag.playerSpawnLocationEvent;
  ///ditto
  alias getPlayerSpawnLocationEvent = _get!(Tag.playerSpawnLocationEvent);

  /++

  +/
  alias playerUnregisterChannelEvent = _create!(Tag.playerUnregisterChannelEvent);
  /// ditto
  pragma(inline, true) bool isPlayerUnregisterChannelEvent() const => _tag == Tag.playerUnregisterChannelEvent;
  ///ditto
  alias getPlayerUnregisterChannelEvent = _get!(Tag.playerUnregisterChannelEvent);

  /++

  +/
  alias raidFinishEvent = _create!(Tag.raidFinishEvent);
  /// ditto
  pragma(inline, true) bool isRaidFinishEvent() const => _tag == Tag.raidFinishEvent;
  ///ditto
  alias getRaidFinishEvent = _get!(Tag.raidFinishEvent);

  /++

  +/
  alias raidSpawnWaveEvent = _create!(Tag.raidSpawnWaveEvent);
  /// ditto
  pragma(inline, true) bool isRaidSpawnWaveEvent() const => _tag == Tag.raidSpawnWaveEvent;
  ///ditto
  alias getRaidSpawnWaveEvent = _get!(Tag.raidSpawnWaveEvent);

  /++

  +/
  alias raidStopEvent = _create!(Tag.raidStopEvent);
  /// ditto
  pragma(inline, true) bool isRaidStopEvent() const => _tag == Tag.raidStopEvent;
  ///ditto
  alias getRaidStopEvent = _get!(Tag.raidStopEvent);

  /++

  +/
  alias raidTriggerEvent = _create!(Tag.raidTriggerEvent);
  /// ditto
  pragma(inline, true) bool isRaidTriggerEvent() const => _tag == Tag.raidTriggerEvent;
  ///ditto
  alias getRaidTriggerEvent = _get!(Tag.raidTriggerEvent);

  /++

  +/
  alias lightningStrikeEvent = _create!(Tag.lightningStrikeEvent);
  /// ditto
  pragma(inline, true) bool isLightningStrikeEvent() const => _tag == Tag.lightningStrikeEvent;
  ///ditto
  alias getLightningStrikeEvent = _get!(Tag.lightningStrikeEvent);

  void witFree() @nogc nothrow {
    switch (_tag) with (Tag) {
      case playerChatEvent: _get!(Tag.playerChatEvent).witFree; break;
      case playerCommandSendEvent: _get!(Tag.playerCommandSendEvent).witFree; break;
      case playerPermissionCheckEvent: _get!(Tag.playerPermissionCheckEvent).witFree; break;
      case playerCustomPayloadEvent: _get!(Tag.playerCustomPayloadEvent).witFree; break;
      case playerFishEvent: _get!(Tag.playerFishEvent).witFree; break;
      case playerEggThrowEvent: _get!(Tag.playerEggThrowEvent).witFree; break;
      case playerInteractEvent: _get!(Tag.playerInteractEvent).witFree; break;
      case blockBreakEvent: _get!(Tag.blockBreakEvent).witFree; break;
      case blockBurnEvent: _get!(Tag.blockBurnEvent).witFree; break;
      case blockCanBuildEvent: _get!(Tag.blockCanBuildEvent).witFree; break;
      case blockGrowEvent: _get!(Tag.blockGrowEvent).witFree; break;
      case blockPlaceEvent: _get!(Tag.blockPlaceEvent).witFree; break;
      case dialogClickActionEvent: _get!(Tag.dialogClickActionEvent).witFree; break;
      case dialogShowEvent: _get!(Tag.dialogShowEvent).witFree; break;
      case bedrockFormResponseEvent: _get!(Tag.bedrockFormResponseEvent).witFree; break;
      case serverCommandEvent: _get!(Tag.serverCommandEvent).witFree; break;
      case serverListPingEvent: _get!(Tag.serverListPingEvent).witFree; break;
      case packetReceivedEvent: _get!(Tag.packetReceivedEvent).witFree; break;
      case packetSentEvent: _get!(Tag.packetSentEvent).witFree; break;
      case entitySpawnEvent: _get!(Tag.entitySpawnEvent).witFree; break;
      case entityDyeEvent: _get!(Tag.entityDyeEvent).witFree; break;
      case entityPickupItemEvent: _get!(Tag.entityPickupItemEvent).witFree; break;
      case entityShootBowEvent: _get!(Tag.entityShootBowEvent).witFree; break;
      case entityTransformEvent: _get!(Tag.entityTransformEvent).witFree; break;
      case playerItemConsumeEvent: _get!(Tag.playerItemConsumeEvent).witFree; break;
      case playerItemDamageEvent: _get!(Tag.playerItemDamageEvent).witFree; break;
      case playerDropItemEvent: _get!(Tag.playerDropItemEvent).witFree; break;
      case playerBucketEmptyEvent: _get!(Tag.playerBucketEmptyEvent).witFree; break;
      case playerBucketFillEvent: _get!(Tag.playerBucketFillEvent).witFree; break;
      case blockDispenseEvent: _get!(Tag.blockDispenseEvent).witFree; break;
      case blockPistonExtendEvent: _get!(Tag.blockPistonExtendEvent).witFree; break;
      case blockPistonRetractEvent: _get!(Tag.blockPistonRetractEvent).witFree; break;
      case notePlayEvent: _get!(Tag.notePlayEvent).witFree; break;
      case signChangeEvent: _get!(Tag.signChangeEvent).witFree; break;
      case tntPrimeEvent: _get!(Tag.tntPrimeEvent).witFree; break;
      case asyncStructureGenerateEvent: _get!(Tag.asyncStructureGenerateEvent).witFree; break;
      case asyncStructureSpawnEvent: _get!(Tag.asyncStructureSpawnEvent).witFree; break;
      case genericGameEvent: _get!(Tag.genericGameEvent).witFree; break;
      case lootGenerateEvent: _get!(Tag.lootGenerateEvent).witFree; break;
      case portalCreateEvent: _get!(Tag.portalCreateEvent).witFree; break;
      case structureGrowEvent: _get!(Tag.structureGrowEvent).witFree; break;
      case worldSaveEvent: _get!(Tag.worldSaveEvent).witFree; break;
      case craftItemEvent: _get!(Tag.craftItemEvent).witFree; break;
      case furnaceSmeltEvent: _get!(Tag.furnaceSmeltEvent).witFree; break;
      case furnaceBurnEvent: _get!(Tag.furnaceBurnEvent).witFree; break;
      case furnaceExtractEvent: _get!(Tag.furnaceExtractEvent).witFree; break;
      case furnaceStartSmeltEvent: _get!(Tag.furnaceStartSmeltEvent).witFree; break;
      case inventoryCreativeEvent: _get!(Tag.inventoryCreativeEvent).witFree; break;
      case inventoryMoveItemEvent: _get!(Tag.inventoryMoveItemEvent).witFree; break;
      case inventoryPickupItemEvent: _get!(Tag.inventoryPickupItemEvent).witFree; break;
      case prepareAnvilEvent: _get!(Tag.prepareAnvilEvent).witFree; break;
      case prepareGrindstoneEvent: _get!(Tag.prepareGrindstoneEvent).witFree; break;
      case prepareInventoryResultEvent: _get!(Tag.prepareInventoryResultEvent).witFree; break;
      case prepareItemCraftEvent: _get!(Tag.prepareItemCraftEvent).witFree; break;
      case prepareSmithingEvent: _get!(Tag.prepareSmithingEvent).witFree; break;
      case smithItemEvent: _get!(Tag.smithItemEvent).witFree; break;
      case prepareItemEnchantEvent: _get!(Tag.prepareItemEnchantEvent).witFree; break;
      case enchantItemEvent: _get!(Tag.enchantItemEvent).witFree; break;
      case hangingPlaceEvent: _get!(Tag.hangingPlaceEvent).witFree; break;
      case bellRingEvent: _get!(Tag.bellRingEvent).witFree; break;
      case blockDispenseLootEvent: _get!(Tag.blockDispenseLootEvent).witFree; break;
      case blockDropItemEvent: _get!(Tag.blockDropItemEvent).witFree; break;
      case blockFertilizeEvent: _get!(Tag.blockFertilizeEvent).witFree; break;
      case blockMultiPlaceEvent: _get!(Tag.blockMultiPlaceEvent).witFree; break;
      case blockReceiveGameEvent: _get!(Tag.blockReceiveGameEvent).witFree; break;
      case cauldronLevelChangeEvent: _get!(Tag.cauldronLevelChangeEvent).witFree; break;
      case creatureSpawnEvent: _get!(Tag.creatureSpawnEvent).witFree; break;
      case enderDragonChangePhaseEvent: _get!(Tag.enderDragonChangePhaseEvent).witFree; break;
      case entityChangeBlockEvent: _get!(Tag.entityChangeBlockEvent).witFree; break;
      case entityDamageByBlockEvent: _get!(Tag.entityDamageByBlockEvent).witFree; break;
      case entityDamageByEntityEvent: _get!(Tag.entityDamageByEntityEvent).witFree; break;
      case entityDropItemEvent: _get!(Tag.entityDropItemEvent).witFree; break;
      case entityPlaceEvent: _get!(Tag.entityPlaceEvent).witFree; break;
      case entityPoseChangeEvent: _get!(Tag.entityPoseChangeEvent).witFree; break;
      case entityPotionEffectEvent: _get!(Tag.entityPotionEffectEvent).witFree; break;
      case entitySpellCastEvent: _get!(Tag.entitySpellCastEvent).witFree; break;
      case entityTargetLivingEntityEvent: _get!(Tag.entityTargetLivingEntityEvent).witFree; break;
      case itemSpawnEvent: _get!(Tag.itemSpawnEvent).witFree; break;
      case piglinBarterEvent: _get!(Tag.piglinBarterEvent).witFree; break;
      case villagerCareerChangeEvent: _get!(Tag.villagerCareerChangeEvent).witFree; break;
      case areaEffectCloudApplyEvent: _get!(Tag.areaEffectCloudApplyEvent).witFree; break;
      case creeperPowerEvent: _get!(Tag.creeperPowerEvent).witFree; break;
      case entityRemoveEvent: _get!(Tag.entityRemoveEvent).witFree; break;
      case entityUnleashEvent: _get!(Tag.entityUnleashEvent).witFree; break;
      case lingeringPotionSplashEvent: _get!(Tag.lingeringPotionSplashEvent).witFree; break;
      case potionSplashEvent: _get!(Tag.potionSplashEvent).witFree; break;
      case asyncPlayerChatEvent: _get!(Tag.asyncPlayerChatEvent).witFree; break;
      case asyncPlayerPreLoginEvent: _get!(Tag.asyncPlayerPreLoginEvent).witFree; break;
      case playerAdvancementDoneEvent: _get!(Tag.playerAdvancementDoneEvent).witFree; break;
      case playerAnimationEvent: _get!(Tag.playerAnimationEvent).witFree; break;
      case playerBucketEntityEvent: _get!(Tag.playerBucketEntityEvent).witFree; break;
      case playerChannelEvent: _get!(Tag.playerChannelEvent).witFree; break;
      case playerCommandPreprocessEvent: _get!(Tag.playerCommandPreprocessEvent).witFree; break;
      case playerEditBookEvent: _get!(Tag.playerEditBookEvent).witFree; break;
      case playerHarvestBlockEvent: _get!(Tag.playerHarvestBlockEvent).witFree; break;
      case playerItemBreakEvent: _get!(Tag.playerItemBreakEvent).witFree; break;
      case playerItemMendEvent: _get!(Tag.playerItemMendEvent).witFree; break;
      case playerKickEvent: _get!(Tag.playerKickEvent).witFree; break;
      case playerLocaleChangeEvent: _get!(Tag.playerLocaleChangeEvent).witFree; break;
      case playerPreLoginEvent: _get!(Tag.playerPreLoginEvent).witFree; break;
      case playerRiptideEvent: _get!(Tag.playerRiptideEvent).witFree; break;
      case playerStatisticIncrementEvent: _get!(Tag.playerStatisticIncrementEvent).witFree; break;
      case playerInputEvent: _get!(Tag.playerInputEvent).witFree; break;
      case playerLinksSendEvent: _get!(Tag.playerLinksSendEvent).witFree; break;
      case playerRecipeBookClickEvent: _get!(Tag.playerRecipeBookClickEvent).witFree; break;
      case playerRecipeBookSettingsChangeEvent: _get!(Tag.playerRecipeBookSettingsChangeEvent).witFree; break;
      case playerRecipeDiscoverEvent: _get!(Tag.playerRecipeDiscoverEvent).witFree; break;
      case playerRegisterChannelEvent: _get!(Tag.playerRegisterChannelEvent).witFree; break;
      case playerResourcePackStatusEvent: _get!(Tag.playerResourcePackStatusEvent).witFree; break;
      case playerUnregisterChannelEvent: _get!(Tag.playerUnregisterChannelEvent).witFree; break;
      case raidStopEvent: _get!(Tag.raidStopEvent).witFree; break;
      default: break;
    }
  }

  void witDrop() @nogc nothrow {
    switch (_tag) with (Tag) {
      case playerJoinEvent: _get!(Tag.playerJoinEvent).witDrop; break;
      case playerLeaveEvent: _get!(Tag.playerLeaveEvent).witDrop; break;
      case playerLoginEvent: _get!(Tag.playerLoginEvent).witDrop; break;
      case playerChatEvent: _get!(Tag.playerChatEvent).witDrop; break;
      case playerCommandSendEvent: _get!(Tag.playerCommandSendEvent).witDrop; break;
      case playerPermissionCheckEvent: _get!(Tag.playerPermissionCheckEvent).witDrop; break;
      case playerMoveEvent: _get!(Tag.playerMoveEvent).witDrop; break;
      case playerTeleportEvent: _get!(Tag.playerTeleportEvent).witDrop; break;
      case playerChangeWorldEvent: _get!(Tag.playerChangeWorldEvent).witDrop; break;
      case playerRespawnEvent: _get!(Tag.playerRespawnEvent).witDrop; break;
      case playerExpChangeEvent: _get!(Tag.playerExpChangeEvent).witDrop; break;
      case playerItemHeldEvent: _get!(Tag.playerItemHeldEvent).witDrop; break;
      case playerChangedMainHandEvent: _get!(Tag.playerChangedMainHandEvent).witDrop; break;
      case playerGamemodeChangeEvent: _get!(Tag.playerGamemodeChangeEvent).witDrop; break;
      case playerCustomPayloadEvent: _get!(Tag.playerCustomPayloadEvent).witDrop; break;
      case playerFishEvent: _get!(Tag.playerFishEvent).witDrop; break;
      case playerEggThrowEvent: _get!(Tag.playerEggThrowEvent).witDrop; break;
      case playerInteractUnknownEntityEvent: _get!(Tag.playerInteractUnknownEntityEvent).witDrop; break;
      case playerInteractEntityEvent: _get!(Tag.playerInteractEntityEvent).witDrop; break;
      case playerInteractEvent: _get!(Tag.playerInteractEvent).witDrop; break;
      case playerToggleSneakEvent: _get!(Tag.playerToggleSneakEvent).witDrop; break;
      case playerToggleFlightEvent: _get!(Tag.playerToggleFlightEvent).witDrop; break;
      case playerToggleSprintEvent: _get!(Tag.playerToggleSprintEvent).witDrop; break;
      case inventoryClickEvent: _get!(Tag.inventoryClickEvent).witDrop; break;
      case inventoryCloseEvent: _get!(Tag.inventoryCloseEvent).witDrop; break;
      case blockRedstoneEvent: _get!(Tag.blockRedstoneEvent).witDrop; break;
      case blockBreakEvent: _get!(Tag.blockBreakEvent).witDrop; break;
      case blockCanBuildEvent: _get!(Tag.blockCanBuildEvent).witDrop; break;
      case blockGrowEvent: _get!(Tag.blockGrowEvent).witDrop; break;
      case blockPlaceEvent: _get!(Tag.blockPlaceEvent).witDrop; break;
      case dialogClickActionEvent: _get!(Tag.dialogClickActionEvent).witDrop; break;
      case dialogShowEvent: _get!(Tag.dialogShowEvent).witDrop; break;
      case dialogClearEvent: _get!(Tag.dialogClearEvent).witDrop; break;
      case bedrockFormResponseEvent: _get!(Tag.bedrockFormResponseEvent).witDrop; break;
      case serverListPingEvent: _get!(Tag.serverListPingEvent).witDrop; break;
      case spawnChangeEvent: _get!(Tag.spawnChangeEvent).witDrop; break;
      case serverBroadcastEvent: _get!(Tag.serverBroadcastEvent).witDrop; break;
      case packetReceivedEvent: _get!(Tag.packetReceivedEvent).witDrop; break;
      case packetSentEvent: _get!(Tag.packetSentEvent).witDrop; break;
      case chunkLoadEvent: _get!(Tag.chunkLoadEvent).witDrop; break;
      case chunkSaveEvent: _get!(Tag.chunkSaveEvent).witDrop; break;
      case chunkSendEvent: _get!(Tag.chunkSendEvent).witDrop; break;
      case playerDeathEvent: _get!(Tag.playerDeathEvent).witDrop; break;
      case entitySpawnEvent: _get!(Tag.entitySpawnEvent).witDrop; break;
      case entityDyeEvent: _get!(Tag.entityDyeEvent).witDrop; break;
      case entityTameEvent: _get!(Tag.entityTameEvent).witDrop; break;
      case playerItemConsumeEvent: _get!(Tag.playerItemConsumeEvent).witDrop; break;
      case playerItemDamageEvent: _get!(Tag.playerItemDamageEvent).witDrop; break;
      case playerDropItemEvent: _get!(Tag.playerDropItemEvent).witDrop; break;
      case playerBedEnterEvent: _get!(Tag.playerBedEnterEvent).witDrop; break;
      case playerBedLeaveEvent: _get!(Tag.playerBedLeaveEvent).witDrop; break;
      case playerBucketEmptyEvent: _get!(Tag.playerBucketEmptyEvent).witDrop; break;
      case playerBucketFillEvent: _get!(Tag.playerBucketFillEvent).witDrop; break;
      case blockDamageEvent: _get!(Tag.blockDamageEvent).witDrop; break;
      case signChangeEvent: _get!(Tag.signChangeEvent).witDrop; break;
      case weatherChangeEvent: _get!(Tag.weatherChangeEvent).witDrop; break;
      case thunderChangeEvent: _get!(Tag.thunderChangeEvent).witDrop; break;
      case worldLoadEvent: _get!(Tag.worldLoadEvent).witDrop; break;
      case worldUnloadEvent: _get!(Tag.worldUnloadEvent).witDrop; break;
      case worldInitEvent: _get!(Tag.worldInitEvent).witDrop; break;
      case inventoryOpenEvent: _get!(Tag.inventoryOpenEvent).witDrop; break;
      case inventoryDragEvent: _get!(Tag.inventoryDragEvent).witDrop; break;
      case craftItemEvent: _get!(Tag.craftItemEvent).witDrop; break;
      case furnaceExtractEvent: _get!(Tag.furnaceExtractEvent).witDrop; break;
      case inventoryCreativeEvent: _get!(Tag.inventoryCreativeEvent).witDrop; break;
      case inventoryInteractEvent: _get!(Tag.inventoryInteractEvent).witDrop; break;
      case prepareAnvilEvent: _get!(Tag.prepareAnvilEvent).witDrop; break;
      case prepareGrindstoneEvent: _get!(Tag.prepareGrindstoneEvent).witDrop; break;
      case prepareInventoryResultEvent: _get!(Tag.prepareInventoryResultEvent).witDrop; break;
      case prepareItemCraftEvent: _get!(Tag.prepareItemCraftEvent).witDrop; break;
      case prepareSmithingEvent: _get!(Tag.prepareSmithingEvent).witDrop; break;
      case smithItemEvent: _get!(Tag.smithItemEvent).witDrop; break;
      case tradeSelectEvent: _get!(Tag.tradeSelectEvent).witDrop; break;
      case prepareItemEnchantEvent: _get!(Tag.prepareItemEnchantEvent).witDrop; break;
      case enchantItemEvent: _get!(Tag.enchantItemEvent).witDrop; break;
      case hangingPlaceEvent: _get!(Tag.hangingPlaceEvent).witDrop; break;
      case bellResonateEvent: _get!(Tag.bellResonateEvent).witDrop; break;
      case bellRingEvent: _get!(Tag.bellRingEvent).witDrop; break;
      case blockBrushEvent: _get!(Tag.blockBrushEvent).witDrop; break;
      case blockCookEvent: _get!(Tag.blockCookEvent).witDrop; break;
      case blockDamageAbortEvent: _get!(Tag.blockDamageAbortEvent).witDrop; break;
      case blockDispenseArmorEvent: _get!(Tag.blockDispenseArmorEvent).witDrop; break;
      case blockDispenseLootEvent: _get!(Tag.blockDispenseLootEvent).witDrop; break;
      case blockDropItemEvent: _get!(Tag.blockDropItemEvent).witDrop; break;
      case blockExpEvent: _get!(Tag.blockExpEvent).witDrop; break;
      case blockFertilizeEvent: _get!(Tag.blockFertilizeEvent).witDrop; break;
      case blockMultiPlaceEvent: _get!(Tag.blockMultiPlaceEvent).witDrop; break;
      case blockReceiveGameEvent: _get!(Tag.blockReceiveGameEvent).witDrop; break;
      case blockShearEntityEvent: _get!(Tag.blockShearEntityEvent).witDrop; break;
      case blockSpreadEvent: _get!(Tag.blockSpreadEvent).witDrop; break;
      case brewingStartEvent: _get!(Tag.brewingStartEvent).witDrop; break;
      case campfireStartEvent: _get!(Tag.campfireStartEvent).witDrop; break;
      case cauldronLevelChangeEvent: _get!(Tag.cauldronLevelChangeEvent).witDrop; break;
      case crafterCraftEvent: _get!(Tag.crafterCraftEvent).witDrop; break;
      case entityBlockFormEvent: _get!(Tag.entityBlockFormEvent).witDrop; break;
      case fluidLevelChangeEvent: _get!(Tag.fluidLevelChangeEvent).witDrop; break;
      case inventoryBlockStartEvent: _get!(Tag.inventoryBlockStartEvent).witDrop; break;
      case leavesDecayEvent: _get!(Tag.leavesDecayEvent).witDrop; break;
      case moistureChangeEvent: _get!(Tag.moistureChangeEvent).witDrop; break;
      case sculkBloomEvent: _get!(Tag.sculkBloomEvent).witDrop; break;
      case vaultDisplayItemEvent: _get!(Tag.vaultDisplayItemEvent).witDrop; break;
      case creatureSpawnEvent: _get!(Tag.creatureSpawnEvent).witDrop; break;
      case piglinBarterEvent: _get!(Tag.piglinBarterEvent).witDrop; break;
      case asyncPlayerChatEvent: _get!(Tag.asyncPlayerChatEvent).witDrop; break;
      case asyncPlayerPreLoginEvent: _get!(Tag.asyncPlayerPreLoginEvent).witDrop; break;
      case playerAdvancementDoneEvent: _get!(Tag.playerAdvancementDoneEvent).witDrop; break;
      case playerAnimationEvent: _get!(Tag.playerAnimationEvent).witDrop; break;
      case playerArmorStandManipulateEvent: _get!(Tag.playerArmorStandManipulateEvent).witDrop; break;
      case playerBucketEntityEvent: _get!(Tag.playerBucketEntityEvent).witDrop; break;
      case playerChangedWorldEvent: _get!(Tag.playerChangedWorldEvent).witDrop; break;
      case playerChannelEvent: _get!(Tag.playerChannelEvent).witDrop; break;
      case playerCommandPreprocessEvent: _get!(Tag.playerCommandPreprocessEvent).witDrop; break;
      case playerEditBookEvent: _get!(Tag.playerEditBookEvent).witDrop; break;
      case playerElytraBoostEvent: _get!(Tag.playerElytraBoostEvent).witDrop; break;
      case playerExpCooldownChangeEvent: _get!(Tag.playerExpCooldownChangeEvent).witDrop; break;
      case playerHarvestBlockEvent: _get!(Tag.playerHarvestBlockEvent).witDrop; break;
      case playerHideEntityEvent: _get!(Tag.playerHideEntityEvent).witDrop; break;
      case playerItemBreakEvent: _get!(Tag.playerItemBreakEvent).witDrop; break;
      case playerItemMendEvent: _get!(Tag.playerItemMendEvent).witDrop; break;
      case playerKickEvent: _get!(Tag.playerKickEvent).witDrop; break;
      case playerLeashEntityEvent: _get!(Tag.playerLeashEntityEvent).witDrop; break;
      case playerLevelChangeEvent: _get!(Tag.playerLevelChangeEvent).witDrop; break;
      case playerLocaleChangeEvent: _get!(Tag.playerLocaleChangeEvent).witDrop; break;
      case playerNameEntityEvent: _get!(Tag.playerNameEntityEvent).witDrop; break;
      case playerOpenSignEvent: _get!(Tag.playerOpenSignEvent).witDrop; break;
      case playerPortalEvent: _get!(Tag.playerPortalEvent).witDrop; break;
      case playerPreLoginEvent: _get!(Tag.playerPreLoginEvent).witDrop; break;
      case playerRiptideEvent: _get!(Tag.playerRiptideEvent).witDrop; break;
      case playerShearEntityEvent: _get!(Tag.playerShearEntityEvent).witDrop; break;
      case playerShowEntityEvent: _get!(Tag.playerShowEntityEvent).witDrop; break;
      case playerSpawnChangeEvent: _get!(Tag.playerSpawnChangeEvent).witDrop; break;
      case playerStatisticIncrementEvent: _get!(Tag.playerStatisticIncrementEvent).witDrop; break;
      case playerSwapHandsEvent: _get!(Tag.playerSwapHandsEvent).witDrop; break;
      case playerTakeLecternBookEvent: _get!(Tag.playerTakeLecternBookEvent).witDrop; break;
      case playerUnleashEntityEvent: _get!(Tag.playerUnleashEntityEvent).witDrop; break;
      case playerVelocityEvent: _get!(Tag.playerVelocityEvent).witDrop; break;
      case playerInputEvent: _get!(Tag.playerInputEvent).witDrop; break;
      case playerInteractAtEntityEvent: _get!(Tag.playerInteractAtEntityEvent).witDrop; break;
      case playerLinksSendEvent: _get!(Tag.playerLinksSendEvent).witDrop; break;
      case playerPickupArrowEvent: _get!(Tag.playerPickupArrowEvent).witDrop; break;
      case playerRecipeBookClickEvent: _get!(Tag.playerRecipeBookClickEvent).witDrop; break;
      case playerRecipeBookSettingsChangeEvent: _get!(Tag.playerRecipeBookSettingsChangeEvent).witDrop; break;
      case playerRecipeDiscoverEvent: _get!(Tag.playerRecipeDiscoverEvent).witDrop; break;
      case playerRegisterChannelEvent: _get!(Tag.playerRegisterChannelEvent).witDrop; break;
      case playerResourcePackStatusEvent: _get!(Tag.playerResourcePackStatusEvent).witDrop; break;
      case playerSpawnLocationEvent: _get!(Tag.playerSpawnLocationEvent).witDrop; break;
      case playerUnregisterChannelEvent: _get!(Tag.playerUnregisterChannelEvent).witDrop; break;
      default: break;
    }
  }

  Event witClone() const @nogc nothrow {
    final switch (_tag) {
      case Tag.playerJoinEvent: return _create!(Tag.playerJoinEvent)(this._get!(Tag.playerJoinEvent).witClone); break;
      case Tag.playerLeaveEvent: return _create!(Tag.playerLeaveEvent)(this._get!(Tag.playerLeaveEvent).witClone); break;
      case Tag.playerLoginEvent: return _create!(Tag.playerLoginEvent)(this._get!(Tag.playerLoginEvent).witClone); break;
      case Tag.playerChatEvent: return _create!(Tag.playerChatEvent)(this._get!(Tag.playerChatEvent).witClone); break;
      case Tag.playerCommandSendEvent: return _create!(Tag.playerCommandSendEvent)(this._get!(Tag.playerCommandSendEvent).witClone); break;
      case Tag.playerPermissionCheckEvent: return _create!(Tag.playerPermissionCheckEvent)(this._get!(Tag.playerPermissionCheckEvent).witClone); break;
      case Tag.playerMoveEvent: return _create!(Tag.playerMoveEvent)(this._get!(Tag.playerMoveEvent).witClone); break;
      case Tag.playerTeleportEvent: return _create!(Tag.playerTeleportEvent)(this._get!(Tag.playerTeleportEvent).witClone); break;
      case Tag.playerChangeWorldEvent: return _create!(Tag.playerChangeWorldEvent)(this._get!(Tag.playerChangeWorldEvent).witClone); break;
      case Tag.playerRespawnEvent: return _create!(Tag.playerRespawnEvent)(this._get!(Tag.playerRespawnEvent).witClone); break;
      case Tag.playerExpChangeEvent: return _create!(Tag.playerExpChangeEvent)(this._get!(Tag.playerExpChangeEvent).witClone); break;
      case Tag.playerItemHeldEvent: return _create!(Tag.playerItemHeldEvent)(this._get!(Tag.playerItemHeldEvent).witClone); break;
      case Tag.playerChangedMainHandEvent: return _create!(Tag.playerChangedMainHandEvent)(this._get!(Tag.playerChangedMainHandEvent).witClone); break;
      case Tag.playerGamemodeChangeEvent: return _create!(Tag.playerGamemodeChangeEvent)(this._get!(Tag.playerGamemodeChangeEvent).witClone); break;
      case Tag.playerCustomPayloadEvent: return _create!(Tag.playerCustomPayloadEvent)(this._get!(Tag.playerCustomPayloadEvent).witClone); break;
      case Tag.playerFishEvent: return _create!(Tag.playerFishEvent)(this._get!(Tag.playerFishEvent).witClone); break;
      case Tag.playerEggThrowEvent: return _create!(Tag.playerEggThrowEvent)(this._get!(Tag.playerEggThrowEvent).witClone); break;
      case Tag.playerInteractUnknownEntityEvent: return _create!(Tag.playerInteractUnknownEntityEvent)(this._get!(Tag.playerInteractUnknownEntityEvent).witClone); break;
      case Tag.playerInteractEntityEvent: return _create!(Tag.playerInteractEntityEvent)(this._get!(Tag.playerInteractEntityEvent).witClone); break;
      case Tag.playerInteractEvent: return _create!(Tag.playerInteractEvent)(this._get!(Tag.playerInteractEvent).witClone); break;
      case Tag.playerToggleSneakEvent: return _create!(Tag.playerToggleSneakEvent)(this._get!(Tag.playerToggleSneakEvent).witClone); break;
      case Tag.playerToggleFlightEvent: return _create!(Tag.playerToggleFlightEvent)(this._get!(Tag.playerToggleFlightEvent).witClone); break;
      case Tag.playerToggleSprintEvent: return _create!(Tag.playerToggleSprintEvent)(this._get!(Tag.playerToggleSprintEvent).witClone); break;
      case Tag.inventoryClickEvent: return _create!(Tag.inventoryClickEvent)(this._get!(Tag.inventoryClickEvent).witClone); break;
      case Tag.inventoryCloseEvent: return _create!(Tag.inventoryCloseEvent)(this._get!(Tag.inventoryCloseEvent).witClone); break;
      case Tag.blockRedstoneEvent: return _create!(Tag.blockRedstoneEvent)(this._get!(Tag.blockRedstoneEvent).witClone); break;
      case Tag.blockBreakEvent: return _create!(Tag.blockBreakEvent)(this._get!(Tag.blockBreakEvent).witClone); break;
      case Tag.blockBurnEvent: return _create!(Tag.blockBurnEvent)(this._get!(Tag.blockBurnEvent).witClone); break;
      case Tag.blockCanBuildEvent: return _create!(Tag.blockCanBuildEvent)(this._get!(Tag.blockCanBuildEvent).witClone); break;
      case Tag.blockGrowEvent: return _create!(Tag.blockGrowEvent)(this._get!(Tag.blockGrowEvent).witClone); break;
      case Tag.blockPlaceEvent: return _create!(Tag.blockPlaceEvent)(this._get!(Tag.blockPlaceEvent).witClone); break;
      case Tag.dialogClickActionEvent: return _create!(Tag.dialogClickActionEvent)(this._get!(Tag.dialogClickActionEvent).witClone); break;
      case Tag.dialogShowEvent: return _create!(Tag.dialogShowEvent)(this._get!(Tag.dialogShowEvent).witClone); break;
      case Tag.dialogClearEvent: return _create!(Tag.dialogClearEvent)(this._get!(Tag.dialogClearEvent).witClone); break;
      case Tag.bedrockFormResponseEvent: return _create!(Tag.bedrockFormResponseEvent)(this._get!(Tag.bedrockFormResponseEvent).witClone); break;
      case Tag.serverCommandEvent: return _create!(Tag.serverCommandEvent)(this._get!(Tag.serverCommandEvent).witClone); break;
      case Tag.serverListPingEvent: return _create!(Tag.serverListPingEvent)(this._get!(Tag.serverListPingEvent).witClone); break;
      case Tag.serverLoadEvent: return _create!(Tag.serverLoadEvent)(this._get!(Tag.serverLoadEvent).witClone); break;
      case Tag.spawnChangeEvent: return _create!(Tag.spawnChangeEvent)(this._get!(Tag.spawnChangeEvent).witClone); break;
      case Tag.serverBroadcastEvent: return _create!(Tag.serverBroadcastEvent)(this._get!(Tag.serverBroadcastEvent).witClone); break;
      case Tag.serverTickStartEvent: return _create!(Tag.serverTickStartEvent)(this._get!(Tag.serverTickStartEvent).witClone); break;
      case Tag.serverTickEndEvent: return _create!(Tag.serverTickEndEvent)(this._get!(Tag.serverTickEndEvent).witClone); break;
      case Tag.packetReceivedEvent: return _create!(Tag.packetReceivedEvent)(this._get!(Tag.packetReceivedEvent).witClone); break;
      case Tag.packetSentEvent: return _create!(Tag.packetSentEvent)(this._get!(Tag.packetSentEvent).witClone); break;
      case Tag.chunkLoadEvent: return _create!(Tag.chunkLoadEvent)(this._get!(Tag.chunkLoadEvent).witClone); break;
      case Tag.chunkSaveEvent: return _create!(Tag.chunkSaveEvent)(this._get!(Tag.chunkSaveEvent).witClone); break;
      case Tag.chunkSendEvent: return _create!(Tag.chunkSendEvent)(this._get!(Tag.chunkSendEvent).witClone); break;
      case Tag.entityDamageEvent: return _create!(Tag.entityDamageEvent)(this._get!(Tag.entityDamageEvent).witClone); break;
      case Tag.entityDeathEvent: return _create!(Tag.entityDeathEvent)(this._get!(Tag.entityDeathEvent).witClone); break;
      case Tag.playerDeathEvent: return _create!(Tag.playerDeathEvent)(this._get!(Tag.playerDeathEvent).witClone); break;
      case Tag.entitySpawnEvent: return _create!(Tag.entitySpawnEvent)(this._get!(Tag.entitySpawnEvent).witClone); break;
      case Tag.entityCombustEvent: return _create!(Tag.entityCombustEvent)(this._get!(Tag.entityCombustEvent).witClone); break;
      case Tag.entityRegainHealthEvent: return _create!(Tag.entityRegainHealthEvent)(this._get!(Tag.entityRegainHealthEvent).witClone); break;
      case Tag.entityAirChangeEvent: return _create!(Tag.entityAirChangeEvent)(this._get!(Tag.entityAirChangeEvent).witClone); break;
      case Tag.entityBreedEvent: return _create!(Tag.entityBreedEvent)(this._get!(Tag.entityBreedEvent).witClone); break;
      case Tag.entityDismountEvent: return _create!(Tag.entityDismountEvent)(this._get!(Tag.entityDismountEvent).witClone); break;
      case Tag.entityDyeEvent: return _create!(Tag.entityDyeEvent)(this._get!(Tag.entityDyeEvent).witClone); break;
      case Tag.entityEnterLoveModeEvent: return _create!(Tag.entityEnterLoveModeEvent)(this._get!(Tag.entityEnterLoveModeEvent).witClone); break;
      case Tag.entityExplodeEvent: return _create!(Tag.entityExplodeEvent)(this._get!(Tag.entityExplodeEvent).witClone); break;
      case Tag.entityMountEvent: return _create!(Tag.entityMountEvent)(this._get!(Tag.entityMountEvent).witClone); break;
      case Tag.entityPickupItemEvent: return _create!(Tag.entityPickupItemEvent)(this._get!(Tag.entityPickupItemEvent).witClone); break;
      case Tag.entityPortalEvent: return _create!(Tag.entityPortalEvent)(this._get!(Tag.entityPortalEvent).witClone); break;
      case Tag.entityResurrectEvent: return _create!(Tag.entityResurrectEvent)(this._get!(Tag.entityResurrectEvent).witClone); break;
      case Tag.entityShootBowEvent: return _create!(Tag.entityShootBowEvent)(this._get!(Tag.entityShootBowEvent).witClone); break;
      case Tag.entityTameEvent: return _create!(Tag.entityTameEvent)(this._get!(Tag.entityTameEvent).witClone); break;
      case Tag.entityTargetEvent: return _create!(Tag.entityTargetEvent)(this._get!(Tag.entityTargetEvent).witClone); break;
      case Tag.entityTeleportEvent: return _create!(Tag.entityTeleportEvent)(this._get!(Tag.entityTeleportEvent).witClone); break;
      case Tag.entityToggleGlideEvent: return _create!(Tag.entityToggleGlideEvent)(this._get!(Tag.entityToggleGlideEvent).witClone); break;
      case Tag.entityTransformEvent: return _create!(Tag.entityTransformEvent)(this._get!(Tag.entityTransformEvent).witClone); break;
      case Tag.playerItemConsumeEvent: return _create!(Tag.playerItemConsumeEvent)(this._get!(Tag.playerItemConsumeEvent).witClone); break;
      case Tag.playerItemDamageEvent: return _create!(Tag.playerItemDamageEvent)(this._get!(Tag.playerItemDamageEvent).witClone); break;
      case Tag.playerDropItemEvent: return _create!(Tag.playerDropItemEvent)(this._get!(Tag.playerDropItemEvent).witClone); break;
      case Tag.playerBedEnterEvent: return _create!(Tag.playerBedEnterEvent)(this._get!(Tag.playerBedEnterEvent).witClone); break;
      case Tag.playerBedLeaveEvent: return _create!(Tag.playerBedLeaveEvent)(this._get!(Tag.playerBedLeaveEvent).witClone); break;
      case Tag.playerBucketEmptyEvent: return _create!(Tag.playerBucketEmptyEvent)(this._get!(Tag.playerBucketEmptyEvent).witClone); break;
      case Tag.playerBucketFillEvent: return _create!(Tag.playerBucketFillEvent)(this._get!(Tag.playerBucketFillEvent).witClone); break;
      case Tag.blockDamageEvent: return _create!(Tag.blockDamageEvent)(this._get!(Tag.blockDamageEvent).witClone); break;
      case Tag.blockIgniteEvent: return _create!(Tag.blockIgniteEvent)(this._get!(Tag.blockIgniteEvent).witClone); break;
      case Tag.blockFromToEvent: return _create!(Tag.blockFromToEvent)(this._get!(Tag.blockFromToEvent).witClone); break;
      case Tag.blockFormEvent: return _create!(Tag.blockFormEvent)(this._get!(Tag.blockFormEvent).witClone); break;
      case Tag.blockFadeEvent: return _create!(Tag.blockFadeEvent)(this._get!(Tag.blockFadeEvent).witClone); break;
      case Tag.blockDispenseEvent: return _create!(Tag.blockDispenseEvent)(this._get!(Tag.blockDispenseEvent).witClone); break;
      case Tag.blockExplodeEvent: return _create!(Tag.blockExplodeEvent)(this._get!(Tag.blockExplodeEvent).witClone); break;
      case Tag.blockPhysicsEvent: return _create!(Tag.blockPhysicsEvent)(this._get!(Tag.blockPhysicsEvent).witClone); break;
      case Tag.blockPistonExtendEvent: return _create!(Tag.blockPistonExtendEvent)(this._get!(Tag.blockPistonExtendEvent).witClone); break;
      case Tag.blockPistonRetractEvent: return _create!(Tag.blockPistonRetractEvent)(this._get!(Tag.blockPistonRetractEvent).witClone); break;
      case Tag.notePlayEvent: return _create!(Tag.notePlayEvent)(this._get!(Tag.notePlayEvent).witClone); break;
      case Tag.signChangeEvent: return _create!(Tag.signChangeEvent)(this._get!(Tag.signChangeEvent).witClone); break;
      case Tag.spongeAbsorbEvent: return _create!(Tag.spongeAbsorbEvent)(this._get!(Tag.spongeAbsorbEvent).witClone); break;
      case Tag.tntPrimeEvent: return _create!(Tag.tntPrimeEvent)(this._get!(Tag.tntPrimeEvent).witClone); break;
      case Tag.weatherChangeEvent: return _create!(Tag.weatherChangeEvent)(this._get!(Tag.weatherChangeEvent).witClone); break;
      case Tag.thunderChangeEvent: return _create!(Tag.thunderChangeEvent)(this._get!(Tag.thunderChangeEvent).witClone); break;
      case Tag.worldLoadEvent: return _create!(Tag.worldLoadEvent)(this._get!(Tag.worldLoadEvent).witClone); break;
      case Tag.worldUnloadEvent: return _create!(Tag.worldUnloadEvent)(this._get!(Tag.worldUnloadEvent).witClone); break;
      case Tag.asyncStructureGenerateEvent: return _create!(Tag.asyncStructureGenerateEvent)(this._get!(Tag.asyncStructureGenerateEvent).witClone); break;
      case Tag.asyncStructureSpawnEvent: return _create!(Tag.asyncStructureSpawnEvent)(this._get!(Tag.asyncStructureSpawnEvent).witClone); break;
      case Tag.chunkPopulateEvent: return _create!(Tag.chunkPopulateEvent)(this._get!(Tag.chunkPopulateEvent).witClone); break;
      case Tag.chunkUnloadEvent: return _create!(Tag.chunkUnloadEvent)(this._get!(Tag.chunkUnloadEvent).witClone); break;
      case Tag.entitiesLoadEvent: return _create!(Tag.entitiesLoadEvent)(this._get!(Tag.entitiesLoadEvent).witClone); break;
      case Tag.entitiesUnloadEvent: return _create!(Tag.entitiesUnloadEvent)(this._get!(Tag.entitiesUnloadEvent).witClone); break;
      case Tag.genericGameEvent: return _create!(Tag.genericGameEvent)(this._get!(Tag.genericGameEvent).witClone); break;
      case Tag.lootGenerateEvent: return _create!(Tag.lootGenerateEvent)(this._get!(Tag.lootGenerateEvent).witClone); break;
      case Tag.portalCreateEvent: return _create!(Tag.portalCreateEvent)(this._get!(Tag.portalCreateEvent).witClone); break;
      case Tag.structureGrowEvent: return _create!(Tag.structureGrowEvent)(this._get!(Tag.structureGrowEvent).witClone); break;
      case Tag.timeSkipEvent: return _create!(Tag.timeSkipEvent)(this._get!(Tag.timeSkipEvent).witClone); break;
      case Tag.worldInitEvent: return _create!(Tag.worldInitEvent)(this._get!(Tag.worldInitEvent).witClone); break;
      case Tag.worldSaveEvent: return _create!(Tag.worldSaveEvent)(this._get!(Tag.worldSaveEvent).witClone); break;
      case Tag.inventoryOpenEvent: return _create!(Tag.inventoryOpenEvent)(this._get!(Tag.inventoryOpenEvent).witClone); break;
      case Tag.inventoryDragEvent: return _create!(Tag.inventoryDragEvent)(this._get!(Tag.inventoryDragEvent).witClone); break;
      case Tag.craftItemEvent: return _create!(Tag.craftItemEvent)(this._get!(Tag.craftItemEvent).witClone); break;
      case Tag.furnaceSmeltEvent: return _create!(Tag.furnaceSmeltEvent)(this._get!(Tag.furnaceSmeltEvent).witClone); break;
      case Tag.brewEvent: return _create!(Tag.brewEvent)(this._get!(Tag.brewEvent).witClone); break;
      case Tag.brewingStandFuelEvent: return _create!(Tag.brewingStandFuelEvent)(this._get!(Tag.brewingStandFuelEvent).witClone); break;
      case Tag.furnaceBurnEvent: return _create!(Tag.furnaceBurnEvent)(this._get!(Tag.furnaceBurnEvent).witClone); break;
      case Tag.furnaceExtractEvent: return _create!(Tag.furnaceExtractEvent)(this._get!(Tag.furnaceExtractEvent).witClone); break;
      case Tag.furnaceStartSmeltEvent: return _create!(Tag.furnaceStartSmeltEvent)(this._get!(Tag.furnaceStartSmeltEvent).witClone); break;
      case Tag.hopperInventorySearchEvent: return _create!(Tag.hopperInventorySearchEvent)(this._get!(Tag.hopperInventorySearchEvent).witClone); break;
      case Tag.inventoryCreativeEvent: return _create!(Tag.inventoryCreativeEvent)(this._get!(Tag.inventoryCreativeEvent).witClone); break;
      case Tag.inventoryInteractEvent: return _create!(Tag.inventoryInteractEvent)(this._get!(Tag.inventoryInteractEvent).witClone); break;
      case Tag.inventoryMoveItemEvent: return _create!(Tag.inventoryMoveItemEvent)(this._get!(Tag.inventoryMoveItemEvent).witClone); break;
      case Tag.inventoryPickupItemEvent: return _create!(Tag.inventoryPickupItemEvent)(this._get!(Tag.inventoryPickupItemEvent).witClone); break;
      case Tag.prepareAnvilEvent: return _create!(Tag.prepareAnvilEvent)(this._get!(Tag.prepareAnvilEvent).witClone); break;
      case Tag.prepareGrindstoneEvent: return _create!(Tag.prepareGrindstoneEvent)(this._get!(Tag.prepareGrindstoneEvent).witClone); break;
      case Tag.prepareInventoryResultEvent: return _create!(Tag.prepareInventoryResultEvent)(this._get!(Tag.prepareInventoryResultEvent).witClone); break;
      case Tag.prepareItemCraftEvent: return _create!(Tag.prepareItemCraftEvent)(this._get!(Tag.prepareItemCraftEvent).witClone); break;
      case Tag.prepareSmithingEvent: return _create!(Tag.prepareSmithingEvent)(this._get!(Tag.prepareSmithingEvent).witClone); break;
      case Tag.smithItemEvent: return _create!(Tag.smithItemEvent)(this._get!(Tag.smithItemEvent).witClone); break;
      case Tag.tradeSelectEvent: return _create!(Tag.tradeSelectEvent)(this._get!(Tag.tradeSelectEvent).witClone); break;
      case Tag.vehicleBlockCollisionEvent: return _create!(Tag.vehicleBlockCollisionEvent)(this._get!(Tag.vehicleBlockCollisionEvent).witClone); break;
      case Tag.vehicleCollisionEvent: return _create!(Tag.vehicleCollisionEvent)(this._get!(Tag.vehicleCollisionEvent).witClone); break;
      case Tag.vehicleCreateEvent: return _create!(Tag.vehicleCreateEvent)(this._get!(Tag.vehicleCreateEvent).witClone); break;
      case Tag.vehicleDamageEvent: return _create!(Tag.vehicleDamageEvent)(this._get!(Tag.vehicleDamageEvent).witClone); break;
      case Tag.vehicleDestroyEvent: return _create!(Tag.vehicleDestroyEvent)(this._get!(Tag.vehicleDestroyEvent).witClone); break;
      case Tag.vehicleEnterEvent: return _create!(Tag.vehicleEnterEvent)(this._get!(Tag.vehicleEnterEvent).witClone); break;
      case Tag.vehicleEntityCollisionEvent: return _create!(Tag.vehicleEntityCollisionEvent)(this._get!(Tag.vehicleEntityCollisionEvent).witClone); break;
      case Tag.vehicleExitEvent: return _create!(Tag.vehicleExitEvent)(this._get!(Tag.vehicleExitEvent).witClone); break;
      case Tag.vehicleMoveEvent: return _create!(Tag.vehicleMoveEvent)(this._get!(Tag.vehicleMoveEvent).witClone); break;
      case Tag.vehicleUpdateEvent: return _create!(Tag.vehicleUpdateEvent)(this._get!(Tag.vehicleUpdateEvent).witClone); break;
      case Tag.prepareItemEnchantEvent: return _create!(Tag.prepareItemEnchantEvent)(this._get!(Tag.prepareItemEnchantEvent).witClone); break;
      case Tag.enchantItemEvent: return _create!(Tag.enchantItemEvent)(this._get!(Tag.enchantItemEvent).witClone); break;
      case Tag.mapInitializeEvent: return _create!(Tag.mapInitializeEvent)(this._get!(Tag.mapInitializeEvent).witClone); break;
      case Tag.hangingBreakEvent: return _create!(Tag.hangingBreakEvent)(this._get!(Tag.hangingBreakEvent).witClone); break;
      case Tag.hangingBreakByEntityEvent: return _create!(Tag.hangingBreakByEntityEvent)(this._get!(Tag.hangingBreakByEntityEvent).witClone); break;
      case Tag.hangingPlaceEvent: return _create!(Tag.hangingPlaceEvent)(this._get!(Tag.hangingPlaceEvent).witClone); break;
      case Tag.bellResonateEvent: return _create!(Tag.bellResonateEvent)(this._get!(Tag.bellResonateEvent).witClone); break;
      case Tag.bellRingEvent: return _create!(Tag.bellRingEvent)(this._get!(Tag.bellRingEvent).witClone); break;
      case Tag.blockBrushEvent: return _create!(Tag.blockBrushEvent)(this._get!(Tag.blockBrushEvent).witClone); break;
      case Tag.blockCookEvent: return _create!(Tag.blockCookEvent)(this._get!(Tag.blockCookEvent).witClone); break;
      case Tag.blockDamageAbortEvent: return _create!(Tag.blockDamageAbortEvent)(this._get!(Tag.blockDamageAbortEvent).witClone); break;
      case Tag.blockDispenseArmorEvent: return _create!(Tag.blockDispenseArmorEvent)(this._get!(Tag.blockDispenseArmorEvent).witClone); break;
      case Tag.blockDispenseLootEvent: return _create!(Tag.blockDispenseLootEvent)(this._get!(Tag.blockDispenseLootEvent).witClone); break;
      case Tag.blockDropItemEvent: return _create!(Tag.blockDropItemEvent)(this._get!(Tag.blockDropItemEvent).witClone); break;
      case Tag.blockExpEvent: return _create!(Tag.blockExpEvent)(this._get!(Tag.blockExpEvent).witClone); break;
      case Tag.blockFertilizeEvent: return _create!(Tag.blockFertilizeEvent)(this._get!(Tag.blockFertilizeEvent).witClone); break;
      case Tag.blockMultiPlaceEvent: return _create!(Tag.blockMultiPlaceEvent)(this._get!(Tag.blockMultiPlaceEvent).witClone); break;
      case Tag.blockReceiveGameEvent: return _create!(Tag.blockReceiveGameEvent)(this._get!(Tag.blockReceiveGameEvent).witClone); break;
      case Tag.blockShearEntityEvent: return _create!(Tag.blockShearEntityEvent)(this._get!(Tag.blockShearEntityEvent).witClone); break;
      case Tag.blockSpreadEvent: return _create!(Tag.blockSpreadEvent)(this._get!(Tag.blockSpreadEvent).witClone); break;
      case Tag.brewingStartEvent: return _create!(Tag.brewingStartEvent)(this._get!(Tag.brewingStartEvent).witClone); break;
      case Tag.campfireStartEvent: return _create!(Tag.campfireStartEvent)(this._get!(Tag.campfireStartEvent).witClone); break;
      case Tag.cauldronLevelChangeEvent: return _create!(Tag.cauldronLevelChangeEvent)(this._get!(Tag.cauldronLevelChangeEvent).witClone); break;
      case Tag.crafterCraftEvent: return _create!(Tag.crafterCraftEvent)(this._get!(Tag.crafterCraftEvent).witClone); break;
      case Tag.entityBlockFormEvent: return _create!(Tag.entityBlockFormEvent)(this._get!(Tag.entityBlockFormEvent).witClone); break;
      case Tag.fluidLevelChangeEvent: return _create!(Tag.fluidLevelChangeEvent)(this._get!(Tag.fluidLevelChangeEvent).witClone); break;
      case Tag.inventoryBlockStartEvent: return _create!(Tag.inventoryBlockStartEvent)(this._get!(Tag.inventoryBlockStartEvent).witClone); break;
      case Tag.leavesDecayEvent: return _create!(Tag.leavesDecayEvent)(this._get!(Tag.leavesDecayEvent).witClone); break;
      case Tag.moistureChangeEvent: return _create!(Tag.moistureChangeEvent)(this._get!(Tag.moistureChangeEvent).witClone); break;
      case Tag.sculkBloomEvent: return _create!(Tag.sculkBloomEvent)(this._get!(Tag.sculkBloomEvent).witClone); break;
      case Tag.vaultDisplayItemEvent: return _create!(Tag.vaultDisplayItemEvent)(this._get!(Tag.vaultDisplayItemEvent).witClone); break;
      case Tag.creatureSpawnEvent: return _create!(Tag.creatureSpawnEvent)(this._get!(Tag.creatureSpawnEvent).witClone); break;
      case Tag.enderDragonChangePhaseEvent: return _create!(Tag.enderDragonChangePhaseEvent)(this._get!(Tag.enderDragonChangePhaseEvent).witClone); break;
      case Tag.entityBreakDoorEvent: return _create!(Tag.entityBreakDoorEvent)(this._get!(Tag.entityBreakDoorEvent).witClone); break;
      case Tag.entityChangeBlockEvent: return _create!(Tag.entityChangeBlockEvent)(this._get!(Tag.entityChangeBlockEvent).witClone); break;
      case Tag.entityDamageByBlockEvent: return _create!(Tag.entityDamageByBlockEvent)(this._get!(Tag.entityDamageByBlockEvent).witClone); break;
      case Tag.entityDamageByEntityEvent: return _create!(Tag.entityDamageByEntityEvent)(this._get!(Tag.entityDamageByEntityEvent).witClone); break;
      case Tag.entityDropItemEvent: return _create!(Tag.entityDropItemEvent)(this._get!(Tag.entityDropItemEvent).witClone); break;
      case Tag.entityEnterBlockEvent: return _create!(Tag.entityEnterBlockEvent)(this._get!(Tag.entityEnterBlockEvent).witClone); break;
      case Tag.entityExhaustionEvent: return _create!(Tag.entityExhaustionEvent)(this._get!(Tag.entityExhaustionEvent).witClone); break;
      case Tag.entityInteractEvent: return _create!(Tag.entityInteractEvent)(this._get!(Tag.entityInteractEvent).witClone); break;
      case Tag.entityKnockbackEvent: return _create!(Tag.entityKnockbackEvent)(this._get!(Tag.entityKnockbackEvent).witClone); break;
      case Tag.entityPlaceEvent: return _create!(Tag.entityPlaceEvent)(this._get!(Tag.entityPlaceEvent).witClone); break;
      case Tag.entityPoseChangeEvent: return _create!(Tag.entityPoseChangeEvent)(this._get!(Tag.entityPoseChangeEvent).witClone); break;
      case Tag.entityPotionEffectEvent: return _create!(Tag.entityPotionEffectEvent)(this._get!(Tag.entityPotionEffectEvent).witClone); break;
      case Tag.entitySpellCastEvent: return _create!(Tag.entitySpellCastEvent)(this._get!(Tag.entitySpellCastEvent).witClone); break;
      case Tag.entityTargetLivingEntityEvent: return _create!(Tag.entityTargetLivingEntityEvent)(this._get!(Tag.entityTargetLivingEntityEvent).witClone); break;
      case Tag.entityToggleSwimEvent: return _create!(Tag.entityToggleSwimEvent)(this._get!(Tag.entityToggleSwimEvent).witClone); break;
      case Tag.explosionPrimeEvent: return _create!(Tag.explosionPrimeEvent)(this._get!(Tag.explosionPrimeEvent).witClone); break;
      case Tag.fireworkExplodeEvent: return _create!(Tag.fireworkExplodeEvent)(this._get!(Tag.fireworkExplodeEvent).witClone); break;
      case Tag.foodLevelChangeEvent: return _create!(Tag.foodLevelChangeEvent)(this._get!(Tag.foodLevelChangeEvent).witClone); break;
      case Tag.itemDespawnEvent: return _create!(Tag.itemDespawnEvent)(this._get!(Tag.itemDespawnEvent).witClone); break;
      case Tag.itemMergeEvent: return _create!(Tag.itemMergeEvent)(this._get!(Tag.itemMergeEvent).witClone); break;
      case Tag.itemSpawnEvent: return _create!(Tag.itemSpawnEvent)(this._get!(Tag.itemSpawnEvent).witClone); break;
      case Tag.piglinBarterEvent: return _create!(Tag.piglinBarterEvent)(this._get!(Tag.piglinBarterEvent).witClone); break;
      case Tag.projectileHitEvent: return _create!(Tag.projectileHitEvent)(this._get!(Tag.projectileHitEvent).witClone); break;
      case Tag.projectileLaunchEvent: return _create!(Tag.projectileLaunchEvent)(this._get!(Tag.projectileLaunchEvent).witClone); break;
      case Tag.sheepDyeWoolEvent: return _create!(Tag.sheepDyeWoolEvent)(this._get!(Tag.sheepDyeWoolEvent).witClone); break;
      case Tag.sheepRegrowWoolEvent: return _create!(Tag.sheepRegrowWoolEvent)(this._get!(Tag.sheepRegrowWoolEvent).witClone); break;
      case Tag.slimeSplitEvent: return _create!(Tag.slimeSplitEvent)(this._get!(Tag.slimeSplitEvent).witClone); break;
      case Tag.striderTemperatureChangeEvent: return _create!(Tag.striderTemperatureChangeEvent)(this._get!(Tag.striderTemperatureChangeEvent).witClone); break;
      case Tag.villagerAcquireTradeEvent: return _create!(Tag.villagerAcquireTradeEvent)(this._get!(Tag.villagerAcquireTradeEvent).witClone); break;
      case Tag.villagerCareerChangeEvent: return _create!(Tag.villagerCareerChangeEvent)(this._get!(Tag.villagerCareerChangeEvent).witClone); break;
      case Tag.villagerReplenishTradeEvent: return _create!(Tag.villagerReplenishTradeEvent)(this._get!(Tag.villagerReplenishTradeEvent).witClone); break;
      case Tag.wardenAngerChangeEvent: return _create!(Tag.wardenAngerChangeEvent)(this._get!(Tag.wardenAngerChangeEvent).witClone); break;
      case Tag.areaEffectCloudApplyEvent: return _create!(Tag.areaEffectCloudApplyEvent)(this._get!(Tag.areaEffectCloudApplyEvent).witClone); break;
      case Tag.arrowBodyCountChangeEvent: return _create!(Tag.arrowBodyCountChangeEvent)(this._get!(Tag.arrowBodyCountChangeEvent).witClone); break;
      case Tag.batToggleSleepEvent: return _create!(Tag.batToggleSleepEvent)(this._get!(Tag.batToggleSleepEvent).witClone); break;
      case Tag.creeperPowerEvent: return _create!(Tag.creeperPowerEvent)(this._get!(Tag.creeperPowerEvent).witClone); break;
      case Tag.entityCombustByBlockEvent: return _create!(Tag.entityCombustByBlockEvent)(this._get!(Tag.entityCombustByBlockEvent).witClone); break;
      case Tag.entityCombustByEntityEvent: return _create!(Tag.entityCombustByEntityEvent)(this._get!(Tag.entityCombustByEntityEvent).witClone); break;
      case Tag.entityKnockbackByEntityEvent: return _create!(Tag.entityKnockbackByEntityEvent)(this._get!(Tag.entityKnockbackByEntityEvent).witClone); break;
      case Tag.entityPortalEnterEvent: return _create!(Tag.entityPortalEnterEvent)(this._get!(Tag.entityPortalEnterEvent).witClone); break;
      case Tag.entityPortalExitEvent: return _create!(Tag.entityPortalExitEvent)(this._get!(Tag.entityPortalExitEvent).witClone); break;
      case Tag.entityRemoveEvent: return _create!(Tag.entityRemoveEvent)(this._get!(Tag.entityRemoveEvent).witClone); break;
      case Tag.entityTargetBlockEvent: return _create!(Tag.entityTargetBlockEvent)(this._get!(Tag.entityTargetBlockEvent).witClone); break;
      case Tag.entityUnleashEvent: return _create!(Tag.entityUnleashEvent)(this._get!(Tag.entityUnleashEvent).witClone); break;
      case Tag.expBottleEvent: return _create!(Tag.expBottleEvent)(this._get!(Tag.expBottleEvent).witClone); break;
      case Tag.horseJumpEvent: return _create!(Tag.horseJumpEvent)(this._get!(Tag.horseJumpEvent).witClone); break;
      case Tag.lingeringPotionSplashEvent: return _create!(Tag.lingeringPotionSplashEvent)(this._get!(Tag.lingeringPotionSplashEvent).witClone); break;
      case Tag.pigZapEvent: return _create!(Tag.pigZapEvent)(this._get!(Tag.pigZapEvent).witClone); break;
      case Tag.pigZombieAngerEvent: return _create!(Tag.pigZombieAngerEvent)(this._get!(Tag.pigZombieAngerEvent).witClone); break;
      case Tag.potionSplashEvent: return _create!(Tag.potionSplashEvent)(this._get!(Tag.potionSplashEvent).witClone); break;
      case Tag.spawnerSpawnEvent: return _create!(Tag.spawnerSpawnEvent)(this._get!(Tag.spawnerSpawnEvent).witClone); break;
      case Tag.trialSpawnerSpawnEvent: return _create!(Tag.trialSpawnerSpawnEvent)(this._get!(Tag.trialSpawnerSpawnEvent).witClone); break;
      case Tag.villagerReputationChangeEvent: return _create!(Tag.villagerReputationChangeEvent)(this._get!(Tag.villagerReputationChangeEvent).witClone); break;
      case Tag.asyncPlayerChatEvent: return _create!(Tag.asyncPlayerChatEvent)(this._get!(Tag.asyncPlayerChatEvent).witClone); break;
      case Tag.asyncPlayerPreLoginEvent: return _create!(Tag.asyncPlayerPreLoginEvent)(this._get!(Tag.asyncPlayerPreLoginEvent).witClone); break;
      case Tag.playerAdvancementDoneEvent: return _create!(Tag.playerAdvancementDoneEvent)(this._get!(Tag.playerAdvancementDoneEvent).witClone); break;
      case Tag.playerAnimationEvent: return _create!(Tag.playerAnimationEvent)(this._get!(Tag.playerAnimationEvent).witClone); break;
      case Tag.playerArmorStandManipulateEvent: return _create!(Tag.playerArmorStandManipulateEvent)(this._get!(Tag.playerArmorStandManipulateEvent).witClone); break;
      case Tag.playerBucketEntityEvent: return _create!(Tag.playerBucketEntityEvent)(this._get!(Tag.playerBucketEntityEvent).witClone); break;
      case Tag.playerChangedWorldEvent: return _create!(Tag.playerChangedWorldEvent)(this._get!(Tag.playerChangedWorldEvent).witClone); break;
      case Tag.playerChannelEvent: return _create!(Tag.playerChannelEvent)(this._get!(Tag.playerChannelEvent).witClone); break;
      case Tag.playerCommandPreprocessEvent: return _create!(Tag.playerCommandPreprocessEvent)(this._get!(Tag.playerCommandPreprocessEvent).witClone); break;
      case Tag.playerEditBookEvent: return _create!(Tag.playerEditBookEvent)(this._get!(Tag.playerEditBookEvent).witClone); break;
      case Tag.playerElytraBoostEvent: return _create!(Tag.playerElytraBoostEvent)(this._get!(Tag.playerElytraBoostEvent).witClone); break;
      case Tag.playerExpCooldownChangeEvent: return _create!(Tag.playerExpCooldownChangeEvent)(this._get!(Tag.playerExpCooldownChangeEvent).witClone); break;
      case Tag.playerHarvestBlockEvent: return _create!(Tag.playerHarvestBlockEvent)(this._get!(Tag.playerHarvestBlockEvent).witClone); break;
      case Tag.playerHideEntityEvent: return _create!(Tag.playerHideEntityEvent)(this._get!(Tag.playerHideEntityEvent).witClone); break;
      case Tag.playerItemBreakEvent: return _create!(Tag.playerItemBreakEvent)(this._get!(Tag.playerItemBreakEvent).witClone); break;
      case Tag.playerItemMendEvent: return _create!(Tag.playerItemMendEvent)(this._get!(Tag.playerItemMendEvent).witClone); break;
      case Tag.playerKickEvent: return _create!(Tag.playerKickEvent)(this._get!(Tag.playerKickEvent).witClone); break;
      case Tag.playerLeashEntityEvent: return _create!(Tag.playerLeashEntityEvent)(this._get!(Tag.playerLeashEntityEvent).witClone); break;
      case Tag.playerLevelChangeEvent: return _create!(Tag.playerLevelChangeEvent)(this._get!(Tag.playerLevelChangeEvent).witClone); break;
      case Tag.playerLocaleChangeEvent: return _create!(Tag.playerLocaleChangeEvent)(this._get!(Tag.playerLocaleChangeEvent).witClone); break;
      case Tag.playerNameEntityEvent: return _create!(Tag.playerNameEntityEvent)(this._get!(Tag.playerNameEntityEvent).witClone); break;
      case Tag.playerOpenSignEvent: return _create!(Tag.playerOpenSignEvent)(this._get!(Tag.playerOpenSignEvent).witClone); break;
      case Tag.playerPortalEvent: return _create!(Tag.playerPortalEvent)(this._get!(Tag.playerPortalEvent).witClone); break;
      case Tag.playerPreLoginEvent: return _create!(Tag.playerPreLoginEvent)(this._get!(Tag.playerPreLoginEvent).witClone); break;
      case Tag.playerRiptideEvent: return _create!(Tag.playerRiptideEvent)(this._get!(Tag.playerRiptideEvent).witClone); break;
      case Tag.playerShearEntityEvent: return _create!(Tag.playerShearEntityEvent)(this._get!(Tag.playerShearEntityEvent).witClone); break;
      case Tag.playerShowEntityEvent: return _create!(Tag.playerShowEntityEvent)(this._get!(Tag.playerShowEntityEvent).witClone); break;
      case Tag.playerSpawnChangeEvent: return _create!(Tag.playerSpawnChangeEvent)(this._get!(Tag.playerSpawnChangeEvent).witClone); break;
      case Tag.playerStatisticIncrementEvent: return _create!(Tag.playerStatisticIncrementEvent)(this._get!(Tag.playerStatisticIncrementEvent).witClone); break;
      case Tag.playerSwapHandsEvent: return _create!(Tag.playerSwapHandsEvent)(this._get!(Tag.playerSwapHandsEvent).witClone); break;
      case Tag.playerTakeLecternBookEvent: return _create!(Tag.playerTakeLecternBookEvent)(this._get!(Tag.playerTakeLecternBookEvent).witClone); break;
      case Tag.playerUnleashEntityEvent: return _create!(Tag.playerUnleashEntityEvent)(this._get!(Tag.playerUnleashEntityEvent).witClone); break;
      case Tag.playerVelocityEvent: return _create!(Tag.playerVelocityEvent)(this._get!(Tag.playerVelocityEvent).witClone); break;
      case Tag.playerInputEvent: return _create!(Tag.playerInputEvent)(this._get!(Tag.playerInputEvent).witClone); break;
      case Tag.playerInteractAtEntityEvent: return _create!(Tag.playerInteractAtEntityEvent)(this._get!(Tag.playerInteractAtEntityEvent).witClone); break;
      case Tag.playerLinksSendEvent: return _create!(Tag.playerLinksSendEvent)(this._get!(Tag.playerLinksSendEvent).witClone); break;
      case Tag.playerPickupArrowEvent: return _create!(Tag.playerPickupArrowEvent)(this._get!(Tag.playerPickupArrowEvent).witClone); break;
      case Tag.playerRecipeBookClickEvent: return _create!(Tag.playerRecipeBookClickEvent)(this._get!(Tag.playerRecipeBookClickEvent).witClone); break;
      case Tag.playerRecipeBookSettingsChangeEvent: return _create!(Tag.playerRecipeBookSettingsChangeEvent)(this._get!(Tag.playerRecipeBookSettingsChangeEvent).witClone); break;
      case Tag.playerRecipeDiscoverEvent: return _create!(Tag.playerRecipeDiscoverEvent)(this._get!(Tag.playerRecipeDiscoverEvent).witClone); break;
      case Tag.playerRegisterChannelEvent: return _create!(Tag.playerRegisterChannelEvent)(this._get!(Tag.playerRegisterChannelEvent).witClone); break;
      case Tag.playerResourcePackStatusEvent: return _create!(Tag.playerResourcePackStatusEvent)(this._get!(Tag.playerResourcePackStatusEvent).witClone); break;
      case Tag.playerSpawnLocationEvent: return _create!(Tag.playerSpawnLocationEvent)(this._get!(Tag.playerSpawnLocationEvent).witClone); break;
      case Tag.playerUnregisterChannelEvent: return _create!(Tag.playerUnregisterChannelEvent)(this._get!(Tag.playerUnregisterChannelEvent).witClone); break;
      case Tag.raidFinishEvent: return _create!(Tag.raidFinishEvent)(this._get!(Tag.raidFinishEvent).witClone); break;
      case Tag.raidSpawnWaveEvent: return _create!(Tag.raidSpawnWaveEvent)(this._get!(Tag.raidSpawnWaveEvent).witClone); break;
      case Tag.raidStopEvent: return _create!(Tag.raidStopEvent)(this._get!(Tag.raidStopEvent).witClone); break;
      case Tag.raidTriggerEvent: return _create!(Tag.raidTriggerEvent)(this._get!(Tag.raidTriggerEvent).witClone); break;
      case Tag.lightningStrikeEvent: return _create!(Tag.lightningStrikeEvent)(this._get!(Tag.lightningStrikeEvent).witClone); break;
    }
  }
}