[ci skip] Cleanup events (#10202)

patches/api/Add-BeaconEffectEvent.patch

@@ -18,18 +18,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
 +import org.bukkit.potion.PotionEffect;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a beacon effect is being applied to a player.
 + */
 +public class BeaconEffectEvent extends BlockEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    private PotionEffect effect;
-+    private Player player;
-+    private boolean primary;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Player player;
++    private final boolean primary;
++    private PotionEffect effect;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public BeaconEffectEvent(@NotNull Block block, @NotNull PotionEffect effect, @NotNull Player player, boolean primary) {
 +        super(block);
 +        this.effect = effect;
@@ -37,16 +42,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.primary = primary;
 +    }
 +
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    @Override
-+    public void setCancelled(boolean cancelled) {
-+        this.cancelled = cancelled;
-+    }
-+
 +    /**
 +     * Gets the potion effect being applied.
 +     *
@@ -54,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PotionEffect getEffect() {
-+        return effect;
++        return this.effect;
 +    }
 +
 +    /**
@@ -73,26 +68,36 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Player getPlayer() {
-+        return player;
++        return this.player;
 +    }
 +
 +    /**
 +     * Gets whether the effect is a primary beacon effect.
 +     *
-+     * @return true if this event represents a primary effect
++     * @return {@code true} if this event represents a primary effect
 +     */
 +    public boolean isPrimary() {
-+        return primary;
++        return this.primary;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-BellRevealRaiderEvent.patch

@@ -13,27 +13,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package io.papermc.paper.event.block;
 +
 +import org.bukkit.block.Block;
-+import org.bukkit.entity.Entity;
 +import org.bukkit.entity.Raider;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
-+ * Called when a {@link org.bukkit.entity.Raider} is revealed by a bell.
++ * Called when a {@link Raider} is revealed by a bell.
++ *
 + * @deprecated use {@link org.bukkit.event.block.BellResonateEvent}
 + */
 +@Deprecated
 +public class BellRevealRaiderEvent extends BlockEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
 +
-+    private boolean cancelled = false;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Raider raider;
++    private boolean cancelled;
 +
-+    public BellRevealRaiderEvent(@NotNull Block theBlock, @NotNull Entity raider) {
++    @ApiStatus.Internal
++    public BellRevealRaiderEvent(@NotNull Block theBlock, @NotNull Raider raider) {
 +        super(theBlock);
-+        this.raider = (Raider) raider;
++        this.raider = raider;
 +    }
 +
 +    /**
@@ -43,12 +46,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Raider getEntity() {
-+        return raider;
++        return this.raider;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
@@ -63,10 +66,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public @NotNull HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    public static @NotNull HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-BellRingEvent.patch

@@ -17,17 +17,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.block.Block;
 +import org.bukkit.block.BlockFace;
 +import org.bukkit.entity.Entity;
-+import org.bukkit.event.Cancellable;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Called when a bell is rung.
++ *
 + * @deprecated use {@link org.bukkit.event.block.BellRingEvent}
 + */
 +@Deprecated
-+public class BellRingEvent extends org.bukkit.event.block.BellRingEvent implements Cancellable {
++public class BellRingEvent extends org.bukkit.event.block.BellRingEvent {
 +
++    @ApiStatus.Internal
 +    public BellRingEvent(@NotNull Block block, @NotNull BlockFace direction, @Nullable Entity entity) {
 +        super(block, direction, entity);
 +    }

patches/api/Add-BlockBreakBlockEvent.patch

@@ -14,9 +14,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.block.Block;
 +import org.bukkit.event.HandlerList;
-+import org.bukkit.event.block.BlockEvent;
 +import org.bukkit.event.block.BlockExpEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +import java.util.List;
@@ -30,9 +30,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private final List<ItemStack> drops;
 +    private final Block source;
++    private final List<ItemStack> drops;
 +
++    @ApiStatus.Internal
 +    public BlockBreakBlockEvent(@NotNull Block block, @NotNull Block source, @NotNull List<ItemStack> drops) {
 +        super(block, 0);
 +        this.source = source;
@@ -40,13 +41,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Get the drops of this event
++     * Gets the drops of this event
 +     *
 +     * @return the drops
 +     */
 +    @NotNull
 +    public List<ItemStack> getDrops() {
-+        return drops;
++        return this.drops;
 +    }
 +
 +    /**
@@ -56,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Block getSource() {
-+        return source;
++        return this.source;
 +    }
 +
 +    @NotNull

patches/api/Add-BlockFailedDispenseEvent.patch

@@ -15,16 +15,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.block.Block;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a block tries to dispense an item, but its inventory is empty.
 + */
 +public class BlockFailedDispenseEvent extends BlockEvent {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private boolean shouldPlayEffect = true;
 +
++    @ApiStatus.Internal
 +    public BlockFailedDispenseEvent(@NotNull Block theBlock) {
 +        super(theBlock);
 +    }
@@ -46,8 +49,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * {@inheritDoc}
-+     *
 +     * @return {@link #shouldPlayEffect()}
 +     */
 +    @Override
@@ -57,13 +58,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    public @NotNull
-+    HandlerList getHandlers() {
-+        return handlers;
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
 +    }
 +
-+    public static @NotNull
-+    HandlerList getHandlerList() {
-+        return handlers;
++    public static @NotNull HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-BlockLockCheckEvent.patch

@@ -33,23 +33,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import io.papermc.paper.block.LockableTileState;
 +import net.kyori.adventure.sound.Sound;
 +import net.kyori.adventure.text.Component;
-+import org.bukkit.Nameable;
 +import org.bukkit.block.Block;
-+import org.bukkit.block.BlockState;
-+import org.bukkit.block.Lockable;
-+import org.bukkit.block.TileState;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +import java.util.Objects;
 +
 +/**
-+ * Called when the server tries to check the lock on a lockable tile entity.
-+ * @see #setResult(Result) to change behavior
++ * Called when the server tries to check the lock on a lockable block entity.
++ * <br>
++ * See {@link #setResult(Result)} to change behavior
 + */
 +public class BlockLockCheckEvent extends BlockEvent {
 +
@@ -57,11 +55,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private final LockableTileState state;
 +    private final Player player;
-+    private ItemStack itemStack;
-+    private Result result = Result.DEFAULT;
 +    private Component lockedMessage;
 +    private Sound lockedSound;
++    private ItemStack itemStack;
++    private Result result = Result.DEFAULT;
 +
++    @ApiStatus.Internal
 +    public BlockLockCheckEvent(final @NotNull Block block, final @NotNull LockableTileState state, final @NotNull Player player, final @NotNull Component lockedMessage, final @NotNull Sound lockedSound) {
 +        super(block);
 +        this.state = state;
@@ -71,7 +70,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets the snapshot {@link LockableTileState} of the tile entity
++     * Gets the snapshot {@link LockableTileState} of the block entity
 +     * whose lock is being checked.
 +     *
 +     * @return the snapshot block state.
@@ -105,11 +104,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Sets the itemstack that will be used as the key item.
 +     *
-+     * @param stack the stack to use as a key (or null to fall back to the player's main hand item)
++     * @param stack the stack to use as a key
 +     * @see #resetKeyItem() to clear a custom key item
 +     */
 +    public void setKeyItem(@NotNull ItemStack stack) {
-+        Preconditions.checkNotNull(stack, "stack is null");
++        Preconditions.checkArgument(stack != null, "stack cannot be null");
 +        this.itemStack = stack;
 +    }
 +
@@ -123,7 +122,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Checks if a custom key stack has been set.
 +     *
-+     * @return true if a custom key itemstack has been set
++     * @return {@code true} if a custom key itemstack has been set
 +     */
 +    public boolean isUsingCustomKeyItemStack() {
 +        return this.itemStack != null;
@@ -140,11 +139,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets the result of this event. {@link org.bukkit.event.Event.Result#DEFAULT} is the default
-+     * allowing the vanilla logic to check the lock of this block. Set to {@link org.bukkit.event.Event.Result#ALLOW}
-+     * or {@link org.bukkit.event.Event.Result#DENY} to override that behavior.
++     * Gets the result of this event. {@link Result#DEFAULT} is the default
++     * allowing the vanilla logic to check the lock of this block. Set to {@link Result#ALLOW}
++     * or {@link Result#DENY} to override that behavior.
 +     * <p>
-+     * Setting this to {@link org.bukkit.event.Event.Result#ALLOW} bypasses the spectator check.
++     * Setting this to {@link Result#ALLOW} bypasses the spectator check.
 +     *
 +     * @param result the result of this event
 +     */
@@ -153,11 +152,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Shorthand method to set the {@link #getResult()} to {@link org.bukkit.event.Event.Result#DENY},
++     * Shorthand method to set the {@link #getResult()} to {@link Result#DENY},
 +     * the locked message and locked sound.
 +     *
-+     * @param lockedMessage the message to show if locked (or null for none)
-+     * @param lockedSound the sound to play if locked (or null for none)
++     * @param lockedMessage the message to show if locked (or {@code null} for none)
++     * @param lockedSound the sound to play if locked (or {@code null} for none)
 +     */
 +    public void denyWithMessageAndSound(@Nullable Component lockedMessage, @Nullable Sound lockedSound) {
 +        this.result = Result.DENY;
@@ -169,7 +168,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Gets the locked message that will be sent if the
 +     * player cannot open the block.
 +     *
-+     * @return the locked message (or null if none)
++     * @return the locked message (or {@code null} if none)
 +     */
 +    public @Nullable Component getLockedMessage() {
 +        return this.lockedMessage;
@@ -179,7 +178,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Sets the locked message that will be sent if the
 +     * player cannot open the block.
 +     *
-+     * @param lockedMessage the locked message (or null for none)
++     * @param lockedMessage the locked message (or {@code null} for none)
 +     */
 +    public void setLockedMessage(@Nullable Component lockedMessage) {
 +        this.lockedMessage = lockedMessage;
@@ -189,7 +188,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Gets the locked sound that will play if the
 +     * player cannot open the block.
 +     *
-+     * @return the locked sound (or null if none)
++     * @return the locked sound (or {@code null} if none)
 +     */
 +    public @Nullable Sound getLockedSound() {
 +        return this.lockedSound;
@@ -199,7 +198,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Sets the locked sound that will play if the
 +     * player cannot open the block.
 +     *
-+     * @param lockedSound the locked sound (or null for none)
++     * @param lockedSound the locked sound (or {@code null} for none)
 +     */
 +    public void setLockedSound(@Nullable Sound lockedSound) {
 +        this.lockedSound = lockedSound;

patches/api/Add-BlockPreDispenseEvent.patch

@@ -17,14 +17,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +public class BlockPreDispenseEvent extends BlockEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled = false;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final ItemStack itemStack;
 +    private final int slot;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public BlockPreDispenseEvent(@NotNull Block block, @NotNull ItemStack itemStack, int slot) {
 +        super(block);
 +        this.itemStack = itemStack;
@@ -38,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItemStack() {
-+        return itemStack;
++        return this.itemStack;
 +    }
 +
 +    /**
@@ -47,17 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return The inventory slot
 +     */
 +    public int getSlot() {
-+        return slot;
-+    }
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
++        return this.slot;
 +    }
 +
 +    @Override
@@ -69,4 +64,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
 +    }
++
++    @NotNull
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
 +}

patches/api/Add-CompostItemEvent-and-EntityCompostItemEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.block.BlockEvent;
 +import org.bukkit.event.inventory.InventoryMoveItemEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -30,6 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final ItemStack item;
 +    private boolean willRaiseLevel;
 +
++    @ApiStatus.Internal
 +    public CompostItemEvent(@NotNull Block composter, @NotNull ItemStack item, boolean willRaiseLevel) {
 +        super(composter);
 +        this.item = item;
@@ -49,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets whether the composter will rise a level.
 +     *
-+     * @return true if successful
++     * @return {@code true} if successful
 +     */
 +    public boolean willRaiseLevel() {
 +        return this.willRaiseLevel;
@@ -58,7 +60,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Sets whether the composter will rise a level.
 +     *
-+     * @param willRaiseLevel true if the composter should rise a level
++     * @param willRaiseLevel {@code true} if the composter should rise a level
 +     */
 +    public void setWillRaiseLevel(boolean willRaiseLevel) {
 +        this.willRaiseLevel = willRaiseLevel;
@@ -88,6 +90,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Entity;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -95,12 +98,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class EntityCompostItemEvent extends CompostItemEvent implements Cancellable {
 +
-+    private final Entity who;
++    private final Entity entity;
 +    private boolean cancelled;
 +
-+    public EntityCompostItemEvent(@NotNull Entity who, @NotNull Block composter, @NotNull ItemStack item, boolean willRaiseLevel) {
++    @ApiStatus.Internal
++    public EntityCompostItemEvent(@NotNull Entity entity, @NotNull Block composter, @NotNull ItemStack item, boolean willRaiseLevel) {
 +        super(composter, item, willRaiseLevel);
-+        this.who = who;
++        this.entity = entity;
 +    }
 +
 +    /**
@@ -110,7 +114,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getEntity() {
-+        return this.who;
++        return this.entity;
 +    }
 +
 +    @Override

patches/api/Add-ElderGuardianAppearanceEvent.patch

@@ -13,28 +13,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package io.papermc.paper.event.entity;
 +
 +import org.bukkit.entity.ElderGuardian;
-+import org.bukkit.entity.Entity;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
-+import java.util.Collections;
-+import java.util.List;
-+
 +/**
-+ * Is called when an {@link org.bukkit.entity.ElderGuardian} appears in front of a {@link org.bukkit.entity.Player}.
++ * Is called when an {@link ElderGuardian} appears in front of a {@link Player}.
 + */
 +public class ElderGuardianAppearanceEvent extends EntityEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final Player affectedPlayer;
++    private boolean cancelled;
 +
-+    public ElderGuardianAppearanceEvent(@NotNull Entity what, @NotNull Player affectedPlayer) {
-+        super(what);
++    @ApiStatus.Internal
++    public ElderGuardianAppearanceEvent(@NotNull ElderGuardian guardian, @NotNull Player affectedPlayer) {
++        super(guardian);
 +        this.affectedPlayer = affectedPlayer;
 +    }
 +
@@ -45,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Player getAffectedPlayer() {
-+        return affectedPlayer;
++        return this.affectedPlayer;
 +    }
 +
 +    /**
@@ -55,12 +53,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ElderGuardian getEntity() {
-+        return (ElderGuardian) entity;
++        return (ElderGuardian) super.getEntity();
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -71,11 +69,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-EntityDyeEvent-and-CollarColorable-interface.patch

@@ -44,26 +44,32 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package io.papermc.paper.event.entity;
 +
 +import org.bukkit.DyeColor;
++import org.bukkit.entity.Cat;
 +import org.bukkit.entity.Entity;
 +import org.bukkit.entity.Player;
++import org.bukkit.entity.Sheep;
++import org.bukkit.entity.Wolf;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
-+ * Called when an entity is dyed. Currently, this is called for {@link org.bukkit.entity.Sheep}
-+ * being dyed, and {@link org.bukkit.entity.Wolf}/{@link org.bukkit.entity.Cat} collars being dyed.
++ * Called when an entity is dyed. Currently, this is called for {@link Sheep}
++ * being dyed, and {@link Wolf}/{@link Cat} collars being dyed.
 + */
 +public class EntityDyeEvent extends EntityEvent implements Cancellable {
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private DyeColor dyeColor;
 +    private final Player player;
-+    private boolean cancel;
++    private DyeColor dyeColor;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EntityDyeEvent(@NotNull Entity entity, @NotNull DyeColor dyeColor, @Nullable Player player) {
 +        super(entity);
 +        this.dyeColor = dyeColor;
@@ -91,20 +97,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Returns the player dyeing the entity, if available.
 +     *
-+     * @return player or null
++     * @return player or {@code null}
 +     */
 +    public @Nullable Player getPlayer() {
-+        return player;
++        return this.player;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return this.cancel;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @Override

patches/api/Add-EntityFertilizeEggEvent.patch

@@ -12,26 +12,28 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.entity;
 +
-+import com.google.common.base.Preconditions;
++import org.bukkit.Material;
 +import org.bukkit.entity.LivingEntity;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityBreedEvent;
 +import org.bukkit.event.entity.EntityEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Called when two entities mate and the mating process results in a fertilization.
-+ * Fertilization differs from normal breeding, as represented by the {@link org.bukkit.event.entity.EntityBreedEvent}, as
++ * Fertilization differs from normal breeding, as represented by the {@link EntityBreedEvent}, as
 + * it does not result in the immediate creation of the child entity in the world.
 + * <p>
 + * An example of this would be:
 + * <ul>
-+ * <li>A frog being marked as "is_pregnant" and laying {@link org.bukkit.Material#FROGSPAWN} later.</li>
-+ * <li>Sniffers producing the {@link org.bukkit.Material#SNIFFER_EGG} item, which needs to be placed before it can begin to hatch.</li>
-+ * <li>A turtle being marked with "HasEgg" and laying a {@link org.bukkit.Material#TURTLE_EGG} later.</li>
++ * <li>A frog being marked as "is_pregnant" and laying {@link Material#FROGSPAWN} later.</li>
++ * <li>Sniffers producing the {@link Material#SNIFFER_EGG} item, which needs to be placed before it can begin to hatch.</li>
++ * <li>A turtle being marked with "HasEgg" and laying a {@link Material#TURTLE_EGG} later.</li>
 + * </ul>
 + *
 + * The event hence only exposes the two parent entities in the fertilization process and cannot provide the child entity, as it will only exist at a later point in time.
@@ -46,14 +48,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final ItemStack bredWith;
 +    private int experience;
 +
-+    private boolean cancel;
++    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public EntityFertilizeEggEvent(@NotNull LivingEntity mother, @NotNull LivingEntity father, @Nullable Player breeder, @Nullable ItemStack bredWith, int experience) {
 +        super(mother);
-+        Preconditions.checkArgument(mother != null, "Cannot have null mother");
-+        Preconditions.checkArgument(father != null, "Cannot have null father");
-+
-+        // Breeder can be null in the case of spontaneous conception
 +        this.mother = mother;
 +        this.father = father;
 +        this.breeder = breeder;
@@ -64,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public LivingEntity getEntity() {
-+        return (LivingEntity) entity;
++        return (LivingEntity) super.getEntity();
 +    }
 +
 +    /**
@@ -75,7 +74,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public LivingEntity getMother() {
-+        return mother;
++        return this.mother;
 +    }
 +
 +    /**
@@ -86,28 +85,28 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public LivingEntity getFather() {
-+        return father;
++        return this.father;
 +    }
 +
 +    /**
-+     * Gets the Entity responsible for fertilization. Breeder is null for spontaneous
++     * Gets the Entity responsible for fertilization. Breeder is {@code null} for spontaneous
 +     * conception.
 +     *
-+     * @return The Entity who initiated breeding.
++     * @return The Entity who initiated fertilization.
 +     */
 +    @Nullable
 +    public Player getBreeder() {
-+        return breeder;
++        return this.breeder;
 +    }
 +
 +    /**
 +     * The ItemStack that was used to initiate fertilization, if present.
 +     *
-+     * @return ItemStack used to initiate breeding.
++     * @return ItemStack used to initiate fertilization.
 +     */
 +    @Nullable
 +    public ItemStack getBredWith() {
-+        return bredWith;
++        return this.bredWith;
 +    }
 +
 +    /**
@@ -116,7 +115,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return experience amount
 +     */
 +    public int getExperience() {
-+        return experience;
++        return this.experience;
 +    }
 +
 +    /**
@@ -131,12 +130,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull

patches/api/Add-EntityInsideBlockEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -58,6 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final Block block;
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public EntityInsideBlockEvent(@NotNull Entity entity, @NotNull Block block) {
 +        super(entity);
 +        this.block = block;
@@ -70,12 +72,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Block getBlock() {
-+        return block;
++        return this.block;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Add-EntityKnockbackByEntityEvent-and-EntityPushedByE.patch

@@ -18,16 +18,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Entity;
 +import org.bukkit.entity.LivingEntity;
 +import org.bukkit.util.Vector;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when an Entity is knocked back by the hit of another Entity. The acceleration
 + * vector can be modified. If this event is cancelled, the entity is not knocked back.
-+ *
 + */
 +public class EntityKnockbackByEntityEvent extends EntityPushedByEntityAttackEvent {
++
 +    private final float knockbackStrength;
 +
++    @ApiStatus.Internal
 +    public EntityKnockbackByEntityEvent(@NotNull LivingEntity entity, @NotNull Entity hitBy, float knockbackStrength, @NotNull Vector acceleration) {
 +        super(entity, hitBy, acceleration);
 +        this.knockbackStrength = knockbackStrength;
@@ -46,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the original knockback strength.
 +     */
 +    public float getKnockbackStrength() {
-+        return knockbackStrength;
++        return this.knockbackStrength;
 +    }
 +
 +    /**
@@ -71,6 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
 +import org.bukkit.util.Vector;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -82,38 +85,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class EntityPushedByEntityAttackEvent extends EntityEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final @NotNull Entity pushedBy;
 +    private final @NotNull Vector acceleration;
-+    private boolean cancelled = false;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EntityPushedByEntityAttackEvent(@NotNull Entity entity, @NotNull Entity pushedBy, @NotNull Vector acceleration) {
 +        super(entity);
 +        this.pushedBy = pushedBy;
 +        this.acceleration = acceleration;
 +    }
 +
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
-+    }
-+
 +    /**
 +     * Gets the entity which pushed the affected entity.
 +     *
@@ -121,7 +106,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getPushedBy() {
-+        return pushedBy;
++        return this.pushedBy;
 +    }
 +
 +    /**
@@ -131,6 +116,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Vector getAcceleration() {
-+        return acceleration;
++        return this.acceleration;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-EntityLoadCrossbowEvent.patch

@@ -25,12 +25,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Called when a LivingEntity loads a crossbow with a projectile.
 + */
 +public class EntityLoadCrossbowEvent extends EntityEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final ItemStack crossbow;
 +    private final EquipmentSlot hand;
-+    private boolean cancelled;
++
 +    private boolean consumeItem = true;
++    private boolean cancelled;
 +
 +    @ApiStatus.Internal
 +    public EntityLoadCrossbowEvent(@NotNull LivingEntity entity, @NotNull ItemStack crossbow, @NotNull EquipmentSlot hand) {
@@ -42,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public LivingEntity getEntity() {
-+        return (LivingEntity) entity;
++        return (LivingEntity) super.getEntity();
 +    }
 +
 +    /**
@@ -52,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getCrossbow() {
-+        return crossbow;
++        return this.crossbow;
 +    }
 +
 +    /**
@@ -62,19 +64,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public EquipmentSlot getHand() {
-+        return hand;
++        return this.hand;
 +    }
 +
 +    /**
-+     *
 +     * @return should the itemstack be consumed
 +     */
 +    public boolean shouldConsumeItem() {
-+        return consumeItem;
++        return this.consumeItem;
 +    }
 +
 +    /**
-+     *
 +     * @param consume should the item be consumed
 +     */
 +    public void setConsumeItem(boolean consume) {
@@ -83,14 +83,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
-+     * Set whether or not to cancel the crossbow being loaded. If canceled, the
++     * Set whether to cancel the crossbow being loaded. If canceled, the
 +     * projectile that would be loaded into the crossbow will not be consumed.
-+     *
-+     * @param cancel true if you wish to cancel this event
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {

patches/api/Add-EntityPortalReadyEvent.patch

@@ -18,6 +18,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.bukkit.event.entity.EntityPortalEvent;
++import org.bukkit.event.player.PlayerPortalEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -33,10 +36,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private World targetWorld;
 +    private final PortalType portalType;
++    private World targetWorld;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public EntityPortalReadyEvent(final @NotNull Entity entity, final @Nullable World targetWorld, final @NotNull PortalType portalType) {
 +        super(entity);
 +        this.targetWorld = targetWorld;
@@ -45,25 +50,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the world this portal will teleport to.
-+     * Can be null if "allow-nether" is false in server.properties
++     * Can be {@code null} if "allow-nether" is false in server.properties
 +     * or if there is another situation where there is no world to teleport to.
 +     * <p>
-+     * This world may be modified by later events such as {@link org.bukkit.event.player.PlayerPortalEvent}
-+     * or {@link org.bukkit.event.entity.EntityPortalEvent}.
++     * This world may be modified by later events such as {@link PlayerPortalEvent}
++     * or {@link EntityPortalEvent}.
 +     *
 +     * @return the world the portal will teleport the entity to.
 +     */
 +    public @Nullable World getTargetWorld() {
-+        return targetWorld;
++        return this.targetWorld;
 +    }
 +
 +    /**
-+     * Sets the world this portal will teleport to. A null value
++     * Sets the world this portal will teleport to. A {@code null} value
 +     * will essentially cancel the teleport and prevent further events
-+     * such as {@link org.bukkit.event.player.PlayerPortalEvent} from firing.
++     * such as {@link PlayerPortalEvent} from firing.
 +     * <p>
-+     * This world may be modified by later events such as {@link org.bukkit.event.player.PlayerPortalEvent}
-+     * or {@link org.bukkit.event.entity.EntityPortalEvent}.
++     * This world may be modified by later events such as {@link PlayerPortalEvent}
++     * or {@link EntityPortalEvent}.
 +     *
 +     * @param targetWorld the world
 +     */
@@ -77,12 +82,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the portal type
 +     */
 +    public @NotNull PortalType getPortalType() {
-+        return portalType;
++        return this.portalType;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Add-EntityTeleportEndGatewayEvent.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.block.EndGateway;
 +import org.bukkit.entity.Entity;
 +import org.bukkit.event.entity.EntityTeleportEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -25,8 +26,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull private final EndGateway gateway;
 +
-+    public EntityTeleportEndGatewayEvent(@NotNull Entity what, @NotNull Location from, @NotNull Location to, @NotNull EndGateway gateway) {
-+        super(what, from, to);
++    @ApiStatus.Internal
++    public EntityTeleportEndGatewayEvent(@NotNull Entity entity, @NotNull Location from, @NotNull Location to, @NotNull EndGateway gateway) {
++        super(entity, from, to);
 +        this.gateway = gateway;
 +    }
 +
@@ -37,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public EndGateway getGateway() {
-+        return gateway;
++        return this.gateway;
 +    }
 +
 +}

patches/api/Add-EntityZapEvent.patch

@@ -12,7 +12,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.entity;
 +
-+import com.google.common.base.Preconditions;
 +import org.bukkit.entity.Entity;
 +import org.bukkit.entity.LightningStrike;
 +import org.bukkit.event.Cancellable;
@@ -20,87 +19,85 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.entity.EntityTransformEvent;
 +
 +import java.util.Collections;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
-+ *  Fired when lightning strikes an entity
++ * Fired when lightning strikes an entity
 + */
 +public class EntityZapEvent extends EntityTransformEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    @NotNull private final LightningStrike bolt;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final LightningStrike bolt;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EntityZapEvent(@NotNull final Entity entity, @NotNull final LightningStrike bolt, @NotNull final Entity replacementEntity) {
 +        super(entity, Collections.singletonList(replacementEntity), TransformReason.LIGHTNING);
-+        Preconditions.checkNotNull(bolt);
-+        Preconditions.checkNotNull(replacementEntity);
 +        this.bolt = bolt;
 +    }
 +
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    public void setCancelled(boolean cancel) {
-+        this.cancelled = cancel;
-+    }
-+
 +    /**
 +     * Gets the lightning bolt that is striking the entity.
++     *
 +     * @return The lightning bolt responsible for this event
 +     */
 +    @NotNull
 +    public LightningStrike getBolt() {
-+        return bolt;
++        return this.bolt;
 +    }
 +
 +    /**
 +     * Gets the entity that will replace the struck entity.
++     *
 +     * @return The entity that will replace the struck entity
 +     */
 +    @NotNull
 +    public Entity getReplacementEntity() {
-+        return getTransformedEntity();
++        return super.getTransformedEntity();
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/event/entity/PigZapEvent.java b/src/main/java/org/bukkit/event/entity/PigZapEvent.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/event/entity/PigZapEvent.java
 +++ b/src/main/java/org/bukkit/event/entity/PigZapEvent.java
-@@ -0,0 +0,0 @@ package org.bukkit.event.entity;
- 
- import java.util.Collections;
- import org.bukkit.entity.Entity;
-+import com.destroystokyo.paper.event.entity.EntityZapEvent;
- import org.bukkit.entity.LightningStrike;
- import org.bukkit.entity.Pig;
- import org.bukkit.entity.PigZombie;
 @@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
  /**
   * Stores data for pigs being zapped
   */
 -public class PigZapEvent extends EntityTransformEvent implements Cancellable {
 -    private static final HandlerList handlers = new HandlerList();
-+public class PigZapEvent extends EntityZapEvent implements Cancellable {
-+    //private static final HandlerList handlers = new HandlerList();
++public class PigZapEvent extends com.destroystokyo.paper.event.entity.EntityZapEvent implements Cancellable { // Paper
++    // private static final HandlerList handlers = new HandlerList(); // Paper - moved in the super class
      private boolean canceled;
      private final PigZombie pigzombie;
      private final LightningStrike bolt;
  
      public PigZapEvent(@NotNull final Pig pig, @NotNull final LightningStrike bolt, @NotNull final PigZombie pigzombie) {
 -        super(pig, Collections.singletonList((Entity) pigzombie), TransformReason.LIGHTNING);
-+        super(pig, bolt, pigzombie);
++        super(pig, bolt, pigzombie); // Paper
          this.bolt = bolt;
          this.pigzombie = pigzombie;
      }

patches/api/Add-GS4-Query-event.patch

@@ -14,8 +14,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import com.google.common.base.Preconditions;
 +import com.google.common.collect.ImmutableList;
++import org.bukkit.Server;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +import java.net.InetAddress;
@@ -25,79 +27,76 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import java.util.List;
 +
 +/**
-+ * This event is fired if server is getting queried over GS4 Query protocol
-+ *
++ * This event is fired if server is getting queried over GS4 Query protocol.
++ * <br>
 + * Adapted from Velocity's ProxyQueryEvent
 + *
 + * @author Mark Vainomaa
 + */
 +public final class GS4QueryEvent extends Event {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final QueryType queryType;
 +    private final InetAddress querierAddress;
 +    private QueryResponse response;
 +
++    @ApiStatus.Internal
 +    public GS4QueryEvent(@NotNull QueryType queryType, @NotNull InetAddress querierAddress, @NotNull QueryResponse response) {
 +        super(true); // should always be called async
-+        this.queryType = Preconditions.checkNotNull(queryType, "queryType");
-+        this.querierAddress = Preconditions.checkNotNull(querierAddress, "querierAddress");
-+        this.response = Preconditions.checkNotNull(response, "response");
++        this.queryType = queryType;
++        this.querierAddress = querierAddress;
++        this.response = response;
 +    }
 +
 +    /**
 +     * Get query type
++     *
 +     * @return query type
 +     */
 +    @NotNull
 +    public QueryType getQueryType() {
-+        return queryType;
++        return this.queryType;
 +    }
 +
 +    /**
 +     * Get querier address
++     *
 +     * @return querier address
 +     */
 +    @NotNull
 +    public InetAddress getQuerierAddress() {
-+        return querierAddress;
++        return this.querierAddress;
 +    }
 +
 +    /**
 +     * Get query response
++     *
 +     * @return query response
 +     */
 +    @NotNull
 +    public QueryResponse getResponse() {
-+        return response;
++        return this.response;
 +    }
 +
 +    /**
 +     * Set query response
++     *
 +     * @param response query response
 +     */
 +    public void setResponse(@NotNull QueryResponse response) {
 +        this.response = Preconditions.checkNotNull(response, "response");
 +    }
 +
-+    @Override
-+    public String toString() {
-+        return "GS4QueryEvent{" +
-+            "queryType=" + queryType +
-+            ", querierAddress=" + querierAddress +
-+            ", response=" + response +
-+            '}';
-+    }
-+
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    /**
@@ -114,10 +113,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         * Full query asks pretty much everything present on this event (only hardcoded values cannot be modified here).
 +         */
 +        FULL
-+        ;
 +    }
 +
 +    public final static class QueryResponse {
++
 +        private final String motd;
 +        private final String gameVersion;
 +        private final String map;
@@ -143,95 +142,105 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +
 +        /**
-+         * Get motd which will be used to reply to the query. By default it is {@link org.bukkit.Server#getMotd()}.
++         * Get motd which will be used to reply to the query. By default it is {@link Server#getMotd()}.
++         *
 +         * @return motd
 +         */
 +        @NotNull
 +        public String getMotd() {
-+            return motd;
++            return this.motd;
 +        }
 +
 +        /**
 +         * Get game version which will be used to reply to the query. By default supported Minecraft versions range is sent.
++         *
 +         * @return game version
 +         */
 +        @NotNull
 +        public String getGameVersion() {
-+            return gameVersion;
++            return this.gameVersion;
 +        }
 +
 +        /**
 +         * Get map name which will be used to reply to the query. By default {@code world} is sent.
++         *
 +         * @return map name
 +         */
 +        @NotNull
 +        public String getMap() {
-+            return map;
++            return this.map;
 +        }
 +
 +        /**
 +         * Get current online player count which will be used to reply to the query.
++         *
 +         * @return online player count
 +         */
 +        public int getCurrentPlayers() {
-+            return currentPlayers;
++            return this.currentPlayers;
 +        }
 +
 +        /**
 +         * Get max player count which will be used to reply to the query.
++         *
 +         * @return max player count
 +         */
 +        public int getMaxPlayers() {
-+            return maxPlayers;
++            return this.maxPlayers;
 +        }
 +
 +        /**
-+         * Get server (public facing) hostname
++         * Get server (public facing) hostname.
++         *
 +         * @return server hostname
 +         */
 +        @NotNull
 +        public String getHostname() {
-+            return hostname;
++            return this.hostname;
 +        }
 +
 +        /**
-+         * Get server (public facing) port
++         * Get server (public facing) port.
++         *
 +         * @return server port
 +         */
 +        public int getPort() {
-+            return port;
++            return this.port;
 +        }
 +
 +        /**
 +         * Get collection of players which will be used to reply to the query.
++         *
 +         * @return collection of players
 +         */
 +        @NotNull
 +        public Collection<String> getPlayers() {
-+            return players;
++            return this.players;
 +        }
 +
 +        /**
 +         * Get server software (name and version) which will be used to reply to the query.
++         *
 +         * @return server software
 +         */
 +        @NotNull
 +        public String getServerVersion() {
-+            return serverVersion;
++            return this.serverVersion;
 +        }
 +
 +        /**
 +         * Get list of plugins which will be used to reply to the query.
++         *
 +         * @return collection of plugins
 +         */
 +        @NotNull
 +        public Collection<PluginInformation> getPlugins() {
-+            return plugins;
++            return this.plugins;
 +        }
 +
-+
 +        /**
-+         * Creates a new {@link Builder} instance from data represented by this response
++         * Creates a new {@link Builder} instance from data represented by this response.
++         *
 +         * @return {@link QueryResponse} builder
 +         */
 +        @NotNull
@@ -250,7 +259,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +
 +        /**
-+         * Creates a new {@link Builder} instance
++         * Creates a new {@link Builder} instance.
++         *
 +         * @return {@link QueryResponse} builder
 +         */
 +        @NotNull
@@ -272,8 +282,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            private int maxPlayers;
 +            private int port;
 +
-+            private List<String> players = new ArrayList<>();
-+            private List<PluginInformation> plugins = new ArrayList<>();
++            private final List<String> players = new ArrayList<>();
++            private final List<PluginInformation> plugins = new ArrayList<>();
 +
 +            private Builder() {}
 +
@@ -365,7 +375,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +
 +            /**
-+             * Builds new {@link QueryResponse} with supplied data
++             * Builds new {@link QueryResponse} with supplied data.
++             *
 +             * @return response
 +             */
 +            @NotNull
@@ -389,6 +400,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         * Plugin information
 +         */
 +        public static class PluginInformation {
++
 +            private String name;
 +            private String version;
 +
@@ -399,7 +411,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +            @NotNull
 +            public String getName() {
-+                return name;
++                return this.name;
 +            }
 +
 +            public void setName(@NotNull String name) {
@@ -412,7 +424,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +            @NotNull
 +            public String getVersion() {
-+                return version;
++                return this.version;
 +            }
 +
 +            @NotNull

patches/api/Add-More-Creeper-API.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -24,10 +25,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * {@link Creeper#setIgnited(boolean)}.
 + */
 +public class CreeperIgniteEvent extends EntityEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean canceled;
-+    private boolean ignited;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private boolean ignited;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public CreeperIgniteEvent(@NotNull Creeper creeper, boolean ignited) {
 +        super(creeper);
 +        this.ignited = ignited;
@@ -36,11 +40,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public Creeper getEntity() {
-+        return (Creeper) entity;
++        return (Creeper) super.getEntity();
 +    }
 +
 +    public boolean isIgnited() {
-+        return ignited;
++        return this.ignited;
 +    }
 +
 +    public void setIgnited(boolean ignited) {
@@ -48,22 +52,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    public boolean isCancelled() {
-+        return canceled;
++        return this.cancelled;
 +    }
 +
 +    public void setCancelled(boolean cancel) {
-+        canceled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/entity/Creeper.java b/src/main/java/org/bukkit/entity/Creeper.java

patches/api/Add-PhantomPreSpawnEvent.patch

@@ -18,13 +18,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.entity.CreatureSpawnEvent;
 +import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
-+import org.jetbrains.annotations.Nullable;
-+
 +
 +/**
 + * Called when a phantom is spawned for an exhausted player
 + */
 +public class PhantomPreSpawnEvent extends PreCreatureSpawnEvent {
++
 +    @NotNull private final Entity entity;
 +
 +    @ApiStatus.Internal
@@ -36,11 +35,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Get the entity this phantom is spawning for
 +     *
-+     * @return Entity
++     * @return the Entity
 +     */
 +    @NotNull
 +    public Entity getSpawningEntity() {
-+        return entity;
++        return this.entity;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/entity/Phantom.java b/src/main/java/org/bukkit/entity/Phantom.java

patches/api/Add-Player-Client-Options-API.patch

@@ -103,6 +103,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.MainHand;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +import java.util.Map;
@@ -112,7 +113,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerClientOptionsChangeEvent extends PlayerEvent {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final String locale;
 +    private final int viewDistance;
@@ -136,6 +137,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.textFilteringEnabled = false;
 +    }
 +
++    @ApiStatus.Internal
 +    public PlayerClientOptionsChangeEvent(@NotNull Player player, @NotNull Map<ClientOption<?>, ?> options) {
 +        super(player);
 +
@@ -151,81 +153,81 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    public String getLocale() {
-+        return locale;
++        return this.locale;
 +    }
 +
 +    public boolean hasLocaleChanged() {
-+        return !locale.equals(player.getClientOption(ClientOption.LOCALE));
++        return !this.locale.equals(this.player.getClientOption(ClientOption.LOCALE));
 +    }
 +
 +    public int getViewDistance() {
-+        return viewDistance;
++        return this.viewDistance;
 +    }
 +
 +    public boolean hasViewDistanceChanged() {
-+        return viewDistance != player.getClientOption(ClientOption.VIEW_DISTANCE);
++        return this.viewDistance != this.player.getClientOption(ClientOption.VIEW_DISTANCE);
 +    }
 +
 +    @NotNull
 +    public ChatVisibility getChatVisibility() {
-+        return chatVisibility;
++        return this.chatVisibility;
 +    }
 +
 +    public boolean hasChatVisibilityChanged() {
-+        return chatVisibility != player.getClientOption(ClientOption.CHAT_VISIBILITY);
++        return this.chatVisibility != this.player.getClientOption(ClientOption.CHAT_VISIBILITY);
 +    }
 +
 +    public boolean hasChatColorsEnabled() {
-+        return chatColors;
++        return this.chatColors;
 +    }
 +
 +    public boolean hasChatColorsEnabledChanged() {
-+        return chatColors != player.getClientOption(ClientOption.CHAT_COLORS_ENABLED);
++        return this.chatColors != this.player.getClientOption(ClientOption.CHAT_COLORS_ENABLED);
 +    }
 +
 +    @NotNull
 +    public SkinParts getSkinParts() {
-+        return skinparts;
++        return this.skinparts;
 +    }
 +
 +    public boolean hasSkinPartsChanged() {
-+        return skinparts.getRaw() != player.getClientOption(ClientOption.SKIN_PARTS).getRaw();
++        return this.skinparts.getRaw() != this.player.getClientOption(ClientOption.SKIN_PARTS).getRaw();
 +    }
 +
 +    @NotNull
 +    public MainHand getMainHand() {
-+        return mainHand;
++        return this.mainHand;
 +    }
 +
 +    public boolean hasMainHandChanged() {
-+        return mainHand != player.getClientOption(ClientOption.MAIN_HAND);
++        return this.mainHand != this.player.getClientOption(ClientOption.MAIN_HAND);
 +    }
 +
 +    public boolean allowsServerListings() {
-+        return allowsServerListings;
++        return this.allowsServerListings;
 +    }
 +
 +    public boolean hasAllowServerListingsChanged() {
-+        return allowsServerListings != player.getClientOption(ClientOption.ALLOW_SERVER_LISTINGS);
++        return this.allowsServerListings != this.player.getClientOption(ClientOption.ALLOW_SERVER_LISTINGS);
 +    }
 +
 +    public boolean hasTextFilteringEnabled() {
-+        return textFilteringEnabled;
++        return this.textFilteringEnabled;
 +    }
 +
 +    public boolean hasTextFilteringChanged() {
-+        return textFilteringEnabled != player.getClientOption(ClientOption.TEXT_FILTERING_ENABLED);
++        return this.textFilteringEnabled != this.player.getClientOption(ClientOption.TEXT_FILTERING_ENABLED);
 +    }
 +
 +    @Override
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java

patches/api/Add-PlayerAdvancementCriterionGrantEvent.patch

@@ -19,6 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -26,17 +27,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * If cancelled the criteria will be revoked.
 + */
 +public class PlayerAdvancementCriterionGrantEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final Advancement advancement;
 +    @NotNull private final String criterion;
 +    @NotNull private final AdvancementProgress advancementProgress;
-+    private boolean cancel = false;
 +
-+    public PlayerAdvancementCriterionGrantEvent(@NotNull Player who, @NotNull Advancement advancement, @NotNull String criterion) {
-+        super(who);
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public PlayerAdvancementCriterionGrantEvent(@NotNull Player player, @NotNull Advancement advancement, @NotNull String criterion) {
++        super(player);
 +        this.advancement = advancement;
 +        this.criterion = criterion;
-+        this.advancementProgress = who.getAdvancementProgress(advancement);
++        this.advancementProgress = player.getAdvancementProgress(advancement);
 +    }
 +
 +    /**
@@ -46,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Advancement getAdvancement() {
-+        return advancement;
++        return this.advancement;
 +    }
 +
 +    /**
@@ -56,36 +61,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public String getCriterion() {
-+        return criterion;
-+    }
-+
-+    public boolean isCancelled() {
-+        return cancel;
++        return this.criterion;
 +    }
 +
 +    /**
 +     * Gets the current AdvancementProgress.
-+     * See {@link PlayerAdvancementCriterionGrantEvent}
 +     *
 +     * @return advancement progress
 +     */
 +    @NotNull
 +    public AdvancementProgress getAdvancementProgress() {
-+        return advancementProgress;
++        return this.advancementProgress;
 +    }
 +
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerArmorChangeEvent.patch

@@ -18,9 +18,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
 +
-+import java.util.Arrays;
-+import java.util.Collections;
-+import java.util.HashSet;
 +import java.util.Set;
 +import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
@@ -34,7 +31,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Not currently called for environmental factors though it <strong>MAY BE IN THE FUTURE</strong>
 + */
 +public class PlayerArmorChangeEvent extends PlayerEvent {
-+    private static final HandlerList HANDLERS = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    @NotNull private final SlotType slotType;
 +    @NotNull private final ItemStack oldItem;
@@ -78,20 +76,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return this.newItem;
 +    }
 +
-+    @Override
-+    public String toString() {
-+        return "ArmorChangeEvent{" + "player=" + player + ", slotType=" + slotType + ", oldItem=" + oldItem + ", newItem=" + newItem + '}';
-+    }
-+
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    public enum SlotType {
@@ -100,11 +93,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        LEGS(NETHERITE_LEGGINGS, DIAMOND_LEGGINGS, GOLDEN_LEGGINGS, IRON_LEGGINGS, CHAINMAIL_LEGGINGS, LEATHER_LEGGINGS),
 +        FEET(NETHERITE_BOOTS, DIAMOND_BOOTS, GOLDEN_BOOTS, IRON_BOOTS, CHAINMAIL_BOOTS, LEATHER_BOOTS);
 +
-+        private final Set<Material> mutableTypes = new HashSet<>();
-+        private Set<Material> immutableTypes;
++        private final Set<Material> types;
 +
 +        SlotType(Material... types) {
-+            this.mutableTypes.addAll(Arrays.asList(types));
++            this.types = Set.of(types);
 +        }
 +
 +        /**
@@ -115,18 +107,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        @NotNull
 +        public Set<Material> getTypes() {
-+            if (immutableTypes == null) {
-+                immutableTypes = Collections.unmodifiableSet(mutableTypes);
-+            }
-+
-+            return immutableTypes;
++            return this.types;
 +        }
 +
 +        /**
 +         * Gets the type of slot via the specified material
 +         *
 +         * @param material material to get slot by
-+         * @return slot type the material will go in, or null if it won't
++         * @return slot type the material will go in, or {@code null} if it won't
 +         */
 +        @Nullable
 +        public static SlotType getByMaterial(@NotNull Material material) {

patches/api/Add-PlayerAttackEntityCooldownResetEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -24,56 +25,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerAttackEntityCooldownResetEvent extends PlayerEvent implements Cancellable {
 +
-+    private final float cooledAttackStrength;
-+    private boolean cancel = false;
-+    private static final HandlerList handlers = new HandlerList();
-+    @NotNull private final Entity attackedEntity;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    public PlayerAttackEntityCooldownResetEvent(@NotNull Player who, @NotNull Entity attackedEntity, float cooledAttackStrength) {
-+        super(who);
++    @NotNull private final Entity attackedEntity;
++    private final float cooledAttackStrength;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public PlayerAttackEntityCooldownResetEvent(@NotNull Player player, @NotNull Entity attackedEntity, float cooledAttackStrength) {
++        super(player);
 +        this.attackedEntity = attackedEntity;
 +        this.cooledAttackStrength = cooledAttackStrength;
 +    }
 +
-+    @Override
-+    public @NotNull HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    public static @NotNull HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    /**
-+     * Gets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
-+     * <p>
-+     * If an attack cooldown event is cancelled, the players attack strength will remain at the same value instead of being reset.
-+     *
-+     * @return true if this event is cancelled
-+     */
-+    @Override
-+    public boolean isCancelled() {
-+        return cancel;
-+    }
-+
-+    /**
-+     * Cancelling this event will prevent the target player from having their cooldown reset from attacking this entity
-+     *
-+     * @param cancel true if you wish to cancel this event
-+     */
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
-+    }
-+
 +    /**
 +     * Get the value of the players cooldown attack strength when they initiated the attack
 +     *
 +     * @return returns the original player cooldown value
 +     */
 +    public float getCooledAttackStrength() {
-+        return cooledAttackStrength;
++        return this.cooledAttackStrength;
 +    }
 +
 +    /**
@@ -83,6 +55,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getAttackedEntity() {
-+        return attackedEntity;
++        return this.attackedEntity;
++    }
++
++    /**
++     * {@inheritDoc}
++     * <p>
++     * If an attack cooldown event is cancelled, the players attack strength will remain at the same value instead of being reset.
++     */
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    /**
++     * {@inheritDoc}
++     * <p>
++     * Cancelling this event will prevent the target player from having their cooldown reset from attacking this entity
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public static @NotNull HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerConnectionCloseEvent.patch

@@ -46,6 +46,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import java.net.InetAddress;
 +import java.util.UUID;
++import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
++import org.bukkit.event.player.PlayerQuitEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -53,45 +56,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * This event is invoked when a player has disconnected. It is guaranteed that,
 + * if the server is in online-mode, that the provided uuid and username have been
 + * validated.
-+ * </p>
-+ *
 + * <p>
 + * The event is invoked for players who have not yet logged into the world, whereas
-+ * {@link org.bukkit.event.player.PlayerQuitEvent} is only invoked on players who have logged into the world.
-+ * </p>
-+ *
++ * {@link PlayerQuitEvent} is only invoked on players who have logged into the world.
 + * <p>
 + * The event is invoked for players who have already logged into the world,
 + * although whether or not the player exists in the world at the time of
 + * firing is undefined. (That is, whether the plugin can retrieve a Player object
 + * using the event parameters is undefined). However, it is guaranteed that this
-+ * event is invoked AFTER {@link org.bukkit.event.player.PlayerQuitEvent}, if the player has already logged into the world.
-+ * </p>
-+ *
++ * event is invoked AFTER {@link PlayerQuitEvent}, if the player has already logged into the world.
 + * <p>
-+ * This event is guaranteed to never fire unless {@link org.bukkit.event.player.AsyncPlayerPreLoginEvent} has
++ * This event is guaranteed to never fire unless {@link AsyncPlayerPreLoginEvent} has
 + * been fired beforehand, and this event may not be called in parallel with
-+ * {@link org.bukkit.event.player.AsyncPlayerPreLoginEvent} for the same connection.
-+ * </p>
-+ *
++ * {@link AsyncPlayerPreLoginEvent} for the same connection.
 + * <p>
-+ * Cancelling the {@link org.bukkit.event.player.AsyncPlayerPreLoginEvent} guarantees the corresponding
++ * Cancelling the {@link AsyncPlayerPreLoginEvent} guarantees the corresponding
 + * {@code PlayerConnectionCloseEvent} is never called.
-+ * </p>
-+ *
 + * <p>
 + * The event may be invoked asynchronously or synchronously. Plugins should check
 + * {@link Event#isAsynchronous()} and handle accordingly.
-+ * </p>
 + */
 +public class PlayerConnectionCloseEvent extends Event {
 +
-+    private static final HandlerList HANDLERS = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    @NotNull private final UUID playerUniqueId;
 +    @NotNull private final String playerName;
 +    @NotNull private final InetAddress ipAddress;
 +
++    @ApiStatus.Internal
 +    public PlayerConnectionCloseEvent(@NotNull final UUID playerUniqueId, @NotNull final String playerName, @NotNull final InetAddress ipAddress, final boolean async) {
 +        super(async);
 +        this.playerUniqueId = playerUniqueId;
@@ -126,11 +119,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerFailMoveEvent.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -26,14 +27,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final FailReason failReason;
-+    private boolean allowed;
-+    private boolean logWarning;
 +    private final Location from;
 +    private final Location to;
++    private boolean allowed;
++    private boolean logWarning;
 +
-+    public PlayerFailMoveEvent(@NotNull Player who, @NotNull FailReason failReason, boolean allowed,
++    @ApiStatus.Internal
++    public PlayerFailMoveEvent(@NotNull Player player, @NotNull FailReason failReason, boolean allowed,
 +                               boolean logWarning, @NotNull Location from, @NotNull Location to) {
-+        super(who);
++        super(player);
 +        this.failReason = failReason;
 +        this.allowed = allowed;
 +        this.logWarning = logWarning;
@@ -43,41 +45,46 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the reason this movement was prevented by the server
++     *
 +     * @return The reason the movement was prevented
 +     */
 +    @NotNull
 +    public FailReason getFailReason() {
-+        return failReason;
++        return this.failReason;
 +    }
 +
 +    /**
 +     * Gets the location this player moved from
++     *
 +     * @return Location the player moved from
 +     */
 +    @NotNull
 +    public Location getFrom() {
-+        return from.clone();
++        return this.from.clone();
 +    }
 +
 +    /**
 +     * Gets the location this player tried to move to
++     *
 +     * @return Location the player tried to move to
 +     */
 +    @NotNull
 +    public Location getTo() {
-+        return to.clone();
++        return this.to.clone();
 +    }
 +
 +    /**
 +     * Gets if the check should be bypassed, allowing the movement
++     *
 +     * @return whether to bypass the check
 +     */
 +    public boolean isAllowed() {
-+        return allowed;
++        return this.allowed;
 +    }
 +
 +    /**
 +     * Set if the check should be bypassed and the movement should be allowed
++     *
 +     * @param allowed whether to bypass the check
 +     */
 +    public void setAllowed(boolean allowed) {
@@ -85,15 +92,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets if warnings will be printed to console. eg. "Player123 moved too quickly!"
++     * Gets if warnings will be printed to console. e.g. "Player123 moved too quickly!"
++     *
 +     * @return whether to log warnings
 +     */
 +    public boolean getLogWarning() {
-+        return logWarning;
++        return this.logWarning;
 +    }
 +
 +    /**
-+     * Set if a warning is printed to console. eg. "Player123 moved too quickly!"
++     * Set if a warning is printed to console. e.g. "Player123 moved too quickly!"
++     *
 +     * @param logWarning whether to log warnings
 +     */
 +    public void setLogWarning(boolean logWarning) {

patches/api/Add-PlayerFlowerPotManipulateEvent.patch

@@ -18,13 +18,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a player places an item in or takes an item out of a flowerpot.
 + */
 +public class PlayerFlowerPotManipulateEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    @NotNull
 +    private final Block flowerpot;
@@ -32,8 +34,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final ItemStack item;
 +    private final boolean placing;
 +
-+    private boolean cancel = false;
++    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerFlowerPotManipulateEvent(@NotNull final Player player, @NotNull final Block flowerpot, @NotNull final ItemStack item, final boolean placing) {
 +        super(player);
 +        this.flowerpot = flowerpot;
@@ -41,16 +44,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.placing = placing;
 +    }
 +
-+    @Override
-+    public boolean isCancelled() {
-+        return cancel;
-+    }
-+
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
-+    }
-+
 +    /**
 +     * Gets the flowerpot that is involved in this event.
 +     *
@@ -58,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Block getFlowerpot() {
-+        return flowerpot;
++        return this.flowerpot;
 +    }
 +
 +    /**
@@ -69,7 +62,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItem() {
-+        return item;
++        return this.item;
 +    }
 +
 +    /**
@@ -78,17 +71,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return if the item is being placed into the flowerpot
 +     */
 +    public boolean isPlacing() {
-+        return placing;
++        return this.placing;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerInitialSpawnEvent.patch

@@ -25,7 +25,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +@Deprecated(forRemoval = true) @ApiStatus.ScheduledForRemoval(inVersion = "1.21")
 +public class PlayerInitialSpawnEvent extends PlayerSpawnLocationEvent {
 +
-+    public PlayerInitialSpawnEvent(@NotNull Player who, @NotNull Location spawnLocation) {
-+        super(who, spawnLocation);
++    @ApiStatus.Internal
++    public PlayerInitialSpawnEvent(@NotNull Player player, @NotNull Location spawnLocation) {
++        super(player, spawnLocation);
 +    }
 +}

patches/api/Add-PlayerInventorySlotChangeEvent.patch

@@ -23,7 +23,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Called when a slot contents change in a player's inventory.
 + */
 +public class PlayerInventorySlotChangeEvent extends PlayerEvent {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final int rawSlot;
 +    private final int slot;
 +    private final ItemStack oldItemStack;
@@ -44,7 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return The raw slot number.
 +     */
 +    public int getRawSlot() {
-+        return rawSlot;
++        return this.rawSlot;
 +    }
 +
 +    /**
@@ -57,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return The slot number.
 +     */
 +    public int getSlot() {
-+        return slot;
++        return this.slot;
 +    }
 +
 +    /**
@@ -67,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getOldItemStack() {
-+        return oldItemStack;
++        return this.oldItemStack;
 +    }
 +
 +    /**
@@ -77,7 +79,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getNewItemStack() {
-+        return newItemStack;
++        return this.newItemStack;
 +    }
 +
 +    /**
@@ -86,7 +88,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return Whether the slot change advancements will be triggered.
 +     */
 +    public boolean shouldTriggerAdvancements() {
-+        return triggerAdvancements;
++        return this.triggerAdvancements;
 +    }
 +
 +    /**
@@ -101,11 +103,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerItemCooldownEvent.patch

@@ -18,18 +18,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when a player receives an item cooldown.
 + */
 +public class PlayerItemCooldownEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull
 +    private final Material type;
-+    private boolean cancelled;
 +    private int cooldown;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerItemCooldownEvent(@NotNull Player player, @NotNull Material type, int cooldown) {
 +        super(player);
 +        this.type = type;
@@ -43,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Material getType() {
-+        return type;
++        return this.type;
 +    }
 +
 +    /**
@@ -52,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return cooldown in ticks
 +     */
 +    public int getCooldown() {
-+        return cooldown;
++        return this.cooldown;
 +    }
 +
 +    /**
@@ -68,7 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -79,11 +84,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerItemFrameChangeEvent.patch

@@ -12,13 +12,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.player;
 +
-+import org.bukkit.Material;
 +import org.bukkit.entity.ItemFrame;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -27,12 +27,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerItemFrameChangeEvent extends PlayerEvent implements Cancellable {
 +
-+    private static final HandlerList HANDLERS = new HandlerList();
-+    private boolean cancelled;
-+    private final ItemFrame itemFrame;
-+    private ItemStack itemStack;
-+    private final ItemFrameChangeAction action;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
++    private final ItemFrame itemFrame;
++    private final ItemFrameChangeAction action;
++    private ItemStack itemStack;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerItemFrameChangeEvent(@NotNull Player player, @NotNull ItemFrame itemFrame,
 +                                      @NotNull ItemStack itemStack, @NotNull ItemFrameChangeAction action) {
 +        super(player);
@@ -43,46 +46,50 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the {@link ItemFrame} involved in this event.
++     *
 +     * @return the {@link ItemFrame}
 +     */
 +    @NotNull
 +    public ItemFrame getItemFrame() {
-+        return itemFrame;
++        return this.itemFrame;
 +    }
 +
 +    /**
 +     * Gets the {@link ItemStack} involved in this event.
 +     * This is the item being added, rotated, or removed from the {@link ItemFrame}.
-+     * <p>If this method returns air, then the resulting item in the ItemFrame will be empty.</p>
++     * <p>
++     * If this method returns air, then the resulting item in the ItemFrame will be empty.
++     *
 +     * @return the {@link ItemStack} being added, rotated, or removed
 +     */
 +    @NotNull
 +    public ItemStack getItemStack() {
-+        return itemStack;
++        return this.itemStack;
 +    }
 +
 +    /**
 +     * Sets the {@link ItemStack} that this {@link ItemFrame} holds.
-+     * If null is provided, the ItemStack will become air and the result in the ItemFrame will be empty.
++     * If {@code null} is provided, the ItemStack will become air and the result in the ItemFrame will be empty.
++     *
 +     * @param itemStack {@link ItemFrame} item
 +     */
 +    public void setItemStack(@Nullable ItemStack itemStack) {
-+        this.itemStack = itemStack == null ? new ItemStack(Material.AIR) : itemStack;
++        this.itemStack = itemStack == null ? ItemStack.empty() : itemStack;
 +    }
 +
 +    /**
 +     * Gets the action that was performed on this {@link ItemFrame}.
-+     * @see ItemFrameChangeAction
++     *
 +     * @return action performed on the item frame in this event
 +     */
 +    @NotNull
 +    public ItemFrameChangeAction getAction() {
-+        return action;
++        return this.action;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -93,12 +100,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    public enum ItemFrameChangeAction {

patches/api/Add-PlayerJumpEvent.patch

@@ -18,21 +18,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.event.player.PlayerMoveEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when the server detects the player is jumping.
 + * <p>
 + * Added to avoid the overhead and special case logic that many plugins use
-+ * when checking for jumps via PlayerMoveEvent, this event is fired whenever
++ * when checking for jumps via {@link PlayerMoveEvent}, this event is fired whenever
 + * the server detects that the player is jumping.
 + */
 +public class PlayerJumpEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancel = false;
-+    @NotNull private Location from;
-+    @NotNull private Location to;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final Location to;
++    @NotNull private Location from;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerJumpEvent(@NotNull final Player player, @NotNull final Location from, @NotNull final Location to) {
 +        super(player);
 +        this.from = from;
@@ -40,31 +46,29 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
++     * {@inheritDoc}
 +     * <p>
 +     * If a jump event is cancelled, the player will be moved or
-+     * teleported back to the Location as defined by getFrom(). This will not
++     * teleported back to the Location as defined by {@link #getFrom()}. This will not
 +     * fire an event
 +     *
-+     * @return true if this event is cancelled
++     * @return {@code true} if this event is cancelled
 +     */
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
 +    /**
-+     * Sets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
++     * {@inheritDoc}
 +     * <p>
 +     * If a jump event is cancelled, the player will be moved or
-+     * teleported back to the Location as defined by getFrom(). This will not
++     * teleported back to the Location as defined by {@link #getFrom()}. This will not
 +     * fire an event
 +     *
-+     * @param cancel true if you wish to cancel this event
++     * @param cancel {@code true} if you wish to cancel this event
 +     */
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    /**
@@ -74,7 +78,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getFrom() {
-+        return from;
++        return this.from;
 +    }
 +
 +    /**
@@ -83,13 +87,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param from New location to mark as the players previous location
 +     */
 +    public void setFrom(@NotNull Location from) {
-+        validateLocation(from);
++        Preconditions.checkArgument(from != null, "Cannot use null from location!");
++        Preconditions.checkArgument(from.getWorld() != null, "Cannot use from location with null world!");
 +        this.from = from;
 +    }
 +
 +    /**
 +     * Gets the location this player jumped to
-+     *
++     * <p>
 +     * This information is based on what the client sends, it typically
 +     * has little relation to the arc of the jump at any given point.
 +     *
@@ -97,22 +102,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getTo() {
-+        return to;
-+    }
-+
-+    private void validateLocation(Location loc) {
-+        Preconditions.checkArgument(loc != null, "Cannot use null location!");
-+        Preconditions.checkArgument(loc.getWorld() != null, "Cannot use location with null world!");
++        return this.to;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerLocaleChangeEvent.patch

@@ -16,6 +16,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Called when the locale of the player is changed.
@@ -24,11 +26,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +@Deprecated(forRemoval = true) @ApiStatus.ScheduledForRemoval(inVersion = "1.21")
 +public class PlayerLocaleChangeEvent extends PlayerEvent {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final String oldLocale;
 +    private final String newLocale;
 +
-+    public PlayerLocaleChangeEvent(final Player player, final String oldLocale, final String newLocale) {
++    @ApiStatus.Internal
++    public PlayerLocaleChangeEvent(final @NotNull Player player, final @Nullable String oldLocale, final @NotNull String newLocale) {
 +        super(player);
 +        this.oldLocale = oldLocale;
 +        this.newLocale = newLocale;
@@ -39,8 +44,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     *
 +     * @return player's old locale
 +     */
++    @Nullable
 +    public String getOldLocale() {
-+        return oldLocale;
++        return this.oldLocale;
 +    }
 +
 +    /**
@@ -48,16 +54,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     *
 +     * @return player's new locale
 +     */
++    @NotNull
 +    public String getNewLocale() {
-+        return newLocale;
++        return this.newLocale;
 +    }
 +
 +    @Override
++    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
++    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerPickItemEvent.patch

@@ -12,11 +12,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.player;
 +
-+import org.apache.commons.lang3.Validate;
++import com.google.common.base.Preconditions;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Range;
 +
@@ -29,11 +30,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Note: This event will not be fired for players in creative mode.
 + */
 +public class PlayerPickItemEvent extends PlayerEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private int targetSlot;
 +    private int sourceSlot;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerPickItemEvent(@NotNull Player player, int targetSlot, int sourceSlot) {
 +        super(player);
 +        this.targetSlot = targetSlot;
@@ -56,7 +61,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param targetSlot hotbar slot (0-8 inclusive)
 +     */
 +    public void setTargetSlot(@Range(from = 0, to = 8) int targetSlot) {
-+        Validate.isTrue(targetSlot >= 0 && targetSlot <= 8, "Target slot must be in range 0 - 8 (inclusive)");
++        Preconditions.checkArgument(targetSlot >= 0 && targetSlot <= 8, "Target slot must be in range 0 - 8 (inclusive)");
 +        this.targetSlot = targetSlot;
 +    }
 +
@@ -76,7 +81,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param sourceSlot player inventory slot (0-35 inclusive)
 +     */
 +    public void setSourceSlot(@Range(from = 0, to = 35) int sourceSlot) {
-+        Validate.isTrue(sourceSlot >= 0 && sourceSlot <= 35, "Source slot must be in range of the players inventorys slot ids");
++        Preconditions.checkArgument(sourceSlot >= 0 && sourceSlot <= 35, "Source slot must be in range of the player's inventory slot");
 +        this.sourceSlot = sourceSlot;
 +    }
 +

patches/api/Add-PlayerPostRespawnEvent.patch

@@ -16,16 +16,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired after a player has respawned
 + */
 +public class PlayerPostRespawnEvent extends PlayerEvent {
-+    private final static HandlerList handlers = new HandlerList();
++
++    private final static HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Location respawnedLocation;
 +    private final boolean isBedSpawn;
 +
++    @ApiStatus.Internal
 +    public PlayerPostRespawnEvent(@NotNull final Player respawnPlayer, @NotNull final Location respawnedLocation, final boolean isBedSpawn) {
 +        super(respawnPlayer);
 +        this.respawnedLocation = respawnedLocation;
@@ -39,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getRespawnedLocation() {
-+        return respawnedLocation.clone();
++        return this.respawnedLocation.clone();
 +    }
 +
 +    /**
@@ -48,18 +52,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return whether the player respawned to their bed
 +     */
 +    public boolean isBedSpawn() {
-+        return isBedSpawn;
++        return this.isBedSpawn;
 +    }
 +
 +    @Override
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java b/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java

patches/api/Add-PlayerSetSpawnEvent.patch

@@ -18,11 +18,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
-+ * Called when a player's spawn is set, either by themselves or otherwise.<br>
++ * Called when a player's spawn is set, either by themselves or otherwise.
++ * <br>
 + * Cancelling this event will prevent the spawn from being set.
 + */
 +public class PlayerSetSpawnEvent extends PlayerEvent implements Cancellable {
@@ -37,8 +39,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private boolean cancelled;
 +
-+    public PlayerSetSpawnEvent(@NotNull Player who, @NotNull Cause cause, @Nullable Location location, boolean forced, boolean notifyPlayer, @Nullable Component notification) {
-+        super(who);
++    @ApiStatus.Internal
++    public PlayerSetSpawnEvent(@NotNull Player player, @NotNull Cause cause, @Nullable Location location, boolean forced, boolean notifyPlayer, @Nullable Component notification) {
++        super(player);
 +        this.cause = cause;
 +        this.location = location;
 +        this.forced = forced;
@@ -53,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Cause getCause() {
-+        return cause;
++        return this.cause;
 +    }
 +
 +    /**
@@ -62,18 +65,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * will change the resulting spawn point of the player. Use
 +     * {@link Location#clone()} to get a copy of this location.
 +     *
-+     * @return the spawn location, or null if removing the location
++     * @return the spawn location, or {@code null} if removing the location
 +     */
 +    @Nullable
 +    public Location getLocation() {
-+        return location;
++        return this.location;
 +    }
 +
 +    /**
 +     * Sets the location to be set as the spawn location. The yaw
 +     * of this location is the spawn angle.
 +     *
-+     * @param location the spawn location, or null to remove the spawn location
++     * @param location the spawn location, or {@code null} to remove the spawn location
 +     */
 +    public void setLocation(@Nullable Location location) {
 +        this.location = location;
@@ -82,16 +85,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets if this is a force spawn location
 +     *
-+     * @return true if forced
++     * @return {@code true} if forced
 +     */
 +    public boolean isForced() {
-+        return forced;
++        return this.forced;
 +    }
 +
 +    /**
 +     * Sets if this is a forced spawn location
 +     *
-+     * @param forced true to force
++     * @param forced {@code true} to force
 +     */
 +    public void setForced(boolean forced) {
 +        this.forced = forced;
@@ -101,17 +104,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Gets if this action will notify the player their spawn
 +     * has been set.
 +     *
-+     * @return true to notify
++     * @return {@code true} to notify
 +     */
 +    public boolean willNotifyPlayer() {
-+        return notifyPlayer;
++        return this.notifyPlayer;
 +    }
 +
 +    /**
 +     * Sets if this action will notify the player that their spawn
 +     * has been set.
 +     *
-+     * @param notifyPlayer true to notify
++     * @param notifyPlayer {@code true} to notify
 +     */
 +    public void setNotifyPlayer(boolean notifyPlayer) {
 +        this.notifyPlayer = notifyPlayer;
@@ -121,17 +124,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Gets the notification message that will be sent to the player
 +     * if {@link #willNotifyPlayer()} returns true.
 +     *
-+     * @return null if no notification
++     * @return {@code null} if no notification
 +     */
 +    @Nullable
 +    public Component getNotification() {
-+        return notification;
++        return this.notification;
 +    }
 +
 +    /**
 +     * Sets the notification message that will be sent to the player.
 +     *
-+     * @param notification null to send no message
++     * @param notification {@code null} to send no message
 +     */
 +    public void setNotification(@Nullable Component notification) {
 +        this.notification = notification;
@@ -175,8 +178,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        COMMAND,
 +        /**
-+         * When a plugin uses {@link Player#setBedSpawnLocation(Location)} or
-+         * {@link Player#setBedSpawnLocation(Location, boolean)}.
++         * When a plugin uses {@link Player#setRespawnLocation(Location)} or
++         * {@link Player#setRespawnLocation(Location, boolean)}.
 +         */
 +        PLUGIN,
 +        /**

patches/api/Add-PlayerShearBlockEvent.patch

@@ -19,6 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.EquipmentSlot;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +import java.util.List;
@@ -32,15 +33,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Examples include shearing a pumpkin to turn it into a carved pumpkin or shearing a beehive to get honeycomb.
 + */
 +public class PlayerShearBlockEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled = false;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Block block;
 +    private final ItemStack item;
 +    private final EquipmentSlot hand;
 +    private final List<ItemStack> drops;
 +
-+    public PlayerShearBlockEvent(@NotNull Player who, @NotNull Block block, @NotNull ItemStack item, @NotNull EquipmentSlot hand, @NotNull List<ItemStack> drops) {
-+        super(who);
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public PlayerShearBlockEvent(@NotNull Player player, @NotNull Block block, @NotNull ItemStack item, @NotNull EquipmentSlot hand, @NotNull List<ItemStack> drops) {
++        super(player);
 +        this.block = block;
 +        this.item = item;
 +        this.hand = hand;
@@ -54,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Block getBlock() {
-+        return block;
++        return this.block;
 +    }
 +
 +    /**
@@ -64,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItem() {
-+        return item;
++        return this.item;
 +    }
 +
 +    /**
@@ -74,7 +79,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public EquipmentSlot getHand() {
-+        return hand;
++        return this.hand;
 +    }
 +
 +    /**
@@ -84,7 +89,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public List<ItemStack> getDrops() {
-+        return drops;
++        return this.drops;
 +    }
 +
 +    /**
@@ -94,7 +99,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
@@ -110,11 +115,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerShieldDisableEvent.patch

@@ -42,10 +42,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * disabled in the first place.
 + */
 +public class PlayerShieldDisableEvent extends PlayerEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    private final Entity damager;
 +    private int cooldown;
++
 +    private boolean cancelled;
 +
 +    @ApiStatus.Internal
@@ -62,7 +64,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getDamager() {
-+        return damager;
++        return this.damager;
 +    }
 +
 +    /**
@@ -74,7 +76,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return cooldown in ticks
 +     */
 +    public int getCooldown() {
-+        return cooldown;
++        return this.cooldown;
 +    }
 +
 +    /**
@@ -90,23 +92,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.cooldown = cooldown;
 +    }
 +
-+    /**
-+     * Gets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
-+     *
-+     * @return true if this event is cancelled
-+     */
 +    @Override
 +    public boolean isCancelled() {
 +        return this.cancelled;
 +    }
 +
-+    /**
-+     * Sets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins.
-+     *
-+     * @param cancel true if you wish to cancel this event
-+     */
 +    @Override
 +    public void setCancelled(final boolean cancel) {
 +        this.cancelled = cancel;

patches/api/Add-PlayerStopUsingItemEvent.patch

@@ -23,7 +23,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Examples of this are letting go of the interact button when holding a bow, an edible item, or a spyglass.
 + */
 +public class PlayerStopUsingItemEvent extends PlayerEvent {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final ItemStack item;
 +    private final int ticksHeldFor;
 +
@@ -40,7 +42,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItem() {
-+        return item;
++        return this.item;
 +    }
 +
 +    /**
@@ -49,17 +51,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return int the number of ticks the item was held for
 +     */
 +    public int getTicksHeldFor() {
-+        return ticksHeldFor;
++        return this.ticksHeldFor;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PlayerUseUnknownEntityEvent.patch

@@ -19,8 +19,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.event.player.PlayerInteractAtEntityEvent;
 +import org.bukkit.inventory.EquipmentSlot;
 +import org.bukkit.util.Vector;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -33,14 +35,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerUseUnknownEntityEvent extends PlayerEvent {
 +
-+    private static final HandlerList HANDLERS = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final int entityId;
 +    private final boolean attack;
 +    private final @NotNull EquipmentSlot hand;
 +    private final @Nullable Vector clickedPosition;
 +
-+    public PlayerUseUnknownEntityEvent(@NotNull Player who, int entityId, boolean attack, @NotNull EquipmentSlot hand, @Nullable Vector clickedPosition) {
-+        super(who);
++    @ApiStatus.Internal
++    public PlayerUseUnknownEntityEvent(@NotNull Player player, int entityId, boolean attack, @NotNull EquipmentSlot hand, @Nullable Vector clickedPosition) {
++        super(player);
 +        this.entityId = entityId;
 +        this.attack = attack;
 +        this.hand = hand;
@@ -59,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Returns whether the interaction was an attack.
 +     *
-+     * @return true if the player is attacking the entity, false if the player is interacting with the entity
++     * @return {@code true} if the player is attacking the entity, {@code false} if the player is interacting with the entity
 +     */
 +    public boolean isAttack() {
 +        return this.attack;
@@ -75,11 +79,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Returns the position relative to the entity that was clicked, or null if not available.
-+     * See {@link org.bukkit.event.player.PlayerInteractAtEntityEvent} for more details.
++     * Returns the position relative to the entity that was clicked, or {@code null} if not available.
++     * See {@link PlayerInteractAtEntityEvent} for more details.
 +     *
-+     * @return the position relative to the entity that was clicked, or null if not available
-+     * @see org.bukkit.event.player.PlayerInteractAtEntityEvent
++     * @return the position relative to the entity that was clicked, or {@code null} if not available
++     * @see PlayerInteractAtEntityEvent
 +     */
 +    public @Nullable Vector getClickedRelativePosition() {
 +        return this.clickedPosition != null ? this.clickedPosition.clone() : null;
@@ -88,11 +92,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-PrePlayerAttackEntityEvent.patch

@@ -17,18 +17,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when the player tries to attack an entity.
-+ *
++ * <p>
 + * This occurs before any of the damage logic, so cancelling this event
 + * will prevent any sort of sounds from being played when attacking.
-+ *
++ * <p>
 + * This event will fire as cancelled for certain entities, with {@link PrePlayerAttackEntityEvent#willAttack()} being false
 + * to indicate that this entity will not actually be attacked.
 + * <p>
-+ * Note: there may be other factors (invulnerability, etc) that will prevent this entity from being attacked that this event will not cover
++ * Note: there may be other factors (invulnerability, etc.) that will prevent this entity from being attacked that this event will not cover
 + */
 +public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellable {
 +
@@ -36,11 +37,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    private final Entity attacked;
-+    private boolean cancelled;
 +    private final boolean willAttack;
 +
-+    public PrePlayerAttackEntityEvent(@NotNull Player who, @NotNull Entity attacked, boolean willAttack) {
-+        super(who);
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public PrePlayerAttackEntityEvent(@NotNull Player player, @NotNull Entity attacked, boolean willAttack) {
++        super(player);
 +        this.attacked = attacked;
 +        this.willAttack = willAttack;
 +        this.cancelled = !willAttack;
@@ -48,6 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the entity that was attacked in this event.
++     *
 +     * @return entity that was attacked
 +     */
 +    @NotNull
@@ -57,16 +61,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets if this entity will be attacked normally.
-+     * Entities like falling sand will return false because
++     * Entities like falling sand will return {@code false} because
 +     * their entity type does not allow them to be attacked.
 +     * <p>
-+     * Note: there may be other factors (invulnerability, etc) that will prevent this entity from being attacked that this event will not cover
++     * Note: there may be other factors (invulnerability, etc.) that will prevent this entity from being attacked that this event will not cover
++     *
 +     * @return if the entity will actually be attacked
 +     */
 +    public boolean willAttack() {
 +        return this.willAttack;
 +    }
 +
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    /**
++     * Sets if this attack should be cancelled, note if {@link PrePlayerAttackEntityEvent#willAttack()} returns false
++     * this event will always be cancelled.
++     *
++     * @param cancel {@code true} if you wish to cancel this event
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        if (!this.willAttack) {
++            return;
++        }
++
++        this.cancelled = cancel;
++    }
++
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
@@ -77,23 +102,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public static HandlerList getHandlerList() {
 +        return HANDLER_LIST;
 +    }
-+
-+    @Override
-+    public boolean isCancelled() {
-+        return this.cancelled;
-+    }
-+
-+    /**
-+     * Sets if this attack should be cancelled, note if {@link PrePlayerAttackEntityEvent#willAttack()} returns false
-+     * this event will always be cancelled.
-+     * @param cancel true if you wish to cancel this event
-+     */
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        if (!this.willAttack) {
-+            return;
-+        }
-+
-+        this.cancelled = cancel;
-+    }
 +}

patches/api/Add-PrepareResultEvent-PrepareGrindstoneEvent.patch

@@ -21,17 +21,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.inventory.GrindstoneInventory;
 +import org.bukkit.inventory.InventoryView;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Called when an item is put in a slot for grinding in a Grindstone
++ *
 + * @deprecated use {@link org.bukkit.event.inventory.PrepareGrindstoneEvent}
 + */
 +@Deprecated
-+@Warning(false)
++@Warning
 +public class PrepareGrindstoneEvent extends PrepareResultEvent {
 +
++    @ApiStatus.Internal
 +    public PrepareGrindstoneEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
 +        super(inventory, result);
 +    }
@@ -54,6 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.inventory.PrepareInventoryResultEvent;
 +import org.bukkit.inventory.InventoryView;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -63,12 +67,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +public class PrepareResultEvent extends PrepareInventoryResultEvent {
 +
 +    // HandlerList on PrepareInventoryResultEvent to ensure api compat
++
++    @ApiStatus.Internal
 +    public PrepareResultEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
 +        super(inventory, result);
 +    }
 +
 +    /**
-+     * Get result item, may be null.
++     * Get result item, may be {@code null}.
 +     *
 +     * @return result item
 +     */
@@ -78,7 +84,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Set result item, may be null.
++     * Set result item, may be {@code null}.
 +     *
 +     * @param result result item
 +     */

patches/api/Add-ProjectileCollideEvent.patch

@@ -17,31 +17,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Projectile;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityDamageByEntityEvent;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a projectile collides with an entity
 + * <p>
-+ * This event is called <b>before</b> {@link org.bukkit.event.entity.EntityDamageByEntityEvent}, and cancelling it will allow the projectile to continue flying
++ * This event is called <b>before</b> {@link EntityDamageByEntityEvent}, and cancelling it will allow the projectile to continue flying
++ *
 + * @deprecated Deprecated, use {@link org.bukkit.event.entity.ProjectileHitEvent} and check if there is a hit entity
 + */
 +@Deprecated
 +public class ProjectileCollideEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final Entity collidedWith;
 +
-+    /**
-+     * Get the entity the projectile collided with
-+     *
-+     * @return the entity collided with
-+     */
-+    @NotNull
-+    public Entity getCollidedWith() {
-+        return collidedWith;
-+    }
++    private boolean cancelled;
 +
-+    public ProjectileCollideEvent(@NotNull Projectile what, @NotNull Entity collidedWith) {
-+        super(what);
++    @ApiStatus.Internal
++    public ProjectileCollideEvent(@NotNull Projectile projectile, @NotNull Entity collidedWith) {
++        super(projectile);
 +        this.collidedWith = collidedWith;
 +    }
 +
@@ -55,28 +54,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return (Projectile) super.getEntity();
 +    }
 +
-+    private static final HandlerList handlerList = new HandlerList();
-+
++    /**
++     * Get the entity the projectile collided with
++     *
++     * @return the entity collided with
++     */
 +    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlerList;
++    public Entity getCollidedWith() {
++        return this.collidedWith;
 +    }
 +
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlerList;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
 +    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
 +}

patches/api/Add-PufferFishStateChangeEvent.patch

@@ -16,16 +16,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called just before a {@link PufferFish} inflates or deflates.
 + */
 +public class PufferFishStateChangeEvent extends EntityEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    private int newPuffState;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final int newPuffState;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PufferFishStateChangeEvent(@NotNull PufferFish entity, int newPuffState) {
 +        super(entity);
 +        this.newPuffState = newPuffState;
@@ -34,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public PufferFish getEntity() {
-+        return (PufferFish) entity;
++        return (PufferFish) super.getEntity();
 +    }
 +
 +    /**
@@ -42,6 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * <p>
 +     * This is what the {@link PufferFish}'s new puff state will be after this event if it isn't cancelled.<br>
 +     * Refer to {@link PufferFish#getPuffState()} to get the current puff state.
++     *
 +     * @return The <strong>new</strong> puff state, 0 being not inflated, 1 being slightly inflated and 2 being fully inflated
 +     */
 +    public int getNewPuffState() {
@@ -50,24 +55,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Get if the {@link PufferFish} is going to inflate.
-+     * @return If its going to inflate
++     *
++     * @return If it's going to inflate
 +     */
 +    public boolean isInflating() {
-+        return getNewPuffState() > getEntity().getPuffState();
++        return this.newPuffState > this.getEntity().getPuffState();
 +    }
 +
 +    /**
 +     * Get if the {@link PufferFish} is going to deflate.
-+     * @return If its going to deflate
++     *
++     * @return If it's going to deflate
 +     */
 +    public boolean isDeflating() {
-+        return getNewPuffState() < getEntity().getPuffState();
++        return this.newPuffState < this.getEntity().getPuffState();
 +    }
 +
 +    /**
-+     * Set whether or not to cancel the {@link PufferFish} (in/de)flating.
++     * Set whether to cancel the {@link PufferFish} (in/de)flating.
 +     *
-+     * @param cancel true if you wish to cancel the (in/de)flation
++     * @param cancel {@code true} if you wish to cancel the (in/de)flation
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
@@ -76,17 +83,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-ShulkerDuplicateEvent.patch

@@ -46,7 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    @NotNull
 +    public Shulker getEntity() {
-+        return (Shulker) entity;
++        return (Shulker) super.getEntity();
 +    }
 +
 +    /**
@@ -57,12 +57,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Shulker getParent() {
-+        return parent;
++        return this.parent;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Add-StructuresLocateEvent.patch

@@ -32,18 +32,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + *     <li>An Explorer/Treasure Map is activated.</li>
 + *     <li>{@link World#locateNearestStructure(Location, StructureType, int, boolean)} is invoked.</li>
 + * </ul>
++ *
 + * @deprecated no longer used, see {@link StructuresLocateEvent}
 + */
 +@Deprecated(forRemoval = true) @ApiStatus.ScheduledForRemoval(inVersion = "1.21")
 +public class StructureLocateEvent extends WorldEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Location origin;
 +    private Location result = null;
 +    private StructureType type;
 +    private int radius;
 +    private boolean findUnexplored;
-+    private boolean cancelled = false;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public StructureLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull StructureType structureType, int radius, boolean findUnexplored) {
 +        super(world);
 +        this.origin = origin;
@@ -52,29 +57,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.findUnexplored = findUnexplored;
 +    }
 +
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
 +    /**
 +     * Gets the location set as the structure location, if it was defined.
 +     * <p>
 +     * Returns {@code null} if it has not been set by {@link StructureLocateEvent#setResult(Location)}.
 +     * Since this event fires <i>before</i> the search is done, the actual location is unknown at this point.
 +     *
-+     * @return The result location, if it has been set. null if it has not.
++     * @return The result location, if it has been set. {@code null} if it has not.
 +     * @see World#locateNearestStructure(Location, StructureType, int, boolean)
 +     */
 +    @Nullable
 +    public Location getResult() {
-+        return result;
++        return this.result;
 +    }
 +
 +    /**
@@ -93,7 +87,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public StructureType getType() {
-+        return type;
++        return this.type;
 +    }
 +
 +    /**
@@ -112,7 +106,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getOrigin() {
-+        return origin;
++        return this.origin;
 +    }
 +
 +    /**
@@ -123,7 +117,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the search radius.
 +     */
 +    public int getRadius() {
-+        return radius;
++        return this.radius;
 +    }
 +
 +    /**
@@ -145,7 +139,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return Whether to search for only unexplored structures.
 +     */
 +    public boolean shouldFindUnexplored() {
-+        return findUnexplored;
++        return this.findUnexplored;
 +    }
 +
 +    /**
@@ -161,13 +155,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
 +    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java b/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java
 new file mode 100644
@@ -190,6 +195,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.world.WorldEvent;
 +import org.bukkit.generator.structure.Structure;
 +import org.bukkit.generator.structure.StructureType;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +import org.jetbrains.annotations.UnmodifiableView;
@@ -217,8 +223,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private List<ConfiguredStructure> legacy$structures;
 +    private int radius;
 +    private boolean findUnexplored;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public StructuresLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull List<Structure> structures, int radius, boolean findUnexplored) {
 +        super(world);
 +        this.origin = origin;
@@ -242,8 +250,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Returns {@code null} if it has not been set by {@link StructuresLocateEvent#setResult(Result)}.
 +     * Since this event fires <i>before</i> the search is done, the actual result is unknown at this point.
 +     *
-+     * @return The result location and structure, if it has been set. null if it has not.
-+     * @see World#locateNearestStructure(Location, org.bukkit.generator.structure.StructureType, int, boolean)
++     * @return The result location and structure, if it has been set. {@code null} if it has not.
++     * @see World#locateNearestStructure(Location, StructureType, int, boolean)
 +     */
 +    public @Nullable Result getResult() {
 +        return this.result;

patches/api/Add-TNTPrimeEvent.patch

@@ -12,18 +12,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.block;
 +
++import org.bukkit.Material;
 +import org.bukkit.block.Block;
++import org.bukkit.enchantments.Enchantment;
 +import org.bukkit.entity.Entity;
++import org.bukkit.entity.Player;
++import org.bukkit.entity.TNTPrimed;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
-+ * Called when TNT block is about to turn into {@link org.bukkit.entity.TNTPrimed}
++ * Called when TNT block is about to turn into {@link TNTPrimed}
 + * <p>
-+ * Cancelling it won't turn TNT into {@link org.bukkit.entity.TNTPrimed} and leaves
++ * Cancelling it won't turn TNT into {@link TNTPrimed} and leaves
 + * the TNT block as-is
 + *
 + * @author Mark Vainomaa
@@ -31,11 +36,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +@Deprecated(forRemoval = true)
 +public class TNTPrimeEvent extends BlockEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    @NotNull private PrimeReason reason;
-+    @Nullable private Entity primerEntity;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final PrimeReason reason;
++    @Nullable private final Entity primerEntity;
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public TNTPrimeEvent(@NotNull Block theBlock, @NotNull PrimeReason reason, @Nullable Entity primerEntity) {
 +        super(theBlock);
 +        this.reason = reason;
@@ -54,10 +63,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the TNT primer {@link Entity}.
-+     *
-+     * It's null if {@link #getReason()} is {@link PrimeReason#REDSTONE} or {@link PrimeReason#FIRE}.
-+     * It's not null if {@link #getReason()} is {@link PrimeReason#ITEM} or {@link PrimeReason#PROJECTILE}
-+     * It might be null if {@link #getReason()} is {@link PrimeReason#EXPLOSION}
++     * <p>
++     * It's {@code null} if {@link #getReason()} is {@link PrimeReason#REDSTONE} or {@link PrimeReason#FIRE}.
++     * It's not {@code null} if {@link #getReason()} is {@link PrimeReason#ITEM} or {@link PrimeReason#PROJECTILE}
++     * It might be {@code null} if {@link #getReason()} is {@link PrimeReason#EXPLOSION}
 +     *
 +     * @return The {@link Entity} who primed the TNT
 +     */
@@ -67,9 +76,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     * Gets whether spawning {@link TNTPrimed} should be cancelled or not
 +     *
-+     * @return Whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     * @return Whether spawning {@link TNTPrimed} should be cancelled or not
 +     */
 +    @Override
 +    public boolean isCancelled() {
@@ -77,24 +86,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Sets whether to cancel spawning {@link org.bukkit.entity.TNTPrimed} or not
++     * Sets whether to cancel spawning {@link TNTPrimed} or not
 +     *
-+     * @param cancel whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     * @param cancel whether spawning {@link TNTPrimed} should be cancelled or not
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
 +    }
 +
-+    @Nullable
++    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
-+    @Nullable
++    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    public enum PrimeReason {
@@ -109,14 +118,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        FIRE,
 +
 +        /**
-+         * When {@link org.bukkit.entity.Player} used {@link org.bukkit.Material#FLINT_AND_STEEL} or
-+         * {@link org.bukkit.Material#FIRE_CHARGE} on given TNT block
++         * When {@link Player} used {@link Material#FLINT_AND_STEEL} or
++         * {@link Material#FIRE_CHARGE} on given TNT block
 +         */
 +        ITEM,
 +
 +        /**
 +         * When TNT prime was caused by an {@link Entity} shooting TNT
-+         * using a bow with {@link org.bukkit.enchantments.Enchantment#ARROW_FIRE} enchantment
++         * using a bow with {@link Enchantment#ARROW_FIRE} enchantment
 +         */
 +        PROJECTILE,
 +

patches/api/Add-TameableDeathMessageEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -24,12 +25,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class TameableDeathMessageEvent extends EntityEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    private Component deathMessage;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    public TameableDeathMessageEvent(@NotNull Tameable what, @NotNull Component deathMessage) {
-+        super(what);
++    private Component deathMessage;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public TameableDeathMessageEvent(@NotNull Tameable tameable, @NotNull Component deathMessage) {
++        super(tameable);
 +        this.deathMessage = deathMessage;
 +    }
 +
@@ -49,12 +52,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Component deathMessage() {
-+        return deathMessage;
++        return this.deathMessage;
++    }
++
++    @NotNull
++    @Override
++    public Tameable getEntity() {
++        return (Tameable) super.getEntity();
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -64,18 +73,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    @Override
-+    public Tameable getEntity() {
-+        return (Tameable) super.getEntity();
-+    }
-+
-+    @NotNull
-+    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-TargetHitEvent-API.patch

@@ -12,13 +12,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.block;
 +
++import com.google.common.base.Preconditions;
 +import org.bukkit.block.Block;
 +import org.bukkit.block.BlockFace;
 +import org.bukkit.entity.Projectile;
-+import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.ProjectileHitEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Range;
 +
 +/**
 + * Called when a Target Block is hit by a projectile.
@@ -27,44 +29,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * and in the case that the shooter is a player, will stop them from receiving
 + * advancement criteria.
 + */
-+public class TargetHitEvent extends ProjectileHitEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
++public class TargetHitEvent extends ProjectileHitEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private int signalStrength;
 +
++    @ApiStatus.Internal
 +    public TargetHitEvent(@NotNull Projectile projectile, @NotNull Block block, @NotNull BlockFace blockFace, int signalStrength) {
 +        super(projectile, null, block, blockFace);
 +        this.signalStrength = signalStrength;
 +    }
 +
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    @Override
-+    public void setCancelled(boolean cancelled) {
-+        this.cancelled = cancelled;
-+    }
-+
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
 +    /**
 +     * Gets the strength of the redstone signal to be emitted by the Target block
 +     *
 +     * @return the strength of the redstone signal to be emitted
 +     */
-+    public int getSignalStrength() {
-+        return signalStrength;
++    public @Range(from = 0, to = 15) int getSignalStrength() {
++        return this.signalStrength;
 +    }
 +
 +    /**
@@ -72,10 +55,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     *
 +     * @param signalStrength the strength of the redstone signal to be emitted
 +     */
-+    public void setSignalStrength(int signalStrength) {
-+        if (signalStrength < 0 || signalStrength > 15) {
-+            throw new IllegalArgumentException("Signal strength out of range (" + signalStrength + "), must be in range [0,15]");
-+        }
++    public void setSignalStrength(@Range(from = 0, to = 15) int signalStrength) {
++        Preconditions.checkArgument(signalStrength >= 0 && signalStrength <= 15, "Signal strength out of range (%s), must be in range [0,15]", signalStrength);
 +        this.signalStrength = signalStrength;
 +    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
 +}

patches/api/Add-ThrownEggHatchEvent.patch

@@ -14,10 +14,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.entity;
 +
++import com.google.common.base.Preconditions;
 +import org.bukkit.entity.Egg;
 +import org.bukkit.entity.EntityType;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -26,12 +28,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * This event fires for all thrown eggs that may hatch, players, dispensers, etc.
 + */
 +public class ThrownEggHatchEvent extends Event {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Egg egg;
 +    private boolean hatching;
-+    private EntityType hatchType;
 +    private byte numHatches;
++    private EntityType hatchType;
 +
++    @ApiStatus.Internal
 +    public ThrownEggHatchEvent(@NotNull final Egg egg, final boolean hatching, final byte numHatches, @NotNull final EntityType hatchingType) {
 +        this.egg = egg;
 +        this.hatching = hatching;
@@ -46,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Egg getEgg() {
-+        return egg;
++        return this.egg;
 +    }
 +
 +    /**
@@ -56,13 +61,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return boolean Whether the egg is going to hatch or not
 +     */
 +    public boolean isHatching() {
-+        return hatching;
++        return this.hatching;
 +    }
 +
 +    /**
 +     * Sets whether the egg will hatch or not.
 +     *
-+     * @param hatching true if you want the egg to hatch, false if you want it
++     * @param hatching {@code true} if you want the egg to hatch, {@code false} if you want it
 +     *     not to
 +     */
 +    public void setHatching(boolean hatching) {
@@ -70,13 +75,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Get the type of the mob being hatched (EntityType.CHICKEN by default)
++     * Get the type of the mob being hatched ({@link EntityType#CHICKEN} by default)
 +     *
 +     * @return The type of the mob being hatched by the egg
 +     */
 +    @NotNull
 +    public EntityType getHatchingType() {
-+        return hatchType;
++        return this.hatchType;
 +    }
 +
 +    /**
@@ -85,7 +90,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param hatchType The type of the mob being hatched by the egg
 +     */
 +    public void setHatchingType(@NotNull EntityType hatchType) {
-+        if (!hatchType.isSpawnable()) throw new IllegalArgumentException("Can't spawn that entity type from an egg!");
++        Preconditions.checkArgument(hatchType.isSpawnable(), "Can't spawn that entity type from an egg!");
 +        this.hatchType = hatchType;
 +    }
 +
@@ -93,22 +98,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Get the number of mob hatches from the egg. By default the number will
 +     * be the number the server would've done
 +     * <ul>
-+     * <li>7/8 chance of being 0
-+     * <li>31/256 ~= 1/8 chance to be 1
-+     * <li>1/256 chance to be 4
++     *  <li>7/8 chance of being 0
++     *  <li>31/256 ~= 1/8 chance to be 1
++     *  <li>1/256 chance to be 4
 +     * </ul>
 +     *
 +     * @return The number of mobs going to be hatched by the egg
 +     */
 +    public byte getNumHatches() {
-+        return numHatches;
++        return this.numHatches;
 +    }
 +
 +    /**
 +     * Change the number of mobs coming out of the hatched egg
 +     * <p>
-+     * The boolean hatching will override this number. Ie. If hatching =
-+     * false, this number will not matter
++     * The boolean hatching will override this number. I.e. If hatching is
++     * {@code false}, this number will not matter
 +     *
 +     * @param numHatches The number of mobs coming out of the egg
 +     */
@@ -119,11 +124,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-UnknownCommandEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.command.CommandSender;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.Contract;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
@@ -25,11 +26,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Thrown when a player executes a command that is not defined
 + */
 +public class UnknownCommandEvent extends Event {
-+    private static final HandlerList handlers = new HandlerList();
-+    @NotNull private CommandSender sender;
-+    @NotNull private String commandLine;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final CommandSender sender;
++    @NotNull private final String commandLine;
 +    @Nullable private Component message;
 +
++    @ApiStatus.Internal
 +    public UnknownCommandEvent(@NotNull final CommandSender sender, @NotNull final String commandLine, @Nullable final Component message) {
 +        super(false);
 +        this.sender = sender;
@@ -39,29 +43,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the CommandSender or ConsoleCommandSender
-+     * <p>
 +     *
 +     * @return Sender of the command
 +     */
 +    @NotNull
 +    public CommandSender getSender() {
-+        return sender;
++        return this.sender;
 +    }
 +
 +    /**
-+     * Gets the command that was send
-+     * <p>
++     * Gets the command that was sent
 +     *
 +     * @return Command sent
 +     */
 +    @NotNull
 +    public String getCommandLine() {
-+        return commandLine;
++        return this.commandLine;
 +    }
 +
 +    /**
 +     * Gets message that will be returned
-+     * <p>
 +     *
 +     * @return Unknown command message
 +     * @deprecated use {@link #message()}
@@ -75,9 +76,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Sets message that will be returned
 +     * <p>
-+     * Set to null to avoid any message being sent
++     * Set to {@code null} to avoid any message being sent
 +     *
-+     * @param message the message to be returned, or null
++     * @param message the message to be returned, or {@code null}
 +     * @deprecated use {@link #message(Component)}
 +     */
 +    @Deprecated
@@ -87,7 +88,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets message that will be returned
-+     * <p>
 +     *
 +     * @return Unknown command message
 +     */
@@ -100,9 +100,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Sets message that will be returned
 +     * <p>
-+     * Set to null to avoid any message being sent
++     * Set to {@code null} to avoid any message being sent
 +     *
-+     * @param message the message to be returned, or null
++     * @param message the message to be returned, or {@code null}
 +     */
 +    public void message(@Nullable Component message) {
 +        this.message = message;
@@ -111,12 +111,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 +

patches/api/Add-WardenAngerChangeEvent.patch

@@ -14,6 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.entity;
 +
++import com.google.common.base.Preconditions;
 +import org.bukkit.entity.Entity;
 +import org.bukkit.entity.Warden;
 +import org.bukkit.event.Cancellable;
@@ -21,6 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.entity.EntityEvent;
 +import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Range;
 +
 +/**
 + * Called when a Warden's anger level has changed due to another entity.
@@ -31,11 +33,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final Entity target;
 +    private final int oldAnger;
 +    private int newAnger;
 +
++    private boolean cancelled;
++
 +    @ApiStatus.Internal
 +    public WardenAngerChangeEvent(@NotNull final Warden warden, @NotNull final Entity target, final int oldAnger, final int newAnger) {
 +        super(warden);
@@ -51,7 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getTarget() {
-+        return target;
++        return this.target;
 +    }
 +
 +    /**
@@ -60,8 +63,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return old anger level
 +     * @see Warden#getAnger(Entity)
 +     */
++    @Range(from = 0, to = 150)
 +    public int getOldAnger() {
-+        return oldAnger;
++        return this.oldAnger;
 +    }
 +
 +    /**
@@ -70,8 +74,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return new anger level
 +     * @see Warden#getAnger(Entity)
 +     */
++    @Range(from = 0, to = 150)
 +    public int getNewAnger() {
-+        return newAnger;
++        return this.newAnger;
 +    }
 +
 +    /**
@@ -83,27 +88,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @see Warden#setAnger(Entity, int)
 +     * @throws IllegalArgumentException if newAnger is greater than 150
 +     */
-+    public void setNewAnger(int newAnger) {
-+        if (newAnger > 150)
-+            throw new IllegalArgumentException("newAnger must not be greater than 150");
-+
++    public void setNewAnger(@Range(from = 0, to = 150) int newAnger) {
++        Preconditions.checkArgument(newAnger <= 150, "newAnger must not be greater than 150");
 +        this.newAnger = newAnger;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public Warden getEntity() {
-+        return (Warden) entity;
++        return (Warden) super.getEntity();
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
-+    public void setCancelled(boolean cancelled) {
-+        this.cancelled = cancelled;
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull

patches/api/Add-WaterBottleSplashEvent.patch

@@ -19,6 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.LivingEntity;
 +import org.bukkit.entity.ThrownPotion;
 +import org.bukkit.event.entity.PotionSplashEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Unmodifiable;
 +
@@ -27,9 +28,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * different entities in different ways.
 + */
 +public class WaterBottleSplashEvent extends PotionSplashEvent {
++
 +    private final @NotNull Set<LivingEntity> rehydrate;
 +    private final @NotNull Set<LivingEntity> extinguish;
 +
++    @ApiStatus.Internal
 +    public WaterBottleSplashEvent(
 +        final @NotNull ThrownPotion potion,
 +        final @NotNull Map<LivingEntity, Double> affectedEntities,
@@ -114,6 +117,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Doesn't make sense for this event as intensity doesn't vary.
++     *
 +     * @return a confusing value
 +     * @deprecated check if {@link #getToDamage()} contains an entity
 +     */
@@ -125,6 +129,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Doesn't make sense for this event as intensity doesn't vary.
++     *
 +     * @deprecated use {@link #damageAsWaterSensitive(LivingEntity)}
 +     * or {@link #doNotDamageAsWaterSensitive(LivingEntity)} to change which entities are
 +     * damaged

patches/api/Add-WhitelistToggleEvent.patch

@@ -14,6 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -22,10 +23,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * @author Mark Vainomaa
 + */
 +public class WhitelistToggleEvent extends Event {
-+    private static final HandlerList handlers = new HandlerList();
 +
-+    private boolean enabled;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
++    private final boolean enabled;
++
++    @ApiStatus.Internal
 +    public WhitelistToggleEvent(boolean enabled) {
 +        this.enabled = enabled;
 +    }
@@ -36,17 +39,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return Whether whitelist is going to be enabled or not
 +     */
 +    public boolean isEnabled() {
-+        return enabled;
++        return this.enabled;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-and-implement-PlayerRecipeBookClickEvent.patch

@@ -17,17 +17,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a player clicks a recipe in the recipe book
 + */
 +public class PlayerRecipeBookClickEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancel = false;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private NamespacedKey recipe;
 +    private boolean makeAll;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerRecipeBookClickEvent(@NotNull Player player, @NotNull NamespacedKey recipe, boolean makeAll) {
 +        super(player);
 +        this.recipe = recipe;
@@ -41,7 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public NamespacedKey getRecipe() {
-+        return recipe;
++        return this.recipe;
 +    }
 +
 +    /**
@@ -54,17 +59,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * Gets a boolean which indicates whether or not the player requested to make the maximum amount of results. This is
-+     * true if shift is pressed while the recipe is clicked in the recipe book
++     * Gets a boolean which indicates whether the player requested to make the maximum amount of results. This is
++     * {@code true} if shift is pressed while the recipe is clicked in the recipe book
 +     *
 +     * @return {@code true} if shift is pressed while the recipe is clicked
 +     */
 +    public boolean isMakeAll() {
-+        return makeAll;
++        return this.makeAll;
 +    }
 +
 +    /**
-+     * Sets whether or not the maximum amount of results should be made. If this is true, the request is handled as if
++     * Sets whether the maximum amount of results should be made. If this is {@code true}, the request is handled as if
 +     * the player had pressed shift while clicking on the recipe
 +     *
 +     * @param makeAll {@code true} if the request should attempt to make the maximum amount of results
@@ -75,23 +80,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/event/player/PlayerRecipeBookClickEvent.java b/src/main/java/org/bukkit/event/player/PlayerRecipeBookClickEvent.java

patches/api/Add-event-for-player-editing-sign.patch

@@ -14,6 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.block.Sign;
 +import org.bukkit.block.sign.Side;
++import org.bukkit.entity.HumanEntity;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
@@ -27,12 +28,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Cancelling this event stops the sign editing menu from opening.
 + */
 +public class PlayerOpenSignEvent extends PlayerEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
-+    private boolean cancel = false;
++
 +    private final Sign sign;
 +    private final Side side;
 +    private final Cause cause;
 +
++    private boolean cancelled;
++
 +    @ApiStatus.Internal
 +    public PlayerOpenSignEvent(final @NotNull Player editor, final @NotNull Sign sign, final @NotNull Side side, final @NotNull Cause cause) {
 +        super(editor);
@@ -48,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Sign getSign() {
-+        return sign;
++        return this.sign;
 +    }
 +
 +    /**
@@ -59,7 +63,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Side getSide() {
-+        return side;
++        return this.side;
 +    }
 +
 +    /**
@@ -68,17 +72,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the cause
 +     */
 +    public @NotNull Cause getCause() {
-+        return cause;
++        return this.cause;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
@@ -105,7 +109,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        INTERACT,
 +        /**
-+         * The event was triggered via a plugin with {@link org.bukkit.entity.HumanEntity#openSign(Sign, Side)}
++         * The event was triggered via a plugin with {@link HumanEntity#openSign(Sign, Side)}
 +         */
 +        PLUGIN,
 +        /**

patches/api/Add-exception-reporting-event.patch

@@ -12,23 +12,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.server;
 +
-+import com.google.common.base.Preconditions;
 +import org.bukkit.Bukkit;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import com.destroystokyo.paper.exception.ServerException;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called whenever an exception is thrown in a recoverable section of the server.
 + */
 +public class ServerExceptionEvent extends Event {
-+    private static final HandlerList handlers = new HandlerList();
-+    @NotNull private ServerException exception;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final ServerException exception;
++
++    @ApiStatus.Internal
 +    public ServerExceptionEvent(@NotNull ServerException exception) {
 +        super(!Bukkit.isPrimaryThread());
-+        this.exception = Preconditions.checkNotNull(exception, "exception");
++        this.exception = exception;
 +    }
 +
 +    /**
@@ -38,18 +41,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ServerException getException() {
-+        return exception;
++        return this.exception;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/exception/ServerCommandException.java b/src/main/java/com/destroystokyo/paper/exception/ServerCommandException.java

patches/api/Add-extended-PaperServerListPingEvent.patch

@@ -30,6 +30,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import java.util.NoSuchElementException;
 +import java.util.UUID;
 +
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -56,6 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private Object[] players;
 +
 +    @Deprecated
++    @ApiStatus.Internal
 +    public PaperServerListPingEvent(@NotNull StatusClient client, @NotNull String motd, int numPlayers, int maxPlayers,
 +            @NotNull String version, int protocolVersion, @Nullable CachedServerIcon favicon) {
 +        super("", client.getAddress().getAddress(), motd, numPlayers, maxPlayers);
@@ -66,6 +68,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        setServerIcon(favicon);
 +    }
 +
++    @ApiStatus.Internal
 +    public PaperServerListPingEvent(@NotNull StatusClient client, @NotNull net.kyori.adventure.text.Component motd, int numPlayers, int maxPlayers,
 +                                    @NotNull String version, int protocolVersion, @Nullable CachedServerIcon favicon) {
 +        super("", client.getAddress().getAddress(), motd, numPlayers, maxPlayers);
@@ -103,9 +106,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets the number of players displayed in the server list.
-+     *
-+     * <p>Note that this won't have any effect if {@link #shouldHidePlayers()}
-+     * is enabled.</p>
++     * <p>
++     * Note that this won't have any effect if {@link #shouldHidePlayers()}
++     * is enabled.
 +     *
 +     * @param numPlayers The number of online players
 +     */
@@ -118,9 +121,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * {@inheritDoc}
-+     *
-+     * <p>Returns {@code -1} if players are hidden using
-+     * {@link #shouldHidePlayers()}.</p>
++     * <p>
++     * Returns {@code -1} if players are hidden using
++     * {@link #shouldHidePlayers()}.
 +     */
 +    @Override
 +    public int getMaxPlayers() {
@@ -135,23 +138,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Returns whether all player related information is hidden in the server
 +     * list. This will cause {@link #getNumPlayers()}, {@link #getMaxPlayers()}
 +     * and {@link #getPlayerSample()} to be skipped in the response.
-+     *
-+     * <p>The Vanilla Minecraft client will display the player count as {@code ???}
-+     * when this option is enabled.</p>
++     * <p>
++     * The Vanilla Minecraft client will display the player count as {@code ???}
++     * when this option is enabled.
 +     *
 +     * @return {@code true} if the player count is hidden
 +     */
 +    public boolean shouldHidePlayers() {
-+        return hidePlayers;
++        return this.hidePlayers;
 +    }
 +
 +    /**
 +     * Sets whether all player related information is hidden in the server
 +     * list. This will cause {@link #getNumPlayers()}, {@link #getMaxPlayers()}
 +     * and {@link #getPlayerSample()} to be skipped in the response.
-+     *
-+     * <p>The Vanilla Minecraft client will display the player count as {@code ???}
-+     * when this option is enabled.</p>
++     * <p>
++     * The Vanilla Minecraft client will display the player count as {@code ???}
++     * when this option is enabled.
 +     *
 +     * @param hidePlayers {@code true} if the player count should be hidden
 +     */
@@ -162,9 +165,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Returns a mutable list of {@link PlayerProfile} that will be displayed
 +     * as online players on the client.
-+     *
-+     * <p>The Vanilla Minecraft client will display them when hovering the
-+     * player count with the mouse.</p>
++     * <p>
++     * The Vanilla Minecraft client will display them when hovering the
++     * player count with the mouse.
 +     *
 +     * @return The mutable player sample list
 +     */
@@ -180,7 +183,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public String getVersion() {
-+        return version;
++        return this.version;
 +    }
 +
 +    /**
@@ -200,7 +203,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * has not finished initialization yet
 +     */
 +    public int getProtocolVersion() {
-+        return protocolVersion;
++        return this.protocolVersion;
 +    }
 +
 +    /**
@@ -240,9 +243,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * {@inheritDoc}
-+     *
-+     * <p>Cancelling this event will cause the connection to be closed immediately,
-+     * without sending a response to the client.</p>
++     * <p>
++     * Cancelling this event will cause the connection to be closed immediately,
++     * without sending a response to the client.
 +     */
 +    @Override
 +    public boolean isCancelled() {
@@ -251,9 +254,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * {@inheritDoc}
-+     *
-+     * <p>Cancelling this event will cause the connection to be closed immediately,
-+     * without sending a response to the client.</p>
++     * <p>
++     * Cancelling this event will cause the connection to be closed immediately,
++     * without sending a response to the client.
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
@@ -262,10 +265,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * {@inheritDoc}
-+     *
-+     * <p><b>Note:</b> For compatibility reasons, this method will return all
++     * <p>
++     * <b>Note:</b> For compatibility reasons, this method will return all
 +     * online players, not just the ones referenced in {@link #getPlayerSample()}.
-+     * Removing a player will:</p>
++     * Removing a player will:
 +     *
 +     * <ul>
 +     *     <li>Decrement the online player count (if and only if) the player
@@ -294,6 +297,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return (Player) player;
 +    }
 +
++    @ApiStatus.Internal
 +    private final class PlayerIterator implements Iterator<Player> {
 +
 +        private int next;

patches/api/Add-handshake-event-to-allow-plugins-to-handle-clien.patch

@@ -20,6 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -27,18 +28,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +/**
 + * This event is fired during a player handshake.
-+ *
-+ * <p>If there are no listeners listening to this event, the logic default
-+ * to your server platform will be ran.</p>
++ * <p>
++ * If there are no listeners listening to this event, the logic default
++ * to your server platform will be run.
 + *
 + * <p>WARNING: TAMPERING WITH THIS EVENT CAN BE DANGEROUS</p>
 + */
 +public class PlayerHandshakeEvent extends Event implements Cancellable {
 +
-+    private static final HandlerList HANDLERS = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final String originalHandshake;
 +    @NotNull private final String originalSocketAddressHostname;
-+    private boolean cancelled;
 +    @Nullable private String serverHostname;
 +    @Nullable private String socketAddressHostname;
 +    @Nullable private UUID uniqueId;
@@ -46,26 +47,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private boolean failed;
 +    private Component failMessage = Component.text("If you wish to use IP forwarding, please enable it in your BungeeCord config as well!", NamedTextColor.YELLOW);
 +
-+    /**
-+     * Creates a new {@link PlayerHandshakeEvent}.
-+     *
-+     * @param originalHandshake the original handshake string
-+     * @param cancelled if this event is enabled
-+     *
-+     * @deprecated in favour of {@link PlayerHandshakeEvent(String, String, boolean)}
-+     */
++    private boolean cancelled;
++
 +    @Deprecated
++    @ApiStatus.Internal
 +    public PlayerHandshakeEvent(@NotNull String originalHandshake, boolean cancelled) {
 +        this(originalHandshake, "127.0.0.1", cancelled);
 +    }
 +
-+    /**
-+     * Creates a new {@link PlayerHandshakeEvent}.
-+     *
-+     * @param originalHandshake the original handshake string
-+     * @param originalSocketAddressHostname the original socket address hostname
-+     * @param cancelled if this event is enabled
-+     */
++    @ApiStatus.Internal
 +    public PlayerHandshakeEvent(@NotNull String originalHandshake, @NotNull String originalSocketAddressHostname, boolean cancelled) {
 +        super(true);
 +        this.originalHandshake = originalHandshake;
@@ -75,9 +65,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Determines if this event is cancelled.
-+     *
-+     * <p>When this event is cancelled, custom handshake logic will not
-+     * be processed.</p>
++     * <p>
++     * When this event is cancelled, custom handshake logic will not
++     * be processed.
 +     *
 +     * @return {@code true} if this event is cancelled, {@code false} otherwise
 +     */
@@ -88,15 +78,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets if this event is cancelled.
++     * <p>
++     * When this event is cancelled, custom handshake logic will not
++     * be processed.
 +     *
-+     * <p>When this event is cancelled, custom handshake logic will not
-+     * be processed.</p>
-+     *
-+     * @param cancelled {@code true} if this event is cancelled, {@code false} otherwise
++     * @param cancel {@code true} if this event is cancelled, {@code false} otherwise
 +     */
 +    @Override
-+    public void setCancelled(boolean cancelled) {
-+        this.cancelled = cancelled;
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    /**
@@ -201,9 +191,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Determines if authentication failed.
-+     *
-+     * <p>When {@code true}, the client connecting will be disconnected
-+     * with the {@link #getFailMessage() fail message}.</p>
++     * <p>
++     * When {@code true}, the client connecting will be disconnected
++     * with the {@link #getFailMessage() fail message}.
 +     *
 +     * @return {@code true} if authentication failed, {@code false} otherwise
 +     */
@@ -213,9 +203,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets if authentication failed and the client should be disconnected.
-+     *
-+     * <p>When {@code true}, the client connecting will be disconnected
-+     * with the {@link #getFailMessage() fail message}.</p>
++     * <p>
++     * When {@code true}, the client connecting will be disconnected
++     * with the {@link #getFailMessage() fail message}.
 +     *
 +     * @param failed {@code true} if authentication failed, {@code false} otherwise
 +     */
@@ -280,11 +270,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-more-fields-to-AsyncPreLoginEvent.patch

@@ -14,7 +14,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
  import java.net.InetAddress;
  import java.util.UUID;
-+
 +import com.destroystokyo.paper.profile.PlayerProfile;
 +import org.bukkit.Bukkit;
  import org.bukkit.event.Event;
@@ -80,8 +79,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public UUID getUniqueId() {
 -        return uniqueId;
 +        return profile.getId(); // Paper
-     }
- 
++    }
++
 +    // Paper start
 +    /**
 +     * Gets the PlayerProfile of the player logging in
@@ -107,8 +106,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    public InetAddress getRawAddress() {
 +        return rawAddress;
-+    }
-+
+     }
+ 
 +    /**
 +     * Gets the hostname that the player used to connect to the server, or
 +     * blank if unknown

patches/api/Add-spectator-target-events.patch

@@ -19,6 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -26,11 +27,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerStartSpectatingEntityEvent extends PlayerEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final Entity currentSpectatorTarget;
 +    @NotNull private final Entity newSpectatorTarget;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerStartSpectatingEntityEvent(@NotNull Player player, @NotNull Entity currentSpectatorTarget, @NotNull Entity newSpectatorTarget) {
 +        super(player);
 +        this.currentSpectatorTarget = currentSpectatorTarget;
@@ -44,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getCurrentSpectatorTarget() {
-+        return currentSpectatorTarget;
++        return this.currentSpectatorTarget;
 +    }
 +
 +    /**
@@ -54,12 +58,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getNewSpectatorTarget() {
-+        return newSpectatorTarget;
++        return this.newSpectatorTarget;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -70,12 +74,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 +
@@ -92,6 +96,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -99,10 +104,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerStopSpectatingEntityEvent extends PlayerEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
-+    @NotNull private final Entity spectatorTarget;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
++    @NotNull private final Entity spectatorTarget;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerStopSpectatingEntityEvent(@NotNull Player player, @NotNull Entity spectatorTarget) {
 +        super(player);
 +        this.spectatorTarget = spectatorTarget;
@@ -115,12 +122,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getSpectatorTarget() {
-+        return spectatorTarget;
++        return this.spectatorTarget;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -131,11 +138,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Add-whitelist-events.patch

@@ -18,6 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -26,12 +27,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +public class WhitelistStateUpdateEvent extends Event implements Cancellable {
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
-+    private boolean cancel = false;
++
 +    @NotNull private final PlayerProfile playerProfile;
 +    @NotNull private final WhitelistStatus status;
 +
-+    public WhitelistStateUpdateEvent(@NotNull PlayerProfile who, @NotNull WhitelistStatus status) {
-+        this.playerProfile = who;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public WhitelistStateUpdateEvent(@NotNull PlayerProfile playerProfile, @NotNull WhitelistStatus status) {
++        this.playerProfile = playerProfile;
 +        this.status = status;
 +    }
 +
@@ -42,7 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public OfflinePlayer getPlayer() {
-+        return Bukkit.getOfflinePlayer(playerProfile.getId());
++        return Bukkit.getOfflinePlayer(this.playerProfile.getId());
 +    }
 +
 +    /**
@@ -52,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PlayerProfile getPlayerProfile() {
-+        return playerProfile;
++        return this.playerProfile;
 +    }
 +
 +    /**
@@ -62,17 +66,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public WhitelistStatus getStatus() {
-+        return status;
++        return this.status;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull

patches/api/Add-worldborder-events.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.WorldBorder;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -31,6 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private long duration;
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public WorldBorderBoundsChangeEvent(@NotNull World world, @NotNull WorldBorder worldBorder, @NotNull Type type, double oldSize, double newSize, long duration) {
 +        super(world, worldBorder);
 +        this.type = type;
@@ -46,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Type getType() {
-+        return type;
++        return this.type;
 +    }
 +
 +    /**
@@ -55,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the old size
 +     */
 +    public double getOldSize() {
-+        return oldSize;
++        return this.oldSize;
 +    }
 +
 +    /**
@@ -64,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the new size
 +     */
 +    public double getNewSize() {
-+        return newSize;
++        return this.newSize;
 +    }
 +
 +    /**
@@ -73,8 +75,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param newSize the new size
 +     */
 +    public void setNewSize(double newSize) {
-+        // PAIL: TODO: Magic Values
-+        this.newSize = Math.min(6.0E7D, Math.max(1.0D, newSize));
++        this.newSize = Math.min(this.worldBorder.getMaxSize(), Math.max(1.0D, newSize));
 +    }
 +
 +    /**
@@ -83,7 +84,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the time in milliseconds for the change
 +     */
 +    public long getDuration() {
-+        return duration;
++        return this.duration;
 +    }
 +
 +    /**
@@ -95,12 +96,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public void setDuration(long duration) {
 +        // PAIL: TODO: Magic Values
 +        this.duration = Math.min(9223372036854775L, Math.max(0L, duration));
-+        if (duration >= 0 && type == Type.INSTANT_MOVE) type = Type.STARTED_MOVE;
++        if (duration >= 0 && this.type == Type.INSTANT_MOVE) {
++            this.type = Type.STARTED_MOVE;
++        }
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -135,6 +138,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.World;
 +import org.bukkit.WorldBorder;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -148,6 +152,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final double newSize;
 +    private final double duration;
 +
++    @ApiStatus.Internal
 +    public WorldBorderBoundsChangeFinishEvent(@NotNull World world, @NotNull WorldBorder worldBorder, double oldSize, double newSize, double duration) {
 +        super(world, worldBorder);
 +        this.oldSize = oldSize;
@@ -161,7 +166,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the old size
 +     */
 +    public double getOldSize() {
-+        return oldSize;
++        return this.oldSize;
 +    }
 +
 +    /**
@@ -170,18 +175,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the new size
 +     */
 +    public double getNewSize() {
-+        return newSize;
++        return this.newSize;
 +    }
 +
 +    /**
 +     * Gets the duration this worldborder took to make the change.
 +     * <p>
-+     * Can be 0 if handlers for {@link io.papermc.paper.event.world.border.WorldBorderCenterChangeEvent} set the duration to 0.
++     * Can be 0 if handlers for {@link WorldBorderCenterChangeEvent} set the duration to 0.
 +     *
 +     * @return the duration of the transition
 +     */
 +    public double getDuration() {
-+        return duration;
++        return this.duration;
 +    }
 +
 +    @NotNull
@@ -208,7 +213,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.WorldBorder;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
-+import org.bukkit.event.world.WorldEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -220,8 +225,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private final Location oldCenter;
 +    private Location newCenter;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public WorldBorderCenterChangeEvent(@NotNull World world, @NotNull WorldBorder worldBorder, @NotNull Location oldCenter, @NotNull Location newCenter) {
 +        super(world, worldBorder);
 +        this.oldCenter = oldCenter;
@@ -235,7 +242,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getOldCenter() {
-+        return oldCenter;
++        return this.oldCenter;
 +    }
 +
 +    /**
@@ -245,7 +252,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getNewCenter() {
-+        return newCenter;
++        return this.newCenter;
 +    }
 +
 +    /**
@@ -259,7 +266,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
@@ -288,21 +295,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.World;
 +import org.bukkit.WorldBorder;
-+import org.bukkit.event.Cancellable;
 +import org.bukkit.event.world.WorldEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +public abstract class WorldBorderEvent extends WorldEvent {
 +
-+    private final WorldBorder worldBorder;
++    protected final WorldBorder worldBorder;
 +
-+    public WorldBorderEvent(@NotNull World world, @NotNull WorldBorder worldBorder) {
++    @ApiStatus.Internal
++    protected WorldBorderEvent(@NotNull World world, @NotNull WorldBorder worldBorder) {
 +        super(world);
 +        this.worldBorder = worldBorder;
 +    }
 +
 +    @NotNull
 +    public WorldBorder getWorldBorder() {
-+        return worldBorder;
++        return this.worldBorder;
 +    }
 +}

patches/api/Added-EntityDamageItemEvent.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -28,10 +29,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +public class EntityDamageItemEvent extends EntityEvent implements Cancellable {
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final ItemStack item;
 +    private int damage;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public EntityDamageItemEvent(@NotNull Entity entity, @NotNull ItemStack item, int damage) {
 +        super(entity);
 +        this.item = item;
@@ -45,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItem() {
-+        return item;
++        return this.item;
 +    }
 +
 +    /**
@@ -54,7 +58,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return durability change
 +     */
 +    public int getDamage() {
-+        return damage;
++        return this.damage;
 +    }
 +
 +    /**
@@ -68,12 +72,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull

patches/api/Added-EntityToggleSitEvent.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -25,9 +26,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final boolean isSitting;
++    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public EntityToggleSitEvent(@NotNull Entity entity, boolean isSitting) {
 +        super(entity);
 +        this.isSitting = isSitting;

patches/api/Added-PlayerBedFailEnterEvent.patch

@@ -18,6 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -29,8 +30,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final Block bed;
 +    private boolean willExplode;
 +    private Component message;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerBedFailEnterEvent(@NotNull Player player, @NotNull FailReason failReason, @NotNull Block bed, boolean willExplode, @Nullable Component message) {
 +        super(player);
 +        this.failReason = failReason;
@@ -41,16 +44,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    public FailReason getFailReason() {
-+        return failReason;
++        return this.failReason;
 +    }
 +
 +    @NotNull
 +    public Block getBed() {
-+        return bed;
++        return this.bed;
 +    }
 +
 +    public boolean getWillExplode() {
-+        return willExplode;
++        return this.willExplode;
 +    }
 +
 +    public void setWillExplode(boolean willExplode) {
@@ -59,7 +62,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Nullable
 +    public Component getMessage() {
-+        return message;
++        return this.message;
 +    }
 +
 +    public void setMessage(@Nullable Component message) {
@@ -68,19 +71,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
-+     * Cancel this event.
++     * {@inheritDoc}
 +     * <p>
-+     * <b>NOTE: This does not cancel the player getting in the bed, but any messages/explosions
-+     * that may occur because of the interaction.</b>
-+     * @param cancel true if you wish to cancel this event
++     * <b>NOTE</b>: This does not cancel the player getting in the bed, but any messages/explosions
++     * that may occur because of the interaction.
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
@@ -94,7 +96,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return HANDLER_LIST;
 +    }
 +
-+    public static enum FailReason {
++    public enum FailReason {
 +        /**
 +         * The world doesn't allow sleeping (ex. Nether or The End). Entering
 +         * the bed is prevented and the bed explodes.
@@ -124,8 +126,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        /**
 +         * Entering the bed is prevented due to there being monsters nearby.
 +         */
-+        NOT_SAFE;
-+
-+        public static final FailReason[] VALUES = values();
++        NOT_SAFE
 +    }
 +}

patches/api/Added-PlayerChangeBeaconEffectEvent.patch

@@ -26,21 +26,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Called when a player sets the effect for a beacon
 + */
 +public class PlayerChangeBeaconEffectEvent extends PlayerEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
++    private final Block beacon;
 +    private PotionEffectType primary;
 +    private PotionEffectType secondary;
-+    private final Block beacon;
 +    private boolean consumeItem = true;
 +
-+    private boolean isCancelled;
++    private boolean cancelled;
 +
 +    @ApiStatus.Internal
 +    public PlayerChangeBeaconEffectEvent(@NotNull Player player, @Nullable PotionEffectType primary, @Nullable PotionEffectType secondary, @NotNull Block beacon) {
 +        super(player);
 +        this.primary = primary;
 +        this.secondary = secondary;
-+        this.isCancelled = false;
 +        this.beacon = beacon;
 +    }
 +
@@ -48,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the primary effect
 +     */
 +    @Nullable public PotionEffectType getPrimary() {
-+        return primary;
++        return this.primary;
 +    }
 +
 +    /**
@@ -66,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the secondary effect
 +     */
 +    @Nullable public PotionEffectType getSecondary() {
-+        return secondary;
++        return this.secondary;
 +    }
 +
 +    /**
@@ -86,7 +86,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Block getBeacon() {
-+        return beacon;
++        return this.beacon;
 +    }
 +
 +    /**
@@ -95,10 +95,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Independent of {@link #isCancelled()}. If the event is cancelled
 +     * the item will <b>NOT</b> be consumed.
 +     *
-+     * @return true if item will be consumed
++     * @return {@code true} if item will be consumed
 +     */
 +    public boolean willConsumeItem() {
-+        return consumeItem;
++        return this.consumeItem;
 +    }
 +
 +    /**
@@ -107,40 +107,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Independent of {@link #isCancelled()}. If the event is cancelled
 +     * the item will <b>NOT</b> be consumed.
 +     *
-+     * @param consumeItem true if item should be consumed
++     * @param consumeItem {@code true} if item should be consumed
 +     */
 +    public void setConsumeItem(boolean consumeItem) {
 +        this.consumeItem = consumeItem;
 +    }
 +
 +    /**
-+     * Gets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
++     * {@inheritDoc}
 +     * <p>
 +     * If a {@link PlayerChangeBeaconEffectEvent} is cancelled, the changes will
 +     * not take effect
-+     *
-+     * @return true if this event is cancelled
 +     */
 +    @Override
 +    public boolean isCancelled() {
-+        return this.isCancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
-+     * Sets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
++     * {@inheritDoc}
 +     * <p>
 +     * If cancelled, the item will <b>NOT</b> be consumed regardless of what {@link #willConsumeItem()} says
 +     * <p>
 +     * If a {@link PlayerChangeBeaconEffectEvent} is cancelled, the changes will not be applied
 +     * or saved.
-+     *
-+     * @param cancel true if you wish to cancel this event
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.isCancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @Override

patches/api/Added-PlayerDeepSleepEvent.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -31,13 +32,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerDeepSleepEvent(@NotNull Player player) {
 +        super(player);
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Added-PlayerLecternPageChangeEvent.patch

@@ -18,20 +18,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
-+import org.jetbrains.annotations.Nullable;
 +
 +public class PlayerLecternPageChangeEvent extends PlayerEvent implements Cancellable {
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final Lectern lectern;
 +    private final ItemStack book;
 +    private final PageChangeDirection pageChangeDirection;
 +    private final int oldPage;
 +    private int newPage;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerLecternPageChangeEvent(@NotNull Player player, @NotNull Lectern lectern, @NotNull ItemStack book, @NotNull PageChangeDirection pageChangeDirection, int oldPage, int newPage) {
 +        super(player);
 +        this.lectern = lectern;
@@ -48,7 +50,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Lectern getLectern() {
-+        return lectern;
++        return this.lectern;
 +    }
 +
 +    /**
@@ -68,7 +70,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PageChangeDirection getPageChangeDirection() {
-+        return pageChangeDirection;
++        return this.pageChangeDirection;
 +    }
 +
 +    /**
@@ -77,7 +79,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the page changed from
 +     */
 +    public int getOldPage() {
-+        return oldPage;
++        return this.oldPage;
 +    }
 +
 +    /**
@@ -86,7 +88,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return the page changed to
 +     */
 +    public int getNewPage() {
-+        return newPage;
++        return this.newPage;
 +    }
 +
 +    /**
@@ -101,7 +103,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Added-PlayerLoomPatternSelectEvent.patch

@@ -18,6 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.LoomInventory;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -27,10 +28,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final LoomInventory loomInventory;
 +    private PatternType patternType;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerLoomPatternSelectEvent(@NotNull Player player, @NotNull LoomInventory loomInventory, @NotNull PatternType patternType) {
 +        super(player);
 +        this.loomInventory = loomInventory;
@@ -44,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public LoomInventory getLoomInventory() {
-+        return loomInventory;
++        return this.loomInventory;
 +    }
 +
 +    /**
@@ -54,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PatternType getPatternType() {
-+        return patternType;
++        return this.patternType;
 +    }
 +
 +    /**
@@ -68,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Added-PlayerStonecutterRecipeSelectEvent.patch

@@ -24,10 +24,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancelled;
 +    private final StonecutterInventory stonecutterInventory;
 +    private StonecuttingRecipe stonecuttingRecipe;
 +
++    private boolean cancelled;
++
 +    public PlayerStonecutterRecipeSelectEvent(@NotNull Player player, @NotNull StonecutterInventory stonecutterInventory, @NotNull StonecuttingRecipe stonecuttingRecipe) {
 +        super(player);
 +        this.stonecutterInventory = stonecutterInventory;
@@ -36,12 +37,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    public StonecutterInventory getStonecutterInventory() {
-+        return stonecutterInventory;
++        return this.stonecutterInventory;
 +    }
 +
 +    @NotNull
 +    public StonecuttingRecipe getStonecuttingRecipe() {
-+        return stonecuttingRecipe;
++        return this.stonecuttingRecipe;
 +    }
 +
 +    public void setStonecuttingRecipe(@NotNull StonecuttingRecipe stonecuttingRecipe) {
@@ -50,7 +51,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Added-PlayerTradeEvent.patch

@@ -19,30 +19,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.event.player;
 +
-+import java.util.Objects;
++import com.google.common.base.Preconditions;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.MerchantRecipe;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a player trades with a standalone merchant GUI.
 + */
 +public class PlayerPurchaseEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
 +
-+    private boolean increaseTradeUses;
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private boolean rewardExp;
++    private boolean increaseTradeUses;
 +    private MerchantRecipe trade;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerPurchaseEvent(@NotNull Player player,
 +                               @NotNull MerchantRecipe trade,
 +                               boolean rewardExp,
 +                               boolean increaseTradeUses) {
-+        super(Objects.requireNonNull(player, "Player cannot be null!"));
++        super(player);
 +        setTrade(trade);
 +        this.rewardExp = rewardExp;
 +        this.increaseTradeUses = increaseTradeUses;
@@ -50,6 +54,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the associated trade with this event
++     *
 +     * @return the trade
 +     */
 +    @NotNull
@@ -59,10 +64,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets the trade. This is then used to determine the next prices
++     *
 +     * @param trade the trade to use
 +     */
 +    public void setTrade(@NotNull MerchantRecipe trade) {
-+        this.trade = Objects.requireNonNull(trade, "Trade cannot be null!");
++        Preconditions.checkArgument(trade != null, "Trade cannot be null!");
++        this.trade = trade;
 +    }
 +
 +    /**
@@ -74,6 +81,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets whether the trade will try to reward exp
++     *
 +     * @param rewardExp try to reward exp
 +     */
 +    public void setRewardExp(boolean rewardExp) {
@@ -81,37 +89,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    /**
-+     * @return whether or not the trade will count as a use of the trade
++     * @return whether the trade will count as a use of the trade
 +     */
 +    public boolean willIncreaseTradeUses() {
 +        return this.increaseTradeUses;
 +    }
 +
 +    /**
-+     * Sets whether or not the trade will count as a use
-+     * @param increaseTradeUses true to count/false to not count
++     * Sets whether the trade will count as a use
++     *
++     * @param increaseTradeUses {@code true} to count, {@code false} otherwise
 +     */
 +    public void setIncreaseTradeUses(boolean increaseTradeUses) {
 +        this.increaseTradeUses = increaseTradeUses;
 +    }
 +
-+    /**
-+     * Gets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins
-+     *
-+     * @return true if this event is cancelled
-+     */
 +    @Override
 +    public boolean isCancelled() {
 +        return this.cancelled;
 +    }
 +
-+    /**
-+     * Sets the cancellation state of this event. A cancelled event will not
-+     * be executed in the server, but will still pass to other plugins.
-+     *
-+     * @param cancel true if you wish to cancel this event
-+     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
@@ -120,12 +117,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +}
@@ -140,6 +137,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.AbstractVillager;
 +import org.bukkit.entity.Player;
 +import org.bukkit.inventory.MerchantRecipe;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -149,6 +147,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private final AbstractVillager villager;
 +
++    @ApiStatus.Internal
 +    public PlayerTradeEvent(@NotNull Player player, @NotNull AbstractVillager villager, @NotNull MerchantRecipe trade, boolean rewardExp, boolean increaseTradeUses) {
 +        super(player, trade, rewardExp, increaseTradeUses);
 +        this.villager = villager;
@@ -156,6 +155,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Gets the Villager or Wandering trader associated with this event
++     *
 +     * @return the villager or wandering trader
 +     */
 +    @NotNull

patches/api/Added-ServerResourcesReloadedEvent.patch

@@ -14,13 +14,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.server.ServerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when resources such as datapacks are reloaded (e.g. /minecraft:reload)
 + * <p>
-+ *     Intended for use to re-register custom recipes, advancements that may be lost during a reload like this.
-+ * </p>
++ * Intended for use to re-register custom recipes, advancements that may be lost during a reload like this.
 + */
 +public class ServerResourcesReloadedEvent extends ServerEvent {
 +
@@ -28,6 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    private final Cause cause;
 +
++    @ApiStatus.Internal
 +    public ServerResourcesReloadedEvent(@NotNull Cause cause) {
 +        this.cause = cause;
 +    }
@@ -39,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Cause getCause() {
-+        return cause;
++        return this.cause;
 +    }
 +
 +    @NotNull

patches/api/Added-WorldGameRuleChangeEvent.patch

@@ -15,10 +15,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.GameRule;
 +import org.bukkit.World;
 +import org.bukkit.command.CommandSender;
-+import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.world.WorldEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -34,6 +34,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private String value;
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public WorldGameRuleChangeEvent(@NotNull World world, @Nullable CommandSender commandSender, @NotNull GameRule<?> gameRule, @NotNull String value) {
 +        super(world);
 +        this.commandSender = commandSender;
@@ -48,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @Nullable
 +    public CommandSender getCommandSender() {
-+        return commandSender;
++        return this.commandSender;
 +    }
 +
 +    /**
@@ -58,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public GameRule<?> getGameRule() {
-+        return gameRule;
++        return this.gameRule;
 +    }
 +
 +    /**
@@ -68,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public String getValue() {
-+        return value;
++        return this.value;
 +    }
 +
 +    /**
@@ -82,7 +83,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override

patches/api/Adds-PlayerArmSwingEvent.patch

@@ -16,12 +16,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.player.PlayerAnimationEvent;
 +import org.bukkit.event.player.PlayerAnimationType;
 +import org.bukkit.inventory.EquipmentSlot;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +public class PlayerArmSwingEvent extends PlayerAnimationEvent {
 +
 +    private final EquipmentSlot equipmentSlot;
 +
++    @ApiStatus.Internal
 +    public PlayerArmSwingEvent(@NotNull Player player, @NotNull EquipmentSlot equipmentSlot) {
 +        super(player, equipmentSlot == EquipmentSlot.HAND ? PlayerAnimationType.ARM_SWING : PlayerAnimationType.OFF_ARM_SWING);
 +        this.equipmentSlot = equipmentSlot;

patches/api/Adventure.patch

@@ -231,12 +231,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +@ApiStatus.NonExtendable
 +public abstract class AbstractChatEvent extends PlayerEvent implements Cancellable {
++
 +    private final Set<Audience> viewers;
 +    private final Component originalMessage;
 +    private final SignedMessage signedMessage;
 +    private ChatRenderer renderer;
 +    private Component message;
-+    private boolean cancelled = false;
++
++    private boolean cancelled;
 +
 +    AbstractChatEvent(final boolean async, final @NotNull Player player, final @NotNull Set<Audience> viewers, final @NotNull ChatRenderer renderer, final @NotNull Component message, final @NotNull Component originalMessage, final @NotNull SignedMessage signedMessage) {
 +        super(player, async);
@@ -331,8 +333,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    public final void setCancelled(final boolean cancelled) {
-+        this.cancelled = cancelled;
++    public final void setCancelled(final boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/player/AsyncChatCommandDecorateEvent.java b/src/main/java/io/papermc/paper/event/player/AsyncChatCommandDecorateEvent.java
@@ -381,6 +383,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.AsyncPlayerChatPreviewEvent;
 +import org.bukkit.event.server.ServerEvent;
 +import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.Contract;
@@ -393,7 +396,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * message here, and use the chat events for modifying receivers and later the chat type. If you
 + * want to keep the message as "signed" for the clients who get it, be sure to include the entire
 + * original message somewhere in the final message.
-+ * @see AsyncChatCommandDecorateEvent for the decoration of messages sent via commands
++ * <br>
++ * See {@link AsyncChatCommandDecorateEvent} for the decoration of messages sent via commands
 + */
 +@ApiStatus.Experimental
 +public class AsyncChatDecorateEvent extends ServerEvent implements Cancellable {
@@ -403,6 +407,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final Player player;
 +    private final Component originalMessage;
 +    private Component result;
++
 +    private boolean cancelled;
 +
 +    @ApiStatus.Internal
@@ -419,7 +424,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * Certain commands request decorations without a player context
 +     * which is why this is possibly null.
 +     *
-+     * @return the player or null
++     * @return the player or {@code null}
 +     */
 +    public @Nullable Player player() {
 +        return this.player;
@@ -437,7 +442,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets the decoration result. This may already be different from
 +     * {@link #originalMessage()} if some other listener to this event
-+     * <b>OR</b> the legacy preview event ({@link org.bukkit.event.player.AsyncPlayerChatPreviewEvent}
++     * <b>OR</b> the legacy preview event ({@link AsyncPlayerChatPreviewEvent})
 +     * changed the result.
 +     *
 +     * @return the result
@@ -458,10 +463,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * If this decorating is part of a preview request/response.
 +     *
-+     * @return true if part of previewing
++     * @return {@code true} if part of previewing
 +     * @deprecated chat preview was removed in 1.19.3
 +     */
-+    @Deprecated(forRemoval = true)
++    @Deprecated(forRemoval = true, since = "1.19.3")
 +    @ApiStatus.ScheduledForRemoval(inVersion = "1.21")
 +    @Contract(value = "-> false", pure = true)
 +    public boolean isPreview() {
@@ -524,11 +529,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * appropriately.
 + */
 +public final class AsyncChatEvent extends AbstractChatEvent {
-+    private static final HandlerList HANDLERS = new HandlerList();
 +
-+    /**
-+     * @param viewers A mutable set of viewers
-+     */
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @ApiStatus.Internal
 +    public AsyncChatEvent(final boolean async, final @NotNull Player player, final @NotNull Set<Audience> viewers, final @NotNull ChatRenderer renderer, final @NotNull Component message, final @NotNull Component originalMessage, final @NotNull SignedMessage signedMessage) {
 +        super(async, player, viewers, renderer, message, originalMessage, signedMessage);
@@ -537,12 +540,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/player/ChatEvent.java b/src/main/java/io/papermc/paper/event/player/ChatEvent.java
@@ -567,16 +570,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +/**
 + * An event fired when a {@link Player} sends a chat message to the server.
 + *
-+ * @deprecated Listening to this event forces chat to wait for the main thread, delaying chat messages. It is recommended to use {@link AsyncChatEvent} instead, wherever possible.
++ * @deprecated Listening to this event forces chat to wait for the main thread, delaying chat messages.
++ * It is recommended to use {@link AsyncChatEvent} instead, wherever possible.
 + */
 +@Deprecated
 +@Warning(reason = "Listening to this event forces chat to wait for the main thread, delaying chat messages.")
 +public final class ChatEvent extends AbstractChatEvent {
-+    private static final HandlerList HANDLERS = new HandlerList();
 +
-+    /**
-+     * @param viewers A mutable set of viewers
-+     */
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @ApiStatus.Internal
 +    public ChatEvent(final @NotNull Player player, final @NotNull Set<Audience> viewers, final @NotNull ChatRenderer renderer, final @NotNull Component message, final @NotNull Component originalMessage, final @NotNull SignedMessage signedMessage) {
 +        super(false, player, viewers, renderer, message, originalMessage, signedMessage);
@@ -585,12 +587,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return HANDLERS;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/text/PaperComponents.java b/src/main/java/io/papermc/paper/text/PaperComponents.java

patches/api/AnvilDamageEvent.patch

@@ -27,10 +27,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Called when an anvil is damaged from being used
 + */
 +public class AnvilDamagedEvent extends InventoryEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
-+    private boolean cancel;
 +    private DamageState damageState;
++    private boolean cancelled;
 +
 +    @ApiStatus.Internal
 +    public AnvilDamagedEvent(@NotNull InventoryView inventory, @Nullable BlockData blockData) {
@@ -51,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public DamageState getDamageState() {
-+        return damageState;
++        return this.damageState;
 +    }
 +
 +    /**
@@ -66,31 +67,33 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets if anvil is breaking on this use
 +     *
-+     * @return True if breaking
++     * @return {@code true} if breaking
 +     */
 +    public boolean isBreaking() {
-+        return damageState == DamageState.BROKEN;
++        return this.damageState == DamageState.BROKEN;
 +    }
 +
 +    /**
 +     * Sets if anvil is breaking on this use
 +     *
-+     * @param breaking True if breaking
++     * @param breaking {@code true} if breaking
 +     */
 +    public void setBreaking(boolean breaking) {
 +        if (breaking) {
-+            damageState = DamageState.BROKEN;
-+        } else if (damageState == DamageState.BROKEN) {
-+            damageState = DamageState.DAMAGED;
++            this.damageState = DamageState.BROKEN;
++        } else if (this.damageState == DamageState.BROKEN) {
++            this.damageState = DamageState.DAMAGED;
 +        }
 +    }
 +
++    @Override
 +    public boolean isCancelled() {
-+        return cancel;
++        return this.cancelled;
 +    }
 +
++    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.cancel = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
@@ -125,7 +128,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        @NotNull
 +        public Material getMaterial() {
-+            return material;
++            return this.material;
 +        }
 +
 +        /**
@@ -153,7 +156,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return BROKEN;
 +            }
 +            for (DamageState state : values()) {
-+                if (state.material == material) {
++                if (state.getMaterial() == material) {
 +                    return state;
 +                }
 +            }

patches/api/AsyncTabCompleteEvent.patch

@@ -59,47 +59,57 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import java.util.ArrayList;
 +import java.util.List;
++import java.util.Objects;
 +import java.util.stream.Stream;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
-+ * Allows plugins to compute tab completion results asynchronously. If this event provides completions, then the standard synchronous process will not be fired to populate the results. However, the synchronous TabCompleteEvent will fire with the Async results.
-+ *
++ * Allows plugins to compute tab completion results asynchronously.
++ * <p>
++ * If this event provides completions, then the standard synchronous process
++ * will not be fired to populate the results.
++ * However, the synchronous TabCompleteEvent will fire with the Async results.
++ * <p>
 + * Only 1 process will be allowed to provide completions, the Async Event, or the standard process.
 + */
 +public class AsyncTabCompleteEvent extends Event implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final CommandSender sender;
 +    @NotNull private final String buffer;
 +    private final boolean isCommand;
 +    @Nullable
-+    private final Location loc;
++    private final Location location;
 +    private final List<Completion> completions = new ArrayList<>();
 +    private final List<String> stringCompletions = new TransformingRandomAccessList<>(
 +        this.completions,
 +        Completion::suggestion,
 +        Completion::completion
 +    );
++    private boolean handled;
 +    private boolean cancelled;
-+    private boolean handled = false;
-+    private boolean fireSyncHandler = true;
 +
++    @ApiStatus.Internal
 +    public AsyncTabCompleteEvent(@NotNull CommandSender sender, @NotNull String buffer, boolean isCommand, @Nullable Location loc) {
 +        super(true);
 +        this.sender = sender;
 +        this.buffer = buffer;
 +        this.isCommand = isCommand;
-+        this.loc = loc;
++        this.location = loc;
 +    }
 +
 +    @Deprecated
++    @ApiStatus.Internal
 +    public AsyncTabCompleteEvent(@NotNull CommandSender sender, @NotNull List<String> completions, @NotNull String buffer, boolean isCommand, @Nullable Location loc) {
 +        super(true);
 +        this.sender = sender;
 +        this.completions.addAll(fromStrings(completions));
 +        this.buffer = buffer;
 +        this.isCommand = isCommand;
-+        this.loc = loc;
++        this.location = loc;
 +    }
 +
 +    /**
@@ -109,13 +119,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public CommandSender getSender() {
-+        return sender;
++        return this.sender;
 +    }
 +
 +    /**
 +     * The list of completions which will be offered to the sender, in order.
 +     * This list is mutable and reflects what will be offered.
-+     *
++     * <p>
 +     * If this collection is not empty after the event is fired, then
 +     * the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
 +     * or current player names will not be called.
@@ -132,16 +142,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * If this collection is not empty after the event is fired, then
 +     * the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
 +     * or current player names will not be called.
-+     *
-+     * The passed collection will be cloned to a new List. You must call {{@link #getCompletions()}} to mutate from here
++     * <p>
++     * The passed collection will be cloned to a new {@code List}. You must call {{@link #getCompletions()}} to mutate from here
 +     *
 +     * @param completions the new completions
 +     */
 +    public void setCompletions(@NotNull List<String> completions) {
++        Preconditions.checkArgument(completions != null, "Completions list cannot be null");
 +        if (completions == this.stringCompletions) {
 +            return;
 +        }
-+        Preconditions.checkNotNull(completions);
 +        this.completions.clear();
 +        this.completions.addAll(fromStrings(completions));
 +    }
@@ -166,12 +176,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
 +     * or current player names will not be called.
 +     * <p>
-+     * The passed collection will be cloned to a new List. You must call {{@link #completions()}} to mutate from here
++     * The passed collection will be cloned to a new {@code List}. You must call {@link #completions()} to mutate from here
 +     *
 +     * @param newCompletions the new completions
 +     */
 +    public void completions(final @NotNull List<Completion> newCompletions) {
-+        Preconditions.checkNotNull(newCompletions, "new completions");
++        Preconditions.checkArgument(newCompletions != null, "new completions cannot be null");
 +        this.completions.clear();
 +        this.completions.addAll(newCompletions);
 +    }
@@ -183,37 +193,37 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public String getBuffer() {
-+        return buffer;
++        return this.buffer;
 +    }
 +
 +    /**
-+     * @return True if it is a command being tab completed, false if it is a chat message.
++     * @return {@code true} if it is a command being tab completed, {@code false} if it is a chat message.
 +     */
 +    public boolean isCommand() {
-+        return isCommand;
++        return this.isCommand;
 +    }
 +
 +    /**
-+     * @return The position looked at by the sender, or null if none
++     * @return The position looked at by the sender, or {@code null} if none
 +     */
 +    @Nullable
 +    public Location getLocation() {
-+        return loc;
++        return this.location;
 +    }
 +
 +    /**
-+     * If true, the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
++     * If {@code true}, the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
 +     * or current player names will not be called.
 +     *
-+     * @return Is completions considered handled. Always true if completions is not empty.
++     * @return Is completions considered handled. Always {@code true} if completions is not empty.
 +     */
 +    public boolean isHandled() {
-+        return !completions.isEmpty() || handled;
++        return !this.completions.isEmpty() || this.handled;
 +    }
 +
 +    /**
-+     * Sets whether or not to consider the completion request handled.
-+     * If true, the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
++     * Sets whether to consider the completion request handled.
++     * If {@code true}, the standard process of calling {@link Command#tabComplete(CommandSender, String, String[])}
 +     * or current player names will not be called.
 +     *
 +     * @param handled if this completion should be marked as being handled
@@ -222,37 +232,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.handled = handled;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
++     * {@inheritDoc}
++     * <br>
 +     * Will provide no completions, and will not fire the synchronous process
-+     * @param cancelled true if you wish to cancel this event
 +     */
 +    @Override
-+    public void setCancelled(boolean cancelled) {
-+        this.cancelled = cancelled;
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
-+    private static @NotNull List<Completion> fromStrings(final @NotNull List<String> strings) {
-+        final List<Completion> list = new ArrayList<>();
-+        for (final String it : strings) {
-+            list.add(new CompletionImpl(it, null));
++    private static @NotNull List<Completion> fromStrings(final @NotNull List<String> suggestions) {
++        final List<Completion> list = new ArrayList<>(suggestions.size());
++        for (final String suggestion : suggestions) {
++            list.add(new CompletionImpl(suggestion, null));
 +        }
 +        return list;
 +    }
@@ -261,6 +269,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * A rich tab completion, consisting of a string suggestion, and a nullable {@link Component} tooltip.
 +     */
 +    public interface Completion extends Examinable {
++
 +        /**
 +         * Get the suggestion string for this {@link Completion}.
 +         *
@@ -292,11 +301,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        /**
 +         * Create a new {@link Completion} from a suggestion string and a tooltip {@link Component}.
-+         *
-+         * <p>If the provided component is null, the suggestion will not have a tooltip.</p>
++         * <p>
++         * If the provided component is {@code null}, the suggestion will not have a tooltip.
 +         *
 +         * @param suggestion suggestion string
-+         * @param tooltip    tooltip component, or null
++         * @param tooltip    tooltip component, or {@code null}
 +         * @return new completion instance
 +         */
 +        static @NotNull Completion completion(final @NotNull String suggestion, final @Nullable Component tooltip) {
@@ -304,7 +313,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +    }
 +
++    @ApiStatus.Internal
 +    static final class CompletionImpl implements Completion {
++
 +        private final String suggestion;
 +        private final Component tooltip;
 +
@@ -333,12 +344,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            }
 +            final CompletionImpl that = (CompletionImpl) o;
 +            return this.suggestion.equals(that.suggestion)
-+                && java.util.Objects.equals(this.tooltip, that.tooltip);
++                && Objects.equals(this.tooltip, that.tooltip);
 +        }
 +
 +        @Override
 +        public int hashCode() {
-+            return java.util.Objects.hash(this.suggestion, this.tooltip);
++            return Objects.hash(this.suggestion, this.tooltip);
 +        }
 +
 +        @Override

patches/api/BlockDestroyEvent.patch

@@ -30,23 +30,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Fired anytime the server intends to 'destroy' a block through some triggering reason.
 + * This does not fire anytime a block is set to air, but only with more direct triggers such
 + * as physics updates, pistons, Entities changing blocks, commands set to "Destroy".
-+ *
++ * <p>
 + * This event is associated with the game playing a sound effect at the block in question, when
 + * something can be described as "intend to destroy what is there",
-+ *
++ * <p>
 + * Events such as leaves decaying, pistons retracting (where the block is moving), does NOT fire this event.
-+ *
 + */
 +public class BlockDestroyEvent extends BlockExpEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    @NotNull private final BlockData newState;
 +    private boolean willDrop;
 +    private boolean playEffect = true;
 +    private BlockData effectBlock;
 +
-+    private boolean cancelled = false;
++    private boolean cancelled;
 +
 +    @ApiStatus.Internal
 +    public BlockDestroyEvent(@NotNull Block block, @NotNull BlockData newState, @NotNull BlockData effectBlock, int xp, boolean willDrop) {
@@ -58,6 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Get the effect that will be played when the block is broken.
++     *
 +     * @return block break effect
 +     */
 +    @NotNull
@@ -67,7 +67,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    /**
 +     * Sets the effect that will be played when the block is broken.
-+     * Note: {@link BlockDestroyEvent#playEffect()} must be true in order for this effect to be
++     * Note: {@link BlockDestroyEvent#playEffect()} must be {@code true} in order for this effect to be
 +     * played.
 +     *
 +     * @param effectBlock block effect
@@ -81,7 +81,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public BlockData getNewState() {
-+        return newState;
++        return this.newState;
 +    }
 +
 +    /**
@@ -117,25 +117,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
 +     * If the event is cancelled, the block will remain in its previous state.
-+     * @param cancel true if you wish to cancel this event
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/EnderDragon-Events.patch

@@ -27,11 +27,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Fired when a DragonFireball collides with a block/entity and spawns an AreaEffectCloud
 + */
 +public class EnderDragonFireballHitEvent extends EntityEvent implements Cancellable {
++
 +    private static final HandlerList HANDLER_LIST = new HandlerList();
 +
 +    @NotNull private final Collection<LivingEntity> targets;
 +    @NotNull private final AreaEffectCloud areaEffectCloud;
-+    private boolean cancelled = false;
++    private boolean cancelled;
 +
 +    @ApiStatus.Internal
 +    public EnderDragonFireballHitEvent(@NotNull DragonFireball fireball, @NotNull Collection<LivingEntity> targets, @NotNull AreaEffectCloud areaEffectCloud) {
@@ -56,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Collection<LivingEntity> getTargets() {
-+        return targets;
++        return this.targets;
 +    }
 +
 +    /**
@@ -64,20 +65,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public AreaEffectCloud getAreaEffectCloud() {
-+        return areaEffectCloud;
++        return this.areaEffectCloud;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
 +        return HANDLER_LIST;
 +    }
@@ -100,14 +102,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when an EnderDragon spawns an AreaEffectCloud by shooting flames
 + */
 +public class EnderDragonFlameEvent extends EntityEvent implements Cancellable {
-+    @NotNull private final AreaEffectCloud areaEffectCloud;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final AreaEffectCloud areaEffectCloud;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EnderDragonFlameEvent(@NotNull EnderDragon enderDragon, @NotNull AreaEffectCloud areaEffectCloud) {
 +        super(enderDragon);
 +        this.areaEffectCloud = areaEffectCloud;
@@ -127,31 +135,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public AreaEffectCloud getAreaEffectCloud() {
-+        return areaEffectCloud;
++        return this.areaEffectCloud;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java
@@ -167,14 +171,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when an EnderDragon shoots a fireball
 + */
 +public class EnderDragonShootFireballEvent extends EntityEvent implements Cancellable {
-+    @NotNull private final DragonFireball fireball;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final DragonFireball fireball;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EnderDragonShootFireballEvent(@NotNull EnderDragon entity, @NotNull DragonFireball fireball) {
 +        super(entity);
 +        this.fireball = fireball;
@@ -194,30 +204,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public DragonFireball getFireball() {
-+        return fireball;
++        return this.fireball;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/EndermanAttackPlayerEvent.patch

@@ -39,23 +39,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package com.destroystokyo.paper.event.entity;
 +
 +import org.bukkit.entity.Enderman;
-+import org.bukkit.entity.Entity;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
-+import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when an Enderman determines if it should attack a player or not.
++ * <p>
 + * Starts off cancelled if the player is wearing a pumpkin head or is not looking
 + * at the Enderman, according to Vanilla rules.
-+ *
 + */
 +public class EndermanAttackPlayerEvent extends EntityEvent implements Cancellable {
-+    @NotNull private final Player player;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final Player player;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EndermanAttackPlayerEvent(@NotNull Enderman entity, @NotNull Player player) {
 +        super(entity);
 +        this.player = player;
@@ -79,38 +83,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Player getPlayer() {
-+        return player;
++        return this.player;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    /**
-+     *
 +     * @return If cancelled, the enderman will not attack
 +     */
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
++     * {@inheritDoc}
++     * <br>
 +     * Cancels if the Enderman will attack this player
-+     * @param cancel true if you wish to cancel this event
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/EndermanEscapeEvent.patch

@@ -16,16 +16,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +package com.destroystokyo.paper.event.entity;
 +
 +import org.bukkit.entity.Enderman;
-+import org.bukkit.entity.Entity;
 +import org.bukkit.event.Cancellable;
-+import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +public class EndermanEscapeEvent extends EntityEvent implements Cancellable {
-+    @NotNull private final Reason reason;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final Reason reason;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EndermanEscapeEvent(@NotNull Enderman entity, @NotNull Reason reason) {
 +        super(entity);
 +        this.reason = reason;
@@ -42,39 +46,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Reason getReason() {
-+        return reason;
++        return this.reason;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
 +     * Cancels the escape.
-+     *
++     * <p>
 +     * If this escape normally would of resulted in damage avoidance such as indirect,
 +     * the enderman will now take damage.
-+     *
-+     * @param cancel true if you wish to cancel this event
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +
 +    public enum Reason {
@@ -95,7 +94,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        STARE,
 +        /**
-+         * Specific case for CRITICAL_HIT where the enderman is taking rain damage
++         * Specific case for {@link #CRITICAL_HIT} where the enderman is taking rain damage
 +         */
 +        DROWN
 +    }

patches/api/Entity-AddTo-RemoveFrom-World-Events.patch

@@ -15,17 +15,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.World;
 +import org.bukkit.entity.Entity;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.CreatureSpawnEvent;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired any time an entity is being added to the world for any reason (including a chunk loading).
-+ *
-+ * Not to be confused with {@link org.bukkit.event.entity.CreatureSpawnEvent}
++ * <p>
++ * Not to be confused with {@link CreatureSpawnEvent}
 + */
 +public class EntityAddToWorldEvent extends EntityEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final World world;
 +
++    @ApiStatus.Internal
 +    public EntityAddToWorldEvent(@NotNull Entity entity, @NotNull World world) {
 +        super(entity);
 +        this.world = world;
@@ -36,19 +42,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public World getWorld() {
-+        return world;
++        return this.world;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityRemoveFromWorldEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityRemoveFromWorldEvent.java
@@ -63,6 +67,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Entity;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -70,8 +75,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Note: The entity is updated prior to this event being called, as such, the entity's world may not be equal to {@link #getWorld()}.
 + */
 +public class EntityRemoveFromWorldEvent extends EntityEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final World world;
 +
++    @ApiStatus.Internal
 +    public EntityRemoveFromWorldEvent(@NotNull Entity entity, @NotNull World world) {
 +        super(entity);
 +        this.world = world;
@@ -82,18 +91,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public World getWorld() {
-+        return world;
++        return this.world;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Entity-Jump-API.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -24,9 +25,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Cancelling the event will stop the entity from jumping
 + */
 +public class EntityJumpEvent extends EntityEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean canceled;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EntityJumpEvent(@NotNull LivingEntity entity) {
 +        super(entity);
 +    }
@@ -34,26 +38,26 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @NotNull
 +    @Override
 +    public LivingEntity getEntity() {
-+        return (LivingEntity) entity;
++        return (LivingEntity) super.getEntity();
 +    }
 +
 +    public boolean isCancelled() {
-+        return canceled;
++        return this.cancelled;
 +    }
 +
 +    public void setCancelled(boolean cancel) {
-+        canceled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java

patches/api/EntityMoveEvent.patch

@@ -19,6 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
 +import org.bukkit.event.player.PlayerMoveEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -27,11 +28,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Does not fire for players; use {@link PlayerMoveEvent} for player movement.
 + */
 +public class EntityMoveEvent extends EntityEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean canceled;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private Location from;
 +    private Location to;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public EntityMoveEvent(@NotNull LivingEntity entity, @NotNull Location from, @NotNull Location to) {
 +        super(entity);
 +        this.from = from;
@@ -41,15 +46,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    @NotNull
 +    public LivingEntity getEntity() {
-+        return (LivingEntity) entity;
-+    }
-+
-+    public boolean isCancelled() {
-+        return canceled;
-+    }
-+
-+    public void setCancelled(boolean cancel) {
-+        canceled = cancel;
++        return (LivingEntity) super.getEntity();
 +    }
 +
 +    /**
@@ -59,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getFrom() {
-+        return from;
++        return this.from;
 +    }
 +
 +    /**
@@ -79,7 +76,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Location getTo() {
-+        return to;
++        return this.to;
 +    }
 +
 +    /**
@@ -98,7 +95,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return whether the entity has changed position or not
 +     */
 +    public boolean hasChangedPosition() {
-+        return hasExplicitlyChangedPosition() || !from.getWorld().equals(to.getWorld());
++        return hasExplicitlyChangedPosition() || !this.from.getWorld().equals(this.to.getWorld());
 +    }
 +
 +    /**
@@ -107,7 +104,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return whether the entity has changed position or not
 +     */
 +    public boolean hasExplicitlyChangedPosition() {
-+        return from.getX() != to.getX() || from.getY() != to.getY() || from.getZ() != to.getZ();
++        return this.from.getX() != this.to.getX() || this.from.getY() != this.to.getY() || this.from.getZ() != this.to.getZ();
 +    }
 +
 +    /**
@@ -125,7 +122,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return whether the entity has moved to a new block or not
 +     */
 +    public boolean hasExplicitlyChangedBlock() {
-+        return from.getBlockX() != to.getBlockX() || from.getBlockY() != to.getBlockY() || from.getBlockZ() != to.getBlockZ();
++        return this.from.getBlockX() != this.to.getBlockX() || this.from.getBlockY() != this.to.getBlockY() || this.from.getBlockZ() != this.to.getBlockZ();
 +    }
 +
 +    /**
@@ -134,7 +131,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return whether the entity has changed orientation or not
 +     */
 +    public boolean hasChangedOrientation() {
-+        return from.getPitch() != to.getPitch() || from.getYaw() != to.getYaw();
++        return this.from.getPitch() != this.to.getPitch() || this.from.getYaw() != this.to.getYaw();
 +    }
 +
 +    private void validateLocation(@NotNull Location loc) {
@@ -143,13 +140,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/EntityPathfindEvent.patch

@@ -18,78 +18,83 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
 +/**
 + * Fired when an Entity decides to start moving towards a location.
-+ *
++ * <p>
 + * This event does not fire for the entities actual movement. Only when it
 + * is choosing to start moving to a location.
 + */
 +public class EntityPathfindEvent extends EntityEvent implements Cancellable {
-+    @Nullable private final Entity targetEntity;
-+    @NotNull private final Location loc;
 +
-+    public EntityPathfindEvent(@NotNull Entity entity, @NotNull Location loc, @Nullable Entity targetEntity) {
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @Nullable private final Entity targetEntity;
++    @NotNull private final Location location;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public EntityPathfindEvent(@NotNull Entity entity, @NotNull Location location, @Nullable Entity targetEntity) {
 +        super(entity);
 +        this.targetEntity = targetEntity;
-+        this.loc = loc;
++        this.location = location;
 +    }
 +
 +    /**
 +     * The Entity that is pathfinding.
++     *
 +     * @return The Entity that is pathfinding.
 +     */
 +    @NotNull
 +    public Entity getEntity() {
-+        return entity;
++        return this.entity;
 +    }
 +
 +    /**
 +     * If the Entity is trying to pathfind to an entity, this is the entity in relation.
++     * <br>
++     * Otherwise this will return {@code null}.
 +     *
-+     * Otherwise this will return null.
-+     *
-+     * @return The entity target or null
++     * @return The entity target or {@code null}
 +     */
 +    @Nullable
 +    public Entity getTargetEntity() {
-+        return targetEntity;
++        return this.targetEntity;
 +    }
 +
 +    /**
 +     * The Location of where the entity is about to move to.
-+     *
++     * <br>
 +     * Note that if the target happened to of been an entity
++     *
 +     * @return Location of where the entity is trying to pathfind to.
 +     */
 +    @NotNull
 +    public Location getLoc() {
-+        return loc;
++        return this.location;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/EntityTransformedEvent.patch

@@ -12,28 +12,32 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.entity;
 +
-+
 +import org.bukkit.entity.Entity;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
-+import org.bukkit.event.entity.EntityTransformEvent;
 +import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when an entity transforms into another entity
 + * <p>
 + * If the event is cancelled, the entity will not transform
-+ * @deprecated Bukkit has added {@link EntityTransformEvent}, you should start using that
++ *
++ * @deprecated Bukkit has added {@link org.bukkit.event.entity.EntityTransformEvent}, you should start using that
 + */
 +@Deprecated(forRemoval = true) @ApiStatus.ScheduledForRemoval(inVersion = "1.21")
 +public class EntityTransformedEvent extends EntityEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Entity transformed;
 +    private final TransformedReason reason;
 +
-+    public EntityTransformedEvent(Entity entity, Entity transformed, TransformedReason reason) {
++    private boolean cancelled;
++
++    @ApiStatus.Internal
++    public EntityTransformedEvent(@NotNull Entity entity, @NotNull Entity transformed, @NotNull TransformedReason reason) {
 +        super(entity);
 +        this.transformed = transformed;
 +        this.reason = reason;
@@ -43,40 +47,39 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * The entity after it has transformed
 +     *
 +     * @return Transformed entity
-+     * @deprecated see {@link EntityTransformEvent#getTransformedEntity()}
 +     */
-+    @Deprecated
++    @NotNull
 +    public Entity getTransformed() {
-+        return transformed;
++        return this.transformed;
 +    }
 +
 +    /**
 +     * @return The reason for the transformation
-+     * @deprecated see {@link EntityTransformEvent#getTransformReason()}
 +     */
-+    @Deprecated
++    @NotNull
 +    public TransformedReason getReason() {
-+        return reason;
-+    }
-+
-+
-+    @Override
-+    public HandlerList getHandlers(){
-+        return handlers;
-+    }
-+
-+    public static HandlerList getHandlerList(){
-+        return handlers;
++        return this.reason;
 +    }
 +
 +    @Override
 +    public boolean isCancelled(){
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel){
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @Override
++    @NotNull
++    public HandlerList getHandlers(){
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList(){
++        return HANDLER_LIST;
 +    }
 +
 +    public enum TransformedReason {
@@ -97,9 +100,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +         */
 +        SHEARED,
 +        /**
-+         * When a pig turns to a zombiepigman
++         * When a pig turns to a zombified piglin
 +         */
 +        LIGHTNING
-+
 +    }
 +}

patches/api/ExperienceOrbMergeEvent.patch

@@ -42,15 +42,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired anytime the server is about to merge 2 experience orbs into one
 + */
 +public class ExperienceOrbMergeEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final ExperienceOrb mergeTarget;
 +    @NotNull private final ExperienceOrb mergeSource;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public ExperienceOrbMergeEvent(@NotNull ExperienceOrb mergeTarget, @NotNull ExperienceOrb mergeSource) {
 +        super(mergeTarget);
 +        this.mergeTarget = mergeTarget;
@@ -62,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ExperienceOrb getMergeTarget() {
-+        return mergeTarget;
++        return this.mergeTarget;
 +    }
 +
 +    /**
@@ -70,33 +77,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ExperienceOrb getMergeSource() {
-+        return mergeSource;
++        return this.mergeSource;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    /**
++     * @param cancel {@code true} if you wish to cancel this event, and prevent the orbs from merging
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
 +
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    /**
-+     * @param cancel true if you wish to cancel this event, and prevent the orbs from merging
-+     */
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Fill-Profile-Property-Events.patch

@@ -47,14 +47,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +
 +import java.util.Set;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired once a profiles additional properties (such as textures) has been filled
 + */
 +public class FillProfileEvent extends Event {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final PlayerProfile profile;
 +
++    @ApiStatus.Internal
 +    public FillProfileEvent(@NotNull PlayerProfile profile) {
 +        super(!org.bukkit.Bukkit.isPrimaryThread());
 +        this.profile = profile;
@@ -65,7 +70,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PlayerProfile getPlayerProfile() {
-+        return profile;
++        return this.profile;
 +    }
 +
 +    /**
@@ -76,19 +81,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Set<ProfileProperty> getProperties() {
-+        return profile.getProperties();
++        return this.profile.getProperties();
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/profile/PreFillProfileEvent.java b/src/main/java/com/destroystokyo/paper/event/profile/PreFillProfileEvent.java
@@ -128,16 +132,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +
 +import java.util.Collection;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when the server is requesting to fill in properties of an incomplete profile, such as textures.
-+ *
-+ * Allows plugins to pre populate cached properties and avoid a call to the Mojang API
++ * <p>
++ * Allows plugins to pre-populate cached properties and avoid a call to the Mojang API
 + */
 +public class PreFillProfileEvent extends Event {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final PlayerProfile profile;
 +
++    @ApiStatus.Internal
 +    public PreFillProfileEvent(@NotNull PlayerProfile profile) {
 +        super(!org.bukkit.Bukkit.isPrimaryThread());
 +        this.profile = profile;
@@ -148,7 +157,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public PlayerProfile getPlayerProfile() {
-+        return profile;
++        return this.profile;
 +    }
 +
 +    /**
@@ -159,18 +168,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @param properties The properties to set/append
 +     */
 +    public void setProperties(@NotNull Collection<ProfileProperty> properties) {
-+        profile.setProperties(properties);
++        this.profile.setProperties(properties);
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/IllegalPacketEvent.patch

@@ -15,10 +15,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package com.destroystokyo.paper.event.player;
 +
-+import org.bukkit.Bukkit;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -27,20 +27,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +@Deprecated
 +public class IllegalPacketEvent extends PlayerEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @Nullable private final String type;
-+    @Nullable private final String ex;
++    @Nullable private final String exceptionMessage;
 +    @Nullable private String kickMessage;
 +    private boolean shouldKick = true;
 +
++    @ApiStatus.Internal
 +    public IllegalPacketEvent(@NotNull Player player, @Nullable String type, @Nullable String kickMessage, @NotNull Exception e) {
 +        super(player);
 +        this.type = type;
 +        this.kickMessage = kickMessage;
-+        this.ex = e.getMessage();
++        this.exceptionMessage = e.getMessage();
 +    }
 +
 +    public boolean isShouldKick() {
-+        return shouldKick;
++        return this.shouldKick;
 +    }
 +
 +    public void setShouldKick(boolean shouldKick) {
@@ -49,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Nullable
 +    public String getKickMessage() {
-+        return kickMessage;
++        return this.kickMessage;
 +    }
 +
 +    public void setKickMessage(@Nullable String kickMessage) {
@@ -58,32 +62,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Nullable
 +    public String getType() {
-+        return type;
++        return this.type;
 +    }
 +
 +    @Nullable
 +    public String getExceptionMessage() {
-+        return ex;
++        return this.exceptionMessage;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
 +    @NotNull
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    public static void process(@NotNull Player player, @Nullable String type, @Nullable String kickMessage, @NotNull Exception exception) {
-+        IllegalPacketEvent event = new IllegalPacketEvent(player, type, kickMessage, exception);
-+        event.callEvent();
-+        if (event.shouldKick) {
-+            player.kickPlayer(kickMessage);
-+        }
-+        Bukkit.getLogger().severe(player.getName() + "/" + type + ": " + exception.getMessage());
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Introduce-beacon-activation-deactivation-events.patch

@@ -16,6 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.block.Block;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -23,8 +24,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Activation occurs when the beacon beam becomes visible.
 + */
 +public class BeaconActivatedEvent extends BlockEvent {
-+    private static final HandlerList handlers = new HandlerList();
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @ApiStatus.Internal
 +    public BeaconActivatedEvent(@NotNull Block block) {
 +        super(block);
 +    }
@@ -36,18 +39,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Beacon getBeacon() {
-+        return (Beacon) block.getState();
++        return (Beacon) this.block.getState();
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/block/BeaconDeactivatedEvent.java b/src/main/java/io/papermc/paper/event/block/BeaconDeactivatedEvent.java
@@ -63,6 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.block.Block;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.Nullable;
 +
@@ -70,32 +74,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + * Called when a beacon is deactivated, either because its base block(s) or itself were destroyed.
 + */
 +public class BeaconDeactivatedEvent extends BlockEvent {
-+    private static final HandlerList handlers = new HandlerList();
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @ApiStatus.Internal
 +    public BeaconDeactivatedEvent(@NotNull Block block) {
 +        super(block);
 +    }
 +
 +    /**
 +     * Returns the beacon that was deactivated.
-+     * This will return null if the beacon does not exist.
++     * This will return {@code null} if the beacon does not exist.
 +     * (which can occur after the deactivation of a now broken beacon)
 +     *
-+     * @return The beacon that got deactivated, or null if it does not exist.
++     * @return The beacon that got deactivated, or {@code null} if it does not exist.
 +     */
 +    @Nullable
 +    public Beacon getBeacon() {
-+        return block.getType() == Material.BEACON ? (Beacon) block.getState() : null;
++        return this.block.getType() == Material.BEACON ? (Beacon) this.block.getState() : null;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/LootTable-API.patch

@@ -199,11 +199,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +public class LootableInventoryReplenishEvent extends PlayerEvent implements Cancellable {
-+    @NotNull private final LootableInventory inventory;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final LootableInventory inventory;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public LootableInventoryReplenishEvent(@NotNull Player player, @NotNull LootableInventory inventory) {
 +        super(player);
 +        this.inventory = inventory;
@@ -211,31 +217,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @NotNull
 +    public LootableInventory getInventory() {
-+        return inventory;
++        return this.inventory;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/org/bukkit/block/Barrel.java b/src/main/java/org/bukkit/block/Barrel.java

patches/api/Player-Chunk-Load-Unload-Events.patch

@@ -16,40 +16,43 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.world.ChunkEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
-+ * Is called when a {@link org.bukkit.entity.Player} receives a {@link org.bukkit.Chunk}
++ * Is called when a {@link Player} receives a {@link Chunk}
 + * <p>
 + * Can for example be used for spawning a fake entity when the player receives a chunk.
-+ *
++ * <p>
 + * Should only be used for packet/clientside related stuff.
 + * Not intended for modifying server side state.
 + */
 +public class PlayerChunkLoadEvent extends ChunkEvent {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Player player;
 +
++    @ApiStatus.Internal
 +    public PlayerChunkLoadEvent(@NotNull Chunk chunk, @NotNull Player player) {
 +        super(chunk);
 +        this.player = player;
 +    }
 +
 +    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
++    public Player getPlayer() {
++        return this.player;
 +    }
 +
 +    @NotNull
-+    public Player getPlayer() {
-+        return player;
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/packet/PlayerChunkUnloadEvent.java b/src/main/java/io/papermc/paper/event/packet/PlayerChunkUnloadEvent.java
@@ -64,37 +67,40 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.world.ChunkEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Is called when a {@link Player} receives a chunk unload packet.
-+ *
++ * <p>
 + * Should only be used for packet/clientside related stuff.
 + * Not intended for modifying server side.
 + */
 +public class PlayerChunkUnloadEvent extends ChunkEvent {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Player player;
 +
++    @ApiStatus.Internal
 +    public PlayerChunkUnloadEvent(@NotNull Chunk chunk, @NotNull Player player) {
 +        super(chunk);
 +        this.player = player;
 +    }
 +
 +    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
++    public Player getPlayer() {
++        return this.player;
 +    }
 +
 +    @NotNull
-+    public Player getPlayer() {
-+        return player;
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/Player-Entity-Tracking-Events.patch

@@ -17,6 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -29,26 +30,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerTrackEntityEvent extends PlayerEvent implements Cancellable {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Entity entity;
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerTrackEntityEvent(@NotNull Player player, @NotNull Entity entity) {
 +        super(player);
 +        this.entity = entity;
 +    }
 +
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
 +    /**
 +     * Gets the entity that will be tracked
 +     *
@@ -56,18 +48,29 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Entity getEntity() {
-+        return entity;
++        return this.entity;
 +    }
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
 +        this.cancelled = cancel;
 +    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
 +}
 diff --git a/src/main/java/io/papermc/paper/event/player/PlayerUntrackEntityEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerUntrackEntityEvent.java
 new file mode 100644
@@ -81,6 +84,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
@@ -91,31 +95,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 + */
 +public class PlayerUntrackEntityEvent extends PlayerEvent {
 +
-+    private static final HandlerList handlers = new HandlerList();
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    private final Entity entity;
 +
++    @ApiStatus.Internal
 +    public PlayerUntrackEntityEvent(@NotNull Player player, @NotNull Entity entity) {
 +        super(player);
 +        this.entity = entity;
 +    }
 +
++    /**
++     * Gets the entity that will be untracked
++     *
++     * @return the entity untracked
++     */
++    @NotNull
++    public Entity getEntity() {
++        return this.entity;
++    }
++
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    /**
-+     * Gets the entity that will be untracked
-+     * @return the entity untracked
-+     */
-+    @NotNull
-+    public Entity getEntity() {
-+        return entity;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerAttemptPickupItemEvent.patch

@@ -16,23 +16,29 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Thrown when a player attempts to pick an item up from the ground
 + */
 +public class PlayerAttemptPickupItemEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final Item item;
 +    private final int remaining;
 +    private boolean flyAtPlayer = true;
-+    private boolean isCancelled = false;
++
++    private boolean cancelled;
 +
 +    @Deprecated // Remove in 1.13 // Remove in 1.14?
++    @ApiStatus.Internal
 +    public PlayerAttemptPickupItemEvent(@NotNull final Player player, @NotNull final Item item) {
 +        this(player, item, 0);
 +    }
 +
++    @ApiStatus.Internal
 +    public PlayerAttemptPickupItemEvent(@NotNull final Player player, @NotNull final Item item, final int remaining) {
 +        super(player);
 +        this.item = item;
@@ -46,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Item getItem() {
-+        return item;
++        return this.item;
 +    }
 +
 +    /**
@@ -55,14 +61,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return amount that will remain on the ground
 +     */
 +    public int getRemaining() {
-+        return remaining;
++        return this.remaining;
 +    }
 +
 +    /**
 +     * Set if the item will fly at the player
 +     * <p>Cancelling the event will set this value to false.</p>
 +     *
-+     * @param flyAtPlayer True for item to fly at player
++     * @param flyAtPlayer {@code true} for item to fly at player
 +     */
 +    public void setFlyAtPlayer(boolean flyAtPlayer) {
 +        this.flyAtPlayer = flyAtPlayer;
@@ -71,7 +77,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets if the item will fly at the player
 +     *
-+     * @return True if the item will fly at the player
++     * @return {@code true} if the item will fly at the player
 +     */
 +    public boolean getFlyAtPlayer() {
 +        return this.flyAtPlayer;
@@ -80,23 +86,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public boolean isCancelled() {
-+        return this.isCancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        this.isCancelled = cancel;
++        this.cancelled = cancel;
 +        this.flyAtPlayer = !cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerElytraBoostEvent.patch

@@ -18,18 +18,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when a player boosts elytra flight with a firework
 + */
 +public class PlayerElytraBoostEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
-+    private boolean cancelled = false;
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final ItemStack itemStack;
-+    @NotNull private Firework firework;
++    @NotNull private final Firework firework;
 +    private boolean consume = true;
 +
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerElytraBoostEvent(@NotNull Player player, @NotNull ItemStack itemStack, @NotNull Firework firework) {
 +        super(player);
 +        this.itemStack = itemStack;
@@ -43,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItemStack() {
-+        return itemStack;
++        return this.itemStack;
 +    }
 +
 +    /**
@@ -53,45 +58,45 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Firework getFirework() {
-+        return firework;
++        return this.firework;
 +    }
 +
 +    /**
 +     * Get whether to consume the firework or not
 +     *
-+     * @return True to consume
++     * @return {@code true} to consume
 +     */
 +    public boolean shouldConsume() {
-+        return consume;
++        return this.consume;
 +    }
 +
 +    /**
 +     * Set whether to consume the firework or not
 +     *
-+     * @param consume True to consume
++     * @param consume {@code true} to consume
 +     */
 +    public void setShouldConsume(boolean consume) {
 +        this.consume = consume;
 +    }
 +
-+    @NotNull
-+    @Override
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerLaunchProjectileEvent.patch

@@ -16,24 +16,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.Projectile;
 +import org.bukkit.event.Cancellable;
 +import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityShootBowEvent;
 +import org.bukkit.event.player.PlayerEvent;
 +import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Called when a player shoots a projectile.
 + * <p>
 + * Notably this event is not called for arrows as the player does not launch them, rather shoots them with the help
-+ * of a bow or crossbow. A plugin may listen to {@link org.bukkit.event.entity.EntityShootBowEvent} for these actions
-+ * instead.
++ * of a bow or crossbow. A plugin may listen to {@link EntityShootBowEvent}
++ * for these actions instead.
 + */
 +public class PlayerLaunchProjectileEvent extends PlayerEvent implements Cancellable {
-+    private static final HandlerList handlers = new HandlerList();
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
 +    @NotNull private final Projectile projectile;
 +    @NotNull private final ItemStack itemStack;
 +    private boolean consumeItem = true;
++
 +    private boolean cancelled;
 +
++    @ApiStatus.Internal
 +    public PlayerLaunchProjectileEvent(@NotNull Player shooter, @NotNull ItemStack itemStack, @NotNull Projectile projectile) {
 +        super(shooter);
 +        this.itemStack = itemStack;
@@ -47,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public Projectile getProjectile() {
-+        return projectile;
++        return this.projectile;
 +    }
 +
 +    /**
@@ -57,43 +63,45 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ItemStack getItemStack() {
-+        return itemStack;
++        return this.itemStack;
 +    }
 +
 +    /**
 +     * Get whether to consume the ItemStack or not
 +     *
-+     * @return True to consume
++     * @return {@code true} to consume
 +     */
 +    public boolean shouldConsume() {
-+        return consumeItem;
++        return this.consumeItem;
 +    }
 +
 +    /**
 +     * Set whether to consume the ItemStack or not
 +     *
-+     * @param consumeItem True to consume
++     * @param consumeItem {@code true} to consume
 +     */
 +    public void setShouldConsume(boolean consumeItem) {
 +        this.consumeItem = consumeItem;
 +    }
 +
++    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
++    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
 +    }
 +
 +    @NotNull
 +    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerNaturallySpawnCreaturesEvent.patch

@@ -18,17 +18,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
-+import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when the server is calculating what chunks to try to spawn monsters in every Monster Spawn Tick event
 + */
 +public class PlayerNaturallySpawnCreaturesEvent extends PlayerEvent implements Cancellable {
-+    private byte radius;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private byte radius;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerNaturallySpawnCreaturesEvent(@NotNull Player player, byte radius) {
 +        super(player);
 +        this.radius = radius;
@@ -38,7 +43,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * @return The radius of chunks around this player to be included in natural spawn selection
 +     */
 +    public byte getSpawnRadius() {
-+        return radius;
++        return this.radius;
 +    }
 +
 +    /**
@@ -48,33 +53,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.radius = radius;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
-+
-+    @NotNull
-+    public HandlerList getHandlers() {
-+        return handlers;
-+    }
-+
-+    @NotNull
-+    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
 +    /**
 +     * @return If this players chunks will be excluded from natural spawns
 +     */
 +    @Override
 +    public boolean isCancelled() {
-+        return cancelled;
++        return this.cancelled;
 +    }
 +
 +    /**
-+     * @param cancel true if you wish to cancel this event, and not include this players chunks for natural spawning
++     * @param cancel {@code true} if you wish to cancel this event, and not include this players chunks for natural spawning
 +     */
 +    @Override
 +    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerPickupExperienceEvent.patch

@@ -39,17 +39,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.entity.ExperienceOrb;
 +import org.bukkit.entity.Player;
 +import org.bukkit.event.Cancellable;
-+import org.bukkit.event.Event;
 +import org.bukkit.event.HandlerList;
 +import org.bukkit.event.player.PlayerEvent;
++import org.jetbrains.annotations.ApiStatus;
 +import org.jetbrains.annotations.NotNull;
 +
 +/**
 + * Fired when a player is attempting to pick up an experience orb
 + */
 +public class PlayerPickupExperienceEvent extends PlayerEvent implements Cancellable {
-+    @NotNull private final ExperienceOrb experienceOrb;
 +
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull private final ExperienceOrb experienceOrb;
++    private boolean cancelled;
++
++    @ApiStatus.Internal
 +    public PlayerPickupExperienceEvent(@NotNull Player player, @NotNull ExperienceOrb experienceOrb) {
 +        super(player);
 +        this.experienceOrb = experienceOrb;
@@ -60,34 +65,32 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    @NotNull
 +    public ExperienceOrb getExperienceOrb() {
-+        return experienceOrb;
++        return this.experienceOrb;
 +    }
 +
-+    private static final HandlerList handlers = new HandlerList();
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    /**
++     * {@inheritDoc}
++     * <br>
++     * If {@code true}, cancels picking up the experience orb, leaving it in the world
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
 +
 +    @NotNull
++    @Override
 +    public HandlerList getHandlers() {
-+        return handlers;
++        return HANDLER_LIST;
 +    }
 +
 +    @NotNull
 +    public static HandlerList getHandlerList() {
-+        return handlers;
-+    }
-+
-+    private boolean cancelled = false;
-+
-+    @Override
-+    public boolean isCancelled() {
-+        return cancelled;
-+    }
-+
-+    /**
-+     * If true, Cancels picking up the experience orb, leaving it in the world
-+     * @param cancel true if you wish to cancel this event
-+     */
-+    @Override
-+    public void setCancelled(boolean cancel) {
-+        cancelled = cancel;
++        return HANDLER_LIST;
 +    }
 +}

patches/api/PlayerPickupItemEvent-setFlyAtPlayer.patch

@@ -23,9 +23,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper start
 +    /**
 +     * Set if the item will fly at the player
-+     * <p>Cancelling the event will set this value to false.</p>
++     * <p>
++     * Cancelling the event will set this value to false.
 +     *
-+     * @param flyAtPlayer True for item to fly at player
++     * @param flyAtPlayer true for item to fly at player
 +     */
 +    public void setFlyAtPlayer(boolean flyAtPlayer) {
 +        this.flyAtPlayer = flyAtPlayer;
@@ -34,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    /**
 +     * Gets if the item will fly at the player
 +     *
-+     * @return True if the item will fly at the player
++     * @return true if the item will fly at the player
 +     */
 +    public boolean getFlyAtPlayer() {
 +        return flyAtPlayer;