Start working on 1.19.4

patches/unapplied/api/API-for-creating-command-sender-which-forwards-feedb.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Tue, 1 Feb 2022 15:51:44 -0700
+Subject: [PATCH] API for creating command sender which forwards feedback
+
+
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -0,0 +0,0 @@ public final class Bukkit {
+         return server.getConsoleSender();
+     }
+ 
++    // Paper start
++    /**
++     * Creates a special {@link CommandSender} which redirects command feedback (in the form of chat messages) to the
++     * specified listener. The returned sender will have the same effective permissions as {@link #getConsoleSender()}.
++     *
++     * @param feedback feedback listener
++     * @return a command sender
++     */
++    @NotNull
++    public static CommandSender createCommandSender(final @NotNull java.util.function.Consumer<? super net.kyori.adventure.text.Component> feedback) {
++        return server.createCommandSender(feedback);
++    }
++    // Paper end
++
+     /**
+      * Gets the folder that contains all of the various {@link World}s.
+      *
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -0,0 +0,0 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+     @NotNull
+     public ConsoleCommandSender getConsoleSender();
+ 
++    // Paper start
++    /**
++     * Creates a special {@link CommandSender} which redirects command feedback (in the form of chat messages) to the
++     * specified listener. The returned sender will have the same effective permissions as {@link #getConsoleSender()}.
++     *
++     * @param feedback feedback listener
++     * @return a command sender
++     */
++    @NotNull
++    public CommandSender createCommandSender(final @NotNull java.util.function.Consumer<? super net.kyori.adventure.text.Component> feedback);
++    // Paper end
++
+     /**
+      * Gets the folder that contains all of the various {@link World}s.
+      *

patches/unapplied/api/API-to-get-a-BlockState-without-a-snapshot.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 6 Nov 2017 21:10:01 -0500
+Subject: [PATCH] API to get a BlockState without a snapshot
+
+This allows you to get a BlockState without creating a snapshot, operating
+on the real tile entity.
+
+This is useful for where performance is needed
+
+diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Block.java
++++ b/src/main/java/org/bukkit/block/Block.java
+@@ -0,0 +0,0 @@ public interface Block extends Metadatable, Translatable {
+     @NotNull
+     BlockState getState();
+ 
++    // Paper start
++    /**
++     * @see #getState() optionally disables use of snapshot, to operate on real block data
++     * @param useSnapshot if this block is a TE, should we create a fully copy of the TileEntity
++     * @return BlockState with the current state of this block
++     */
++    @NotNull
++    BlockState getState(boolean useSnapshot);
++    // Paper end
++
+     /**
+      * Returns the biome that this block resides in
+      *
+diff --git a/src/main/java/org/bukkit/block/TileState.java b/src/main/java/org/bukkit/block/TileState.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/TileState.java
++++ b/src/main/java/org/bukkit/block/TileState.java
+@@ -0,0 +0,0 @@ public interface TileState extends BlockState, PersistentDataHolder {
+     @NotNull
+     @Override
+     PersistentDataContainer getPersistentDataContainer();
++
++    // Paper start
++    /**
++     * Checks if this TileState is a snapshot or a live
++     * representation of the underlying tile entity.
++     * <p>
++     * NOTE: You may still have to call {@link BlockState#update()} on
++     * live representations to update any visuals on the block.
++     *
++     * @return true if this is a snapshot
++     * @see Block#getState(boolean)
++     */
++    boolean isSnapshot();
++    // Paper end
+ }

patches/unapplied/api/Ability-to-apply-mending-to-XP-API.patch

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 20 Dec 2017 17:38:07 -0500
+Subject: [PATCH] Ability to apply mending to XP API
+
+This allows plugins that give players the ability to apply the experience
+points to the Item Mending formula, which will repair an item instead
+of giving the player experience points.
+
+Both an API To standalone mend, and apply mending logic to .giveExp has been added.
+
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      */
+     public void resetPlayerWeather();
+ 
++    // Paper start
++    /**
++     * Gives the player the amount of experience specified.
++     *
++     * @param amount Exp amount to give
++     */
++    public default void giveExp(int amount) {
++        giveExp(amount, false);
++    }
+     /**
+      * Gives the player the amount of experience specified.
+      *
+      * @param amount Exp amount to give
++     * @param applyMending Mend players items with mending, with same behavior as picking up orbs. calls {@link #applyMending(int)}
+      */
+-    public void giveExp(int amount);
++    public void giveExp(int amount, boolean applyMending);
++
++    /**
++     * Applies the mending effect to any items just as picking up an orb would.
++     *
++     * Can also be called with {@link #giveExp(int, boolean)} by passing true to applyMending
++     *
++     * @param amount Exp to apply
++     * @return the remaining experience
++     */
++    public int applyMending(int amount);
++    // Paper end
+ 
+     /**
+      * Gives the player the amount of experience levels specified. Levels can

patches/unapplied/api/Ability-to-change-PlayerProfile-in-AsyncPreLoginEven.patch

@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 18 Mar 2018 11:43:30 -0400
+Subject: [PATCH] Ability to change PlayerProfile in AsyncPreLoginEvent
+
+This will allow you to change the players name or skin on login.
+
+diff --git a/src/main/java/org/bukkit/event/player/AsyncPlayerPreLoginEvent.java b/src/main/java/org/bukkit/event/player/AsyncPlayerPreLoginEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/AsyncPlayerPreLoginEvent.java
++++ b/src/main/java/org/bukkit/event/player/AsyncPlayerPreLoginEvent.java
+@@ -0,0 +0,0 @@ package org.bukkit.event.player;
+ 
+ import java.net.InetAddress;
+ import java.util.UUID;
++
++import com.destroystokyo.paper.profile.PlayerProfile;
++import org.bukkit.Bukkit;
+ import org.bukkit.event.Event;
+ import org.bukkit.event.HandlerList;
+ import org.jetbrains.annotations.NotNull;
+@@ -0,0 +0,0 @@ public class AsyncPlayerPreLoginEvent extends Event {
+     private static final HandlerList handlers = new HandlerList();
+     private Result result;
+     private net.kyori.adventure.text.Component message; // Paper
+-    private final String name;
++    //private String name; // Paper - Not used anymore
+     private final InetAddress ipAddress;
+-    private final UUID uniqueId;
++    //private UUID uniqueId; // Paper - Not used anymore
+ 
+     @Deprecated
+     public AsyncPlayerPreLoginEvent(@NotNull final String name, @NotNull final InetAddress ipAddress) {
+@@ -0,0 +0,0 @@ public class AsyncPlayerPreLoginEvent extends Event {
+     }
+ 
+     public AsyncPlayerPreLoginEvent(@NotNull final String name, @NotNull final InetAddress ipAddress, @NotNull final UUID uniqueId) {
++        // Paper start
++        this(name, ipAddress, uniqueId, Bukkit.createProfile(uniqueId, name));
++    }
++    private PlayerProfile profile;
++
++    /**
++     * Gets the PlayerProfile of the player logging in
++     * @return The Profile
++     */
++    @NotNull
++    public PlayerProfile getPlayerProfile() {
++        return profile;
++    }
++
++    /**
++     * Changes the PlayerProfile the player will login as
++     * @param profile The profile to use
++     */
++    public void setPlayerProfile(@NotNull PlayerProfile profile) {
++        this.profile = profile;
++    }
++
++    public AsyncPlayerPreLoginEvent(@NotNull final String name, @NotNull final InetAddress ipAddress, @NotNull final UUID uniqueId, @NotNull PlayerProfile profile) {
+         super(true);
++        this.profile = profile;
++        // Paper end
+         this.result = Result.ALLOWED;
+         this.message = net.kyori.adventure.text.Component.empty(); // Paper
+-        this.name = name;
++        //this.name = name; // Paper - Not used anymore
+         this.ipAddress = ipAddress;
+-        this.uniqueId = uniqueId;
++        //this.uniqueId = uniqueId; // Paper - Not used anymore
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class AsyncPlayerPreLoginEvent extends Event {
+      */
+     @NotNull
+     public String getName() {
+-        return name;
++        return profile.getName(); // Paper
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class AsyncPlayerPreLoginEvent extends Event {
+      */
+     @NotNull
+     public UUID getUniqueId() {
+-        return uniqueId;
++        return profile.getId(); // Paper
+     }
+ 
+     @NotNull

patches/unapplied/api/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 15 Aug 2018 01:04:58 -0400
+Subject: [PATCH] Ability to get Tile Entities from a chunk without snapshots
+
+
+diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Chunk.java
++++ b/src/main/java/org/bukkit/Chunk.java
+@@ -0,0 +0,0 @@ public interface Chunk extends PersistentDataHolder {
+      * @return The tile entities.
+      */
+     @NotNull
+-    BlockState[] getTileEntities();
++    // Paper start
++    default BlockState[] getTileEntities() {
++        return getTileEntities(true);
++    }
++
++    /**
++     * Get a list of all tile entities in the chunk.
++     *
++     * @param useSnapshot Take snapshots or direct references
++     * @return The tile entities.
++     */
++    @NotNull
++    BlockState[] getTileEntities(boolean useSnapshot);
++
++    /**
++     * Get a list of all tile entities that match a given predicate in the chunk.
++     *
++     * @param blockPredicate The predicate of blocks to return tile entities for
++     * @param useSnapshot Take snapshots or direct references
++     * @return The tile entities.
++     */
++    @NotNull
++    Collection<BlockState> getTileEntities(java.util.function.@NotNull Predicate<Block> blockPredicate, boolean useSnapshot);
++    // Paper end
+ 
+     /**
+      * Checks if the chunk is loaded.

patches/unapplied/api/Add-API-for-item-entity-health.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 28 Aug 2021 09:00:35 -0700
+Subject: [PATCH] Add API for item entity health
+
+
+diff --git a/src/main/java/org/bukkit/entity/Item.java b/src/main/java/org/bukkit/entity/Item.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Item.java
++++ b/src/main/java/org/bukkit/entity/Item.java
+@@ -0,0 +0,0 @@ public interface Item extends Entity {
+      * @param willAge True if the item should age
+      */
+     public void setWillAge(boolean willAge);
++
++    /**
++     * Gets the health of item stack.
++     * <p>
++     * Currently the default max health is 5.
++     *
++     * @return the health
++     */
++    public int getHealth();
++
++    /**
++     * Sets the health of the item stack. If the value is non-positive
++     * the itemstack's normal "on destroy" functionality will be run.
++     * <p>
++     * Currently, the default max health is 5.
++     *
++     * @param health the health, a non-positive value will destroy the entity
++     */
++    public void setHealth(int health);
+     // Paper end
+ }

patches/unapplied/api/Add-API-for-quit-reason.patch

@@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 14 Nov 2020 16:19:58 +0100
+Subject: [PATCH] Add API for quit reason
+
+
+diff --git a/src/main/java/org/bukkit/event/player/PlayerQuitEvent.java b/src/main/java/org/bukkit/event/player/PlayerQuitEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerQuitEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerQuitEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ public class PlayerQuitEvent extends PlayerEvent {
+     private static final HandlerList handlers = new HandlerList();
+     private net.kyori.adventure.text.Component quitMessage; // Paper
++    private final QuitReason reason; // Paper
+ 
+     @Deprecated // Paper
+     public PlayerQuitEvent(@NotNull final Player who, @Nullable final String quitMessage) {
++        // Paper start
++        this(who, quitMessage, null);
++    }
++    @Deprecated // Paper
++    public PlayerQuitEvent(@NotNull final Player who, @Nullable final String quitMessage, @Nullable QuitReason quitReason) {
+         super(who);
+         this.quitMessage = quitMessage != null ? net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(quitMessage) : null; // Paper
++        this.reason = quitReason == null ? QuitReason.DISCONNECTED : quitReason;
+     }
+     // Paper start
++    @Deprecated
+     public PlayerQuitEvent(@NotNull final Player who, @Nullable final net.kyori.adventure.text.Component quitMessage) {
++        this(who, quitMessage, null);
++    }
++    public PlayerQuitEvent(@NotNull final Player who, @Nullable final net.kyori.adventure.text.Component quitMessage, @Nullable QuitReason quitReason) {
+         super(who);
+         this.quitMessage = quitMessage;
++        this.reason = quitReason == null ? QuitReason.DISCONNECTED : quitReason;
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class PlayerQuitEvent extends PlayerEvent {
+     public static HandlerList getHandlerList() {
+         return handlers;
+     }
++
++    // Paper start
++    @NotNull
++    public QuitReason getReason() {
++        return this.reason;
++    }
++
++    public enum QuitReason {
++        /**
++         * The player left on their own behalf.
++         * <p>
++         * This does not mean they pressed the disconnect button in their client, but rather that the client severed the
++         * connection themselves. This may occur if no keep-alive packet is received on their side, among other things.
++         */
++        DISCONNECTED,
++
++        /**
++         * The player was kicked from the server.
++         */
++        KICKED,
++
++        /**
++         * The player has timed out.
++         */
++        TIMED_OUT,
++
++        /**
++         * The player's connection has entered an erroneous state.
++         * <p>
++         * Reasons for this may include invalid packets, invalid data, and uncaught exceptions in the packet handler,
++         * among others.
++         */
++        ERRONEOUS_STATE,
++    }
++    // Paper end
+ }

patches/unapplied/api/Add-API-for-resetting-a-single-score.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: booky10 <boooky10@gmail.com>
+Date: Fri, 5 Nov 2021 21:01:36 +0100
+Subject: [PATCH] Add API for resetting a single score
+
+It was only possible to reset all scores for a specific entry, instead of resetting only specific scores.
+
+diff --git a/src/main/java/org/bukkit/scoreboard/Score.java b/src/main/java/org/bukkit/scoreboard/Score.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/scoreboard/Score.java
++++ b/src/main/java/org/bukkit/scoreboard/Score.java
+@@ -0,0 +0,0 @@ public interface Score {
+      */
+     @Nullable
+     Scoreboard getScoreboard();
++
++    // Paper start
++    /**
++     * Resets this score, if a value has been set.
++     *
++     * @throws IllegalStateException if the associated objective has been
++     *     unregistered
++     */
++    void resetScore() throws IllegalStateException;
++    // Paper end
+ }

patches/unapplied/api/Add-API-methods-to-control-if-armour-stands-can-move.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Riley Park <rileysebastianpark@gmail.com>
+Date: Wed, 21 Dec 2016 11:47:25 -0600
+Subject: [PATCH] Add API methods to control if armour stands can move
+
+
+diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org/bukkit/entity/ArmorStand.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/ArmorStand.java
++++ b/src/main/java/org/bukkit/entity/ArmorStand.java
+@@ -0,0 +0,0 @@ public interface ArmorStand extends LivingEntity {
+          */
+         ADDING;
+     }
++    // Paper start
++    /**
++     * Tests if this armor stand can move.
++     *
++     * <p>The default value is {@code true}.</p>
++     *
++     * @return {@code true} if this armour stand can move, {@code false} otherwise
++     */
++    boolean canMove();
++
++    /**
++     * Sets if this armor stand can move.
++     *
++     * @param move {@code true} if this armour stand can move, {@code false} otherwise
++     */
++    void setCanMove(boolean move);
++    // Paper end
+ }

patches/unapplied/api/Add-API-to-get-Material-from-Boats-and-Minecarts.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Madeline Miller <mnmiller1@me.com>
+Date: Thu, 31 Dec 2020 12:48:38 +1000
+Subject: [PATCH] Add API to get Material from Boats and Minecarts
+
+
+diff --git a/src/main/java/org/bukkit/entity/Boat.java b/src/main/java/org/bukkit/entity/Boat.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Boat.java
++++ b/src/main/java/org/bukkit/entity/Boat.java
+@@ -0,0 +0,0 @@ public interface Boat extends Vehicle {
+         ON_LAND,
+         IN_AIR;
+     }
++
++    // Paper start
++    /**
++     * Gets the {@link Material} that represents this Boat type.
++     *
++     * @return the boat material.
++     */
++    @NotNull
++    public Material getBoatMaterial();
++    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/entity/Minecart.java b/src/main/java/org/bukkit/entity/Minecart.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Minecart.java
++++ b/src/main/java/org/bukkit/entity/Minecart.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.entity;
+ 
++import org.bukkit.Material;
+ import org.bukkit.block.data.BlockData;
+ import org.bukkit.material.MaterialData;
+ import org.bukkit.util.Vector;
+@@ -0,0 +0,0 @@ public interface Minecart extends Vehicle {
+      * @return the current block offset for this minecart.
+      */
+     public int getDisplayBlockOffset();
++
++    // Paper start
++    /**
++     * Gets the {@link Material} that represents this Minecart type.
++     *
++     * @return the minecart material.
++     */
++    @NotNull
++    public Material getMinecartMaterial();
++    // Paper end
+ }

patches/unapplied/api/Add-API-to-get-exact-interaction-point-in-PlayerInte.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Madeline Miller <mnmiller1@me.com>
+Date: Mon, 4 Jan 2021 16:40:55 +1000
+Subject: [PATCH] Add API to get exact interaction point in PlayerInteractEvent
+
+
+diff --git a/src/main/java/org/bukkit/event/player/PlayerInteractEvent.java b/src/main/java/org/bukkit/event/player/PlayerInteractEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerInteractEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerInteractEvent.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.event.player;
+ 
++import org.bukkit.Location;
+ import org.bukkit.Material;
+ import org.bukkit.block.Block;
+ import org.bukkit.block.BlockFace;
+@@ -0,0 +0,0 @@ public class PlayerInteractEvent extends PlayerEvent implements Cancellable {
+     private Result useClickedBlock;
+     private Result useItemInHand;
+     private EquipmentSlot hand;
++    private Location interactionPoint; // Paper
+ 
+     public PlayerInteractEvent(@NotNull final Player who, @NotNull final Action action, @Nullable final ItemStack item, @Nullable final Block clickedBlock, @NotNull final BlockFace clickedFace) {
+         this(who, action, item, clickedBlock, clickedFace, EquipmentSlot.HAND);
+     }
+ 
+     public PlayerInteractEvent(@NotNull final Player who, @NotNull final Action action, @Nullable final ItemStack item, @Nullable final Block clickedBlock, @NotNull final BlockFace clickedFace, @Nullable final EquipmentSlot hand) {
++        // Paper start - Add interactionPoint
++        this(who, action, item, clickedBlock, clickedFace, hand, null);
++    }
++
++    public PlayerInteractEvent(@NotNull final Player who, @NotNull final Action action, @Nullable final ItemStack item, @Nullable final Block clickedBlock, @NotNull final BlockFace clickedFace, @Nullable final EquipmentSlot hand, @Nullable final Location interactionPoint) {
+         super(who);
+         this.action = action;
+         this.item = item;
+         this.blockClicked = clickedBlock;
+         this.blockFace = clickedFace;
+         this.hand = hand;
++        this.interactionPoint = interactionPoint;
+ 
+         useItemInHand = Result.DEFAULT;
+         useClickedBlock = clickedBlock == null ? Result.DENY : Result.ALLOW;
+     }
++    // Paper end
+ 
+     /**
+      * Returns the action type
+@@ -0,0 +0,0 @@ public class PlayerInteractEvent extends PlayerEvent implements Cancellable {
+         return hand;
+     }
+ 
++    // Paper start
++    /**
++     * The exact point at which the interaction occurred. May be null.
++     *
++     * @return the exact interaction point. May be null.
++     */
++    @Nullable
++    public Location getInteractionPoint() {
++        return interactionPoint;
++    }
++    // Paper end
++
+     @NotNull
+     @Override
+     public HandlerList getHandlers() {

patches/unapplied/api/Add-APIs-to-replace-OfflinePlayer-getLastPlayed.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <1254957+zachbr@users.noreply.github.com>
+Date: Wed, 2 Jan 2019 00:31:12 -0600
+Subject: [PATCH] Add APIs to replace OfflinePlayer#getLastPlayed
+
+Currently OfflinePlayer#getLastPlayed could more accurately be described
+as "OfflinePlayer#getLastTimeTheirDataWasSaved".
+
+The API doc says it should return the last time the server "witnessed"
+the player, whilst also saying it should return the last time they
+logged in. The current implementation does neither.
+
+Given this interesting contradiction in the API documentation and the
+current defacto implementation, I've elected to deprecate (with no
+intent to remove) and replace it with two new methods, clearly named and
+documented as to their purpose.
+
+diff --git a/src/main/java/org/bukkit/OfflinePlayer.java b/src/main/java/org/bukkit/OfflinePlayer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/OfflinePlayer.java
++++ b/src/main/java/org/bukkit/OfflinePlayer.java
+@@ -0,0 +0,0 @@ public interface OfflinePlayer extends ServerOperator, AnimalTamer, Configuratio
+      * UTC.
+      *
+      * @return Date of last log-in for this player, or 0
++     * @deprecated The API contract is ambiguous and the implementation may or may not return the correct value given this API ambiguity. It is instead recommended use {@link #getLastLogin()} or {@link #getLastSeen()} depending on your needs.
+      */
++    @Deprecated
+     public long getLastPlayed();
+ 
+     /**
+@@ -0,0 +0,0 @@ public interface OfflinePlayer extends ServerOperator, AnimalTamer, Configuratio
+      */
+     @Nullable
+     public Location getBedSpawnLocation();
++    // Paper start
++    /**
++     * Gets the last date and time that this player logged into the server.
++     * <p>
++     * If the player has never played before, this will return 0. Otherwise,
++     * it will be the amount of milliseconds since midnight, January 1, 1970
++     * UTC.
++     *
++     * @return last login time
++     */
++    public long getLastLogin();
++
++    /**
++     * Gets the last date and time that this player was seen on the server.
++     * <p>
++     * If the player has never played before, this will return 0. If the
++     * player is currently online, this will return the current time.
++     * Otherwise it will be the amount of milliseconds since midnight,
++     * January 1, 1970 UTC.
++     *
++     * @return last seen time
++     */
++    public long getLastSeen();
++    // Paper end
+ 
+     /**
+      * Increments the given statistic for this player.

patches/unapplied/api/Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alvinn8 <42838560+Alvinn8@users.noreply.github.com>
+Date: Fri, 8 Jan 2021 20:29:58 +0100
+Subject: [PATCH] Add Adventure message to PlayerAdvancementDoneEvent
+
+
+diff --git a/src/main/java/org/bukkit/event/player/PlayerAdvancementDoneEvent.java b/src/main/java/org/bukkit/event/player/PlayerAdvancementDoneEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerAdvancementDoneEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerAdvancementDoneEvent.java
+@@ -0,0 +0,0 @@ import org.bukkit.advancement.Advancement;
+ import org.bukkit.entity.Player;
+ import org.bukkit.event.HandlerList;
+ import org.jetbrains.annotations.NotNull;
++// Paper start
++import org.jetbrains.annotations.Nullable;
++import net.kyori.adventure.text.Component;
++// Paper end
+ 
+ /**
+  * Called when a player has completed all criteria in an advancement.
+@@ -0,0 +0,0 @@ public class PlayerAdvancementDoneEvent extends PlayerEvent {
+     private static final HandlerList handlers = new HandlerList();
+     //
+     private final Advancement advancement;
++    private Component message; // Paper - Add Adventure message
+ 
+     public PlayerAdvancementDoneEvent(@NotNull Player who, @NotNull Advancement advancement) {
++        // Paper start - Add Adventure message
++        this(who, advancement, null);
++    }
++    public PlayerAdvancementDoneEvent(@NotNull Player who, @NotNull Advancement advancement, @Nullable Component message) {
++        // Paper end
+         super(who);
+         this.advancement = advancement;
++        this.message = message; // Paper - Add Adventure message
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class PlayerAdvancementDoneEvent extends PlayerEvent {
+         return advancement;
+     }
+ 
++    // Paper start - Add Adventure message
++    /**
++     * Gets the message to send to all online players.
++     * <p>
++     * Will be null if the advancement does not announce to chat, for example if
++     * it is a recipe unlock or a root advancement.
++     *
++     * @return The announcement message, or null
++     */
++    @Nullable
++    public Component message() {
++        return this.message;
++    }
++
++    /**
++     * Sets the message to send to all online players.
++     * <p>
++     * If set to null the message will not be sent.
++     *
++     * @param message The new message
++     */
++    public void message(@Nullable Component message) {
++        this.message = message;
++    }
++    // Paper end
+     @NotNull
+     @Override
+     public HandlerList getHandlers() {

patches/unapplied/api/Add-ArmorStand-Item-Meta.patch

@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <1254957+zachbr@users.noreply.github.com>
+Date: Sat, 27 Jan 2018 17:06:24 -0500
+Subject: [PATCH] Add ArmorStand Item Meta
+
+This is adds basic item meta for armor stands. It does not add all
+possible metadata however.
+
+There are armor, hand, and equipment types, as well as position data
+that can also be added here. This initial addition should serve a
+starting point for future additions in this area.
+
+diff --git a/src/main/java/com/destroystokyo/paper/inventory/meta/ArmorStandMeta.java b/src/main/java/com/destroystokyo/paper/inventory/meta/ArmorStandMeta.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/inventory/meta/ArmorStandMeta.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.inventory.meta;
++
++import org.bukkit.inventory.meta.ItemMeta;
++
++public interface ArmorStandMeta extends ItemMeta {
++
++    /**
++     * Gets whether the ArmorStand should be invisible when spawned
++     *
++     * @return true if this should be invisible
++     */
++    boolean isInvisible();
++
++    /**
++     * Gets whether this ArmorStand should have no base plate when spawned
++     *
++     * @return true if it will not have a base plate
++     */
++    boolean hasNoBasePlate();
++
++    /**
++     * Gets whether this ArmorStand should show arms when spawned
++     *
++     * @return true if it will show arms
++     */
++    boolean shouldShowArms();
++
++    /**
++     * Gets whether this ArmorStand will be small when spawned
++     *
++     * @return true if it will be small
++     */
++    boolean isSmall();
++
++    /**
++     * Gets whether this ArmorStand will be a marker when spawned
++     * The exact details of this flag are an implementation detail
++     *
++     * @return true if it will be a marker
++     */
++    boolean isMarker();
++
++    /**
++     * Sets that this ArmorStand should be invisible when spawned
++     *
++     * @param invisible true if set invisible
++     */
++    void setInvisible(boolean invisible);
++
++    /**
++     * Sets that this ArmorStand should have no base plate when spawned
++     *
++     * @param noBasePlate true if no base plate
++     */
++    void setNoBasePlate(boolean noBasePlate);
++
++    /**
++     * Sets that this ArmorStand should show arms when spawned
++     *
++     * @param showArms true if show arms
++     */
++    void setShowArms(boolean showArms);
++
++    /**
++     * Sets that this ArmorStand should be small when spawned
++     *
++     * @param small true if small
++     */
++    void setSmall(boolean small);
++
++    /**
++     * Sets that this ArmorStand should be a marker when spawned
++     * The exact details of this flag are an implementation detail
++     *
++     * @param marker true if a marker
++     */
++    void setMarker(boolean marker);
++}

patches/unapplied/api/Add-Ban-Methods-to-Player-Objects.patch

@@ -0,0 +1,242 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 28 Apr 2018 10:28:50 -0400
+Subject: [PATCH] Add Ban Methods to Player Objects
+
+Allows a more logical API for banning players.
+
+player.banPlayer("Breaking the rules");
+
+diff --git a/src/main/java/org/bukkit/OfflinePlayer.java b/src/main/java/org/bukkit/OfflinePlayer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/OfflinePlayer.java
++++ b/src/main/java/org/bukkit/OfflinePlayer.java
+@@ -0,0 +0,0 @@ public interface OfflinePlayer extends ServerOperator, AnimalTamer, Configuratio
+      * @return true if banned, otherwise false
+      */
+     public boolean isBanned();
++    // Paper start
++
++    /**
++     * Permanently Bans this player from the server
++     *
++     * @param reason Reason for Ban
++     * @return Ban Entry
++     */
++    @NotNull
++    public default BanEntry banPlayer(@Nullable String reason) {
++        return banPlayer(reason, null, null);
++    }
++
++    /**
++     * Permanently Bans this player from the server
++     * @param reason Reason for Ban
++     * @param source Source of the ban, or null for default
++     * @return Ban Entry
++     */
++    @NotNull
++    public default BanEntry banPlayer(@Nullable String reason, @Nullable String source) {
++        return banPlayer(reason, null, source);
++    }
++
++    /**
++     * Bans this player from the server
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @return Ban Entry
++     */
++    @NotNull
++    public default BanEntry banPlayer(@Nullable String reason, @Nullable java.util.Date expires) {
++        return banPlayer(reason, expires, null);
++    }
++
++    /**
++     * Bans this player from the server
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @param source Source of the ban or null for default
++     * @return Ban Entry
++     */
++    @NotNull
++    public default BanEntry banPlayer(@Nullable String reason, @Nullable java.util.Date expires, @Nullable String source) {
++        return banPlayer(reason, expires, source, true);
++    }
++    @NotNull
++    public default BanEntry banPlayer(@Nullable String reason, @Nullable java.util.Date expires, @Nullable String source, boolean kickIfOnline) {
++        BanEntry banEntry = Bukkit.getServer().getBanList(BanList.Type.NAME).addBan(getName(), reason, expires, source);
++        if (kickIfOnline && isOnline()) {
++            getPlayer().kickPlayer(reason);
++        }
++        return banEntry;
++    }
++    // Paper end
+ 
+     /**
+      * Checks if this player is whitelisted or not
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+     public void sendMap(@NotNull MapView map);
+ 
+     // Paper start
++    /**
++     * Permanently Bans the Profile and IP address currently used by the player.
++     *
++     * @param reason Reason for ban
++     * @return Ban Entry
++     */
++    // For reference, Bukkit defines this as nullable, while they impl isn't, we'll follow API.
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerFull(@Nullable String reason) {
++        return banPlayerFull(reason, null, null);
++    }
++
++    /**
++     * Permanently Bans the Profile and IP address currently used by the player.
++     *
++     * @param reason Reason for ban
++     * @param source Source of ban, or null for default
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerFull(@Nullable String reason, @Nullable String source) {
++        return banPlayerFull(reason, null, source);
++    }
++
++    /**
++     * Bans the Profile and IP address currently used by the player.
++     *
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerFull(@Nullable String reason, @Nullable java.util.Date expires) {
++        return banPlayerFull(reason, expires, null);
++    }
++
++    /**
++     * Bans the Profile and IP address currently used by the player.
++     *
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @param source Source of the ban, or null for default
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerFull(@Nullable String reason, @Nullable java.util.Date expires, @Nullable String source) {
++        banPlayer(reason, expires, source);
++        return banPlayerIP(reason, expires, source, true);
++    }
++
++    /**
++     * Permanently Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     *
++     * @param reason Reason for ban
++     * @param kickPlayer Whether or not to kick the player afterwards
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, boolean kickPlayer) {
++        return banPlayerIP(reason, null, null, kickPlayer);
++    }
++
++    /**
++     * Permanently Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for ban
++     * @param source Source of ban, or null for default
++     * @param kickPlayer Whether or not to kick the player afterwards
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable String source, boolean kickPlayer) {
++        return banPlayerIP(reason, null, source, kickPlayer);
++    }
++
++    /**
++     * Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @param kickPlayer Whether or not to kick the player afterwards
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable java.util.Date expires, boolean kickPlayer) {
++        return banPlayerIP(reason, expires, null, kickPlayer);
++    }
++
++    /**
++     * Permanently Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     *
++     * @param reason Reason for ban
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason) {
++        return banPlayerIP(reason, null, null);
++    }
++
++    /**
++     * Permanently Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for ban
++     * @param source Source of ban, or null for default
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable String source) {
++        return banPlayerIP(reason, null, source);
++    }
++
++    /**
++     * Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable java.util.Date expires) {
++        return banPlayerIP(reason, expires, null);
++    }
++
++    /**
++     * Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @param source Source of the banm or null for default
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable java.util.Date expires, @Nullable String source) {
++        return banPlayerIP(reason, expires, source, true);
++    }
++
++    /**
++     * Bans the IP address currently used by the player.
++     * Does not ban the Profile, use {@link #banPlayerFull(String, java.util.Date, String)}
++     * @param reason Reason for Ban
++     * @param expires When to expire the ban
++     * @param source Source of the banm or null for default
++     * @param kickPlayer if the targeted player should be kicked
++     * @return Ban Entry
++     */
++    @Nullable
++    public default org.bukkit.BanEntry banPlayerIP(@Nullable String reason, @Nullable java.util.Date expires, @Nullable String source, boolean kickPlayer) {
++        org.bukkit.BanEntry banEntry = org.bukkit.Bukkit.getServer().getBanList(org.bukkit.BanList.Type.IP).addBan(getAddress().getAddress().getHostAddress(), reason, expires, source);
++        if (kickPlayer && isOnline()) {
++            getPlayer().kickPlayer(reason);
++        }
++
++        return banEntry;
++    }
+ 
+     /**
+      * Sends an Action Bar message to the client.

patches/unapplied/api/Add-BaseComponent-sendMessage-methods-to-CommandSend.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Riley Park <rileysebastianpark@gmail.com>
+Date: Tue, 8 Mar 2016 13:05:59 -0800
+Subject: [PATCH] Add BaseComponent sendMessage methods to CommandSender
+
+
+diff --git a/src/main/java/org/bukkit/command/CommandSender.java b/src/main/java/org/bukkit/command/CommandSender.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/command/CommandSender.java
++++ b/src/main/java/org/bukkit/command/CommandSender.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.command;
+ 
+ import java.util.UUID;
++import net.kyori.adventure.audience.MessageType;
++import net.kyori.adventure.identity.Identity;
++import net.kyori.adventure.text.Component;
+ import org.bukkit.Server;
+ import org.bukkit.permissions.Permissible;
+ import org.jetbrains.annotations.NotNull;
+@@ -0,0 +0,0 @@ public interface CommandSender extends net.kyori.adventure.audience.Audience, Pe
+     default void sendPlainMessage(final @NotNull String message) {
+         this.sendMessage(net.kyori.adventure.text.Component.text(message));
+     }
++
++    /**
++     * Sends the component to the sender
++     *
++     * <p>If this sender does not support sending full components then
++     * the component will be sent as legacy text.</p>
++     *
++     * @param component the component to send
++     * @deprecated use {@link #sendMessage(Identity, Component, MessageType)} instead
++     */
++    @Deprecated
++    default void sendMessage(@NotNull net.md_5.bungee.api.chat.BaseComponent component) {
++        this.sendMessage(component.toLegacyText());
++    }
++
++    /**
++     * Sends an array of components as a single message to the sender
++     *
++     * <p>If this sender does not support sending full components then
++     * the components will be sent as legacy text.</p>
++     *
++     * @param components the components to send
++     * @deprecated use {@link #sendMessage(Identity, Component, MessageType)} instead
++     */
++    @Deprecated
++    default void sendMessage(@NotNull net.md_5.bungee.api.chat.BaseComponent... components) {
++        this.sendMessage(new net.md_5.bungee.api.chat.TextComponent(components).toLegacyText());
++    }
+     // Paper end
+ }

patches/unapplied/api/Add-BeaconEffectEvent.patch

@@ -0,0 +1,98 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Mon, 29 Feb 2016 18:09:40 -0600
+Subject: [PATCH] Add BeaconEffectEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/block/BeaconEffectEvent.java b/src/main/java/com/destroystokyo/paper/event/block/BeaconEffectEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/block/BeaconEffectEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.bukkit.potion.PotionEffect;
++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;
++
++    public BeaconEffectEvent(@NotNull Block block, @NotNull PotionEffect effect, @NotNull Player player, boolean primary) {
++        super(block);
++        this.effect = effect;
++        this.player = player;
++        this.primary = primary;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancelled) {
++        this.cancelled = cancelled;
++    }
++
++    /**
++     * Gets the potion effect being applied.
++     *
++     * @return Potion effect
++     */
++    @NotNull
++    public PotionEffect getEffect() {
++        return effect;
++    }
++
++    /**
++     * Sets the potion effect that will be applied.
++     *
++     * @param effect Potion effect
++     */
++    public void setEffect(@NotNull PotionEffect effect) {
++        this.effect = effect;
++    }
++
++    /**
++     * Gets the player who the potion effect is being applied to.
++     *
++     * @return Affected player
++     */
++    @NotNull
++    public Player getPlayer() {
++        return player;
++    }
++
++    /**
++     * Gets whether the effect is a primary beacon effect.
++     *
++     * @return true if this event represents a primary effect
++     */
++    public boolean isPrimary() {
++        return primary;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-BellRevealRaiderEvent.patch

@@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 26 May 2021 17:08:57 -0400
+Subject: [PATCH] Add BellRevealRaiderEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/BellRevealRaiderEvent.java b/src/main/java/io/papermc/paper/event/block/BellRevealRaiderEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BellRevealRaiderEvent.java
+@@ -0,0 +0,0 @@
++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.NotNull;
++
++/**
++ * Called when a {@link org.bukkit.entity.Raider} is revealed by a bell.
++ */
++public class BellRevealRaiderEvent extends BlockEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++
++    private boolean cancelled = false;
++    private final Raider raider;
++
++    public BellRevealRaiderEvent(@NotNull Block theBlock, @NotNull Entity raider) {
++        super(theBlock);
++        this.raider = (Raider) raider;
++    }
++
++    /**
++     * Gets the raider that the bell revealed.
++     *
++     * @return The raider
++     */
++    @NotNull
++    public Raider getEntity() {
++        return raider;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    /**
++     * {@inheritDoc}
++     * <p>
++     * This does not cancel the particle effects shown on the bell, only the entity.
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return handlers;
++    }
++
++    public static @NotNull HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-BellRingEvent.patch

@@ -0,0 +1,69 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Eearslya Sleiarion <eearslya@gmail.com>
+Date: Mon, 24 Jun 2019 21:27:39 -0700
+Subject: [PATCH] Add BellRingEvent
+
+Add a new event, BellRingEvent, to trigger whenever a player rings a
+village bell. Passes along the bell block and the player who rang it.
+
+diff --git a/src/main/java/io/papermc/paper/event/block/BellRingEvent.java b/src/main/java/io/papermc/paper/event/block/BellRingEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BellRingEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.bukkit.potion.PotionEffect;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when a bell is rung.
++ */
++public class BellRingEvent extends BlockEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private boolean cancelled;
++    private final Entity entity;
++
++    public BellRingEvent(@NotNull Block block, @Nullable Entity entity) {
++        super(block);
++        this.entity = entity;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancelled) {
++        this.cancelled = cancelled;
++    }
++
++    /**
++     * Gets the entity that rang the bell.
++     *
++     * @return the ringer or null if none
++     */
++    @Nullable
++    public Entity getEntity() {
++        return entity;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-Block-isValidTool.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 6 Jul 2020 12:44:23 -0700
+Subject: [PATCH] Add Block#isValidTool
+
+
+diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Block.java
++++ b/src/main/java/org/bukkit/block/Block.java
+@@ -0,0 +0,0 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
+     public static int getBlockKeyZ(long packed) {
+         return (int) ((packed << 10) >> 37);
+     }
++
++    /**
++     * Checks if the itemstack is a valid tool to
++     * break the block with
++     *
++     * @param itemStack The (tool) itemstack
++     * @return whether the block will drop items
++     */
++    boolean isValidTool(@NotNull ItemStack itemStack);
+     // Paper End
+ 
+     /**

patches/unapplied/api/Add-BlockBreakBlockEvent.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 3 Jan 2021 17:58:25 -0800
+Subject: [PATCH] Add BlockBreakBlockEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/BlockBreakBlockEvent.java b/src/main/java/io/papermc/paper/event/block/BlockBreakBlockEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BlockBreakBlockEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.List;
++
++/**
++ * Called when a block forces another block to break and drop items.
++ * <p>
++ * Currently called for piston's and liquid flows.
++ */
++public class BlockBreakBlockEvent extends BlockEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final List<ItemStack> drops;
++    private final Block source;
++
++    public BlockBreakBlockEvent(@NotNull Block block, @NotNull Block source, @NotNull List<ItemStack> drops) {
++        super(block);
++        this.source = source;
++        this.drops = drops;
++    }
++
++    /**
++     * Get the drops of this event
++     *
++     * @return the drops
++     */
++    @NotNull
++    public List<ItemStack> getDrops() {
++        return drops;
++    }
++
++    /**
++     * Gets the block that cause this (e.g. a piston, or adjacent liquid)
++     *
++     * @return the source
++     */
++    @NotNull
++    public Block getSource() {
++        return source;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}

patches/unapplied/api/Add-BlockFailedDispenseEvent.patch

@@ -0,0 +1,69 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TheViperShow <29604693+TheViperShow@users.noreply.github.com>
+Date: Wed, 22 Apr 2020 09:40:23 +0200
+Subject: [PATCH] Add BlockFailedDispenseEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/BlockFailedDispenseEvent.java b/src/main/java/io/papermc/paper/event/block/BlockFailedDispenseEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BlockFailedDispenseEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++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 boolean shouldPlayEffect = true;
++
++    public BlockFailedDispenseEvent(@NotNull Block theBlock) {
++        super(theBlock);
++    }
++
++    /**
++     * @return if the effect should be played
++     */
++    public boolean shouldPlayEffect() {
++        return this.shouldPlayEffect;
++    }
++
++    /**
++     * Sets if the effect for empty dispensers should be played
++     *
++     * @param playEffect if the effect should be played
++     */
++    public void shouldPlayEffect(boolean playEffect) {
++        this.shouldPlayEffect = playEffect;
++    }
++
++    /**
++     * {@inheritDoc}
++     *
++     * @return {@link #shouldPlayEffect()}
++     */
++    @Override
++    public boolean callEvent() {
++        super.callEvent();
++        return this.shouldPlayEffect();
++    }
++
++    @Override
++    public @NotNull
++    HandlerList getHandlers() {
++        return handlers;
++    }
++
++    public static @NotNull
++    HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-BlockLockCheckEvent.patch

@@ -0,0 +1,242 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 21 May 2022 20:59:56 -0700
+Subject: [PATCH] Add BlockLockCheckEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/block/LockableTileState.java b/src/main/java/io/papermc/paper/block/LockableTileState.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/block/LockableTileState.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.block;
++
++import org.bukkit.Nameable;
++import org.bukkit.block.Lockable;
++import org.bukkit.block.TileState;
++
++/**
++ * Interface for tile entities that are lockable.
++ */
++public interface LockableTileState extends TileState, Lockable, Nameable {
++}
+diff --git a/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java b/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BlockLockCheckEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import com.google.common.base.Preconditions;
++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.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
++ */
++public class BlockLockCheckEvent extends BlockEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final LockableTileState state;
++    private final Player player;
++    private ItemStack itemStack;
++    private Result result = Result.DEFAULT;
++    private Component lockedMessage;
++    private Sound lockedSound;
++
++    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;
++        this.player = player;
++        this.lockedMessage = lockedMessage;
++        this.lockedSound = lockedSound;
++    }
++
++    /**
++     * Gets the snapshot {@link LockableTileState} of the tile entity
++     * whose lock is being checked.
++     *
++     * @return the snapshot block state.
++     */
++    public @NotNull LockableTileState getBlockState() {
++        return this.state;
++    }
++
++    /**
++     * Get the player involved this lock check.
++     *
++     * @return the player
++     */
++    public @NotNull Player getPlayer() {
++        return this.player;
++    }
++
++    /**
++     * Gets the itemstack that will be used as the key itemstack. Initially
++     * this will be the item in the player's main hand but an override can be set
++     * with {@link #setKeyItem(ItemStack)}. Use {@link #isUsingCustomKeyItemStack()}
++     * to check if a custom key stack has been set.
++     *
++     * @return the item being used as the key item
++     * @see #isUsingCustomKeyItemStack()
++     */
++    public @NotNull ItemStack getKeyItem() {
++        return Objects.requireNonNullElseGet(this.itemStack, this.player.getInventory()::getItemInMainHand);
++    }
++
++    /**
++     * 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)
++     * @see #resetKeyItem() to clear a custom key item
++     */
++    public void setKeyItem(@NotNull ItemStack stack) {
++        Preconditions.checkNotNull(stack, "stack is null");
++        this.itemStack = stack;
++    }
++
++    /**
++     * Reset the key stack to the default (the player's main hand).
++     */
++    public void resetKeyItem() {
++        this.itemStack = null;
++    }
++
++    /**
++     * Checks if a custom key stack has been set.
++     *
++     * @return true if a custom key itemstack has been set
++     */
++    public boolean isUsingCustomKeyItemStack() {
++        return this.itemStack != null;
++    }
++
++    /**
++     * Gets the result of this event.
++     *
++     * @return the result
++     * @see #setResult(Result)
++     */
++    public @NotNull Result getResult() {
++        return this.result;
++    }
++
++    /**
++     * 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.
++     * <p>
++     * Setting this to {@link org.bukkit.event.Event.Result#ALLOW} bypasses the spectator check.
++     *
++     * @param result the result of this event
++     */
++    public void setResult(@NotNull Result result) {
++        this.result = result;
++    }
++
++    /**
++     * Shorthand method to set the {@link #getResult()} to {@link org.bukkit.event.Event.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)
++     */
++    public void denyWithMessageAndSound(@Nullable Component lockedMessage, @Nullable Sound lockedSound) {
++        this.result = Result.DENY;
++        this.lockedMessage = lockedMessage;
++        this.lockedSound = lockedSound;
++    }
++
++    /**
++     * Gets the locked message that will be sent if the
++     * player cannot open the block.
++     *
++     * @return the locked message (or null if none)
++     */
++    public @Nullable Component getLockedMessage() {
++        return this.lockedMessage;
++    }
++
++    /**
++     * Sets the locked message that will be sent if the
++     * player cannot open the block.
++     *
++     * @param lockedMessage the locked message (or null for none)
++     */
++    public void setLockedMessage(@Nullable Component lockedMessage) {
++        this.lockedMessage = lockedMessage;
++    }
++
++    /**
++     * Gets the locked sound that will play if the
++     * player cannot open the block.
++     *
++     * @return the locked sound (or null if none)
++     */
++    public @Nullable Sound getLockedSound() {
++        return this.lockedSound;
++    }
++
++    /**
++     * Sets the locked sound that will play if the
++     * player cannot open the block.
++     *
++     * @param lockedSound the locked sound (or null for none)
++     */
++    public void setLockedSound(@Nullable Sound lockedSound) {
++        this.lockedSound = lockedSound;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public static @NotNull HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}
+diff --git a/src/main/java/org/bukkit/block/Beacon.java b/src/main/java/org/bukkit/block/Beacon.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Beacon.java
++++ b/src/main/java/org/bukkit/block/Beacon.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Represents a captured state of a beacon.
+  */
+-public interface Beacon extends TileState, Lockable, Nameable {
++public interface Beacon extends io.papermc.paper.block.LockableTileState { // Paper
+ 
+     /**
+      * Returns the list of players within the beacon's range of effect.
+diff --git a/src/main/java/org/bukkit/block/Container.java b/src/main/java/org/bukkit/block/Container.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Container.java
++++ b/src/main/java/org/bukkit/block/Container.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
+ /**
+  * Represents a captured state of a container block.
+  */
+-public interface Container extends TileState, BlockInventoryHolder, Lockable, Nameable {
++public interface Container extends io.papermc.paper.block.LockableTileState, BlockInventoryHolder { // Paper
+ 
+     /**
+      * Gets the inventory of the block represented by this block state.

patches/unapplied/api/Add-BlockPreDispenseEvent.patch

@@ -0,0 +1,72 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Madeline Miller <mnmiller1@me.com>
+Date: Sun, 17 Jan 2021 13:15:54 +1000
+Subject: [PATCH] Add BlockPreDispenseEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/BlockPreDispenseEvent.java b/src/main/java/io/papermc/paper/event/block/BlockPreDispenseEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/BlockPreDispenseEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++public class BlockPreDispenseEvent extends BlockEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private boolean cancelled = false;
++    private final ItemStack itemStack;
++    private final int slot;
++
++    public BlockPreDispenseEvent(@NotNull Block block, @NotNull ItemStack itemStack, int slot) {
++        super(block);
++        this.itemStack = itemStack;
++        this.slot = slot;
++    }
++
++    /**
++     * Gets the {@link ItemStack} to be dispensed.
++     *
++     * @return The item to be dispensed
++     */
++    @NotNull
++    public ItemStack getItemStack() {
++        return itemStack;
++    }
++
++    /**
++     * Gets the inventory slot of the dispenser to dispense from.
++     *
++     * @return The inventory slot
++     */
++    public int getSlot() {
++        return slot;
++    }
++
++    @NotNull
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++}

patches/unapplied/api/Add-BlockSoundGroup-interface.patch

@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: simpleauthority <jacob@algorithmjunkie.com>
+Date: Tue, 28 May 2019 03:41:28 -0700
+Subject: [PATCH] Add BlockSoundGroup interface
+
+This PR adds the getSoundGroup() method in Block which returns a BlockSoundGroup
+
+diff --git a/src/main/java/com/destroystokyo/paper/block/BlockSoundGroup.java b/src/main/java/com/destroystokyo/paper/block/BlockSoundGroup.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/block/BlockSoundGroup.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.block;
++
++import org.bukkit.Sound;
++import org.bukkit.block.Block;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Represents the sounds that a {@link Block} makes in certain situations
++ * <p>
++ * The sound group includes break, step, place, hit, and fall sounds.
++ * @deprecated use {@link org.bukkit.SoundGroup}
++ */
++@Deprecated(forRemoval = true)
++public interface BlockSoundGroup {
++    /**
++     * Gets the sound that plays when breaking this block
++     *
++     * @return The break sound
++     * @deprecated use {@link org.bukkit.SoundGroup#getBreakSound()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    Sound getBreakSound();
++
++    /**
++     * Gets the sound that plays when stepping on this block
++     *
++     * @return The step sound
++     * @deprecated use {@link org.bukkit.SoundGroup#getStepSound()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    Sound getStepSound();
++
++    /**
++     * Gets the sound that plays when placing this block
++     *
++     * @return The place sound
++     * @deprecated use {@link org.bukkit.SoundGroup#getPlaceSound()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    Sound getPlaceSound();
++
++    /**
++     * Gets the sound that plays when hitting this block
++     *
++     * @return The hit sound
++     * @deprecated use {@link org.bukkit.SoundGroup#getHitSound()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    Sound getHitSound();
++
++    /**
++     * Gets the sound that plays when this block falls
++     *
++     * @return The fall sound
++     * @deprecated use {@link org.bukkit.SoundGroup#getFallSound()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    Sound getFallSound();
++}
+diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Block.java
++++ b/src/main/java/org/bukkit/block/Block.java
+@@ -0,0 +0,0 @@ public interface Block extends Metadatable, Translatable {
+      * @return <code>true</code> if the block data can be placed here
+      */
+     boolean canPlace(@NotNull BlockData data);
++
++    // Paper start
++    /**
++     * Gets the {@link com.destroystokyo.paper.block.BlockSoundGroup} for this block.
++     * <p>
++     * This object contains the block, step, place, hit, and fall sounds.
++     *
++     * @return the sound group for this block
++     * @deprecated use {@link #getBlockSoundGroup()}
++     */
++    @NotNull
++    @Deprecated(forRemoval = true)
++    com.destroystokyo.paper.block.BlockSoundGroup getSoundGroup();
++
++    /**
++     * Gets the {@link org.bukkit.SoundGroup} for this block.
++     *
++     * @return the sound group for this block
++     */
++    @NotNull org.bukkit.SoundGroup getBlockSoundGroup();
++    // Paper end
+ }

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

@@ -0,0 +1,126 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Sat, 7 Aug 2021 15:11:27 +0200
+Subject: [PATCH] Add CompostItemEvent and EntityCompostItemEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/CompostItemEvent.java b/src/main/java/io/papermc/paper/event/block/CompostItemEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/CompostItemEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.bukkit.event.inventory.InventoryMoveItemEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when an item is about to be composted by a hopper.
++ * To prevent hoppers from moving items into composters, cancel the {@link InventoryMoveItemEvent}.
++ */
++public class CompostItemEvent extends BlockEvent {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final ItemStack item;
++    private boolean willRaiseLevel;
++
++    public CompostItemEvent(@NotNull Block composter, @NotNull ItemStack item, boolean willRaiseLevel) {
++        super(composter);
++        this.item = item;
++        this.willRaiseLevel = willRaiseLevel;
++    }
++
++    /**
++     * Gets the item that was used on the composter.
++     *
++     * @return the item
++     */
++    @NotNull
++    public ItemStack getItem() {
++        return this.item;
++    }
++
++    /**
++     * Gets whether the composter will rise a level.
++     *
++     * @return true if successful
++     */
++    public boolean willRaiseLevel() {
++        return this.willRaiseLevel;
++    }
++
++    /**
++     * Sets whether the composter will rise a level.
++     *
++     * @param willRaiseLevel true if the composter should rise a level
++     */
++    public void setWillRaiseLevel(boolean willRaiseLevel) {
++        this.willRaiseLevel = willRaiseLevel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++}
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityCompostItemEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityCompostItemEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityCompostItemEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import io.papermc.paper.event.block.CompostItemEvent;
++import org.bukkit.block.Block;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when an item is about to be composted by an entity.
++ */
++public class EntityCompostItemEvent extends CompostItemEvent implements Cancellable {
++
++    private final Entity who;
++    private boolean cancelled;
++
++    public EntityCompostItemEvent(@NotNull Entity who, @NotNull Block composter, @NotNull ItemStack item, boolean willRaiseLevel) {
++        super(composter, item, willRaiseLevel);
++        this.who = who;
++    }
++
++    /**
++     * Gets the entity that interacted with the composter.
++     *
++     * @return the entity that composted an item.
++     */
++    @NotNull
++    public Entity getEntity() {
++        return this.who;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++}

patches/unapplied/api/Add-Destroy-Speed-API.patch

@@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ineusia <ineusia@yahoo.com>
+Date: Mon, 26 Oct 2020 11:37:48 -0500
+Subject: [PATCH] Add Destroy Speed API
+
+Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
+
+diff --git a/src/main/java/org/bukkit/block/Block.java b/src/main/java/org/bukkit/block/Block.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/Block.java
++++ b/src/main/java/org/bukkit/block/Block.java
+@@ -0,0 +0,0 @@ public interface Block extends Metadatable, Translatable, net.kyori.adventure.tr
+     @NotNull
+     @Deprecated(forRemoval = true)
+     String getTranslationKey();
++
++    /**
++     * Gets the speed at which this block will be destroyed by a given {@link ItemStack}
++     *
++     * <p>Default value is 1.0</p>
++     *
++     * @param itemStack {@link ItemStack} used to mine this Block
++     * @return the speed that this Block will be mined by the given {@link ItemStack}
++     */
++    @NotNull
++    public default float getDestroySpeed(@NotNull ItemStack itemStack) {
++        return getDestroySpeed(itemStack, false);
++    }
++
++    /**
++     * Gets the speed at which this blook will be destroyed by a given {@link org.bukkit.inventory.ItemStack}
++     * <p>
++     * Default value is 1.0
++     * @param itemStack {@link org.bukkit.inventory.ItemStack} used to mine this Block
++     * @param considerEnchants true to look at enchants on the itemstack
++     * @return the speed that this Block will be mined by the given {@link org.bukkit.inventory.ItemStack}
++     */
++    @NotNull
++    float getDestroySpeed(@NotNull ItemStack itemStack, boolean considerEnchants);
+     // Paper end
+ }

patches/unapplied/api/Add-ElderGuardianAppearanceEvent.patch

@@ -0,0 +1,81 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Fri, 19 Mar 2021 23:39:21 -0400
+Subject: [PATCH] Add ElderGuardianAppearanceEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/ElderGuardianAppearanceEvent.java b/src/main/java/io/papermc/paper/event/entity/ElderGuardianAppearanceEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/ElderGuardianAppearanceEvent.java
+@@ -0,0 +0,0 @@
++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.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}.
++ */
++public class ElderGuardianAppearanceEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList handlers = new HandlerList();
++
++    private boolean cancelled;
++    private final Player affectedPlayer;
++
++    public ElderGuardianAppearanceEvent(@NotNull Entity what, @NotNull Player affectedPlayer) {
++        super(what);
++        this.affectedPlayer = affectedPlayer;
++    }
++
++    /**
++     * Get the player affected by the guardian appearance.
++     *
++     * @return Player affected by the appearance
++     */
++    @NotNull
++    public Player getAffectedPlayer() {
++        return affectedPlayer;
++    }
++
++    /**
++     * The elder guardian playing the effect.
++     *
++     * @return The elder guardian
++     */
++    @NotNull
++    public ElderGuardian getEntity() {
++        return (ElderGuardian) entity;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-Entity-Body-Yaw-API.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TheTuso <piotrekpasztor@gmail.com>
+Date: Thu, 2 Feb 2023 16:40:11 +0100
+Subject: [PATCH] Add Entity Body Yaw API
+
+
+diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -0,0 +0,0 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+      * @param amount the amount of damage to do
+      */
+     void damageItemStack(org.bukkit.inventory.@NotNull EquipmentSlot slot, int amount);
++
++    /**
++     * Gets entity body yaw
++     *
++     * @return entity body yaw
++     * @see Location#getYaw()
++     */
++    float getBodyYaw();
++
++    /**
++     * Sets entity body yaw
++     *
++     * @param bodyYaw new entity body yaw
++     * @see Location#setYaw(float)
++     */
++    void setBodyYaw(float bodyYaw);
+     // Paper end
+ }

patches/unapplied/api/Add-EntityBlockStorage-clearEntities.patch

@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Mon, 5 Apr 2021 18:12:06 -0400
+Subject: [PATCH] Add EntityBlockStorage#clearEntities()
+
+
+diff --git a/src/main/java/org/bukkit/block/EntityBlockStorage.java b/src/main/java/org/bukkit/block/EntityBlockStorage.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/block/EntityBlockStorage.java
++++ b/src/main/java/org/bukkit/block/EntityBlockStorage.java
+@@ -0,0 +0,0 @@ public interface EntityBlockStorage<T extends Entity> extends TileState {
+      * @param entity Entity to add to the block
+      */
+     void addEntity(@NotNull T entity);
++
++    // Paper start - Add EntityBlockStorage clearEntities
++    /**
++     * Clear all currently stored entities in the block.
++     */
++    void clearEntities();
++    // Paper end
+ }

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

@@ -0,0 +1,262 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 18 Mar 2022 21:16:38 -0700
+Subject: [PATCH] Add EntityDyeEvent and CollarColorable interface
+
+
+diff --git a/src/main/java/io/papermc/paper/entity/CollarColorable.java b/src/main/java/io/papermc/paper/entity/CollarColorable.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/entity/CollarColorable.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.entity;
++
++import org.bukkit.DyeColor;
++import org.bukkit.entity.LivingEntity;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Entities that can have their collars colored.
++ */
++public interface CollarColorable extends LivingEntity {
++
++    /**
++     * Get the collar color of this entity
++     *
++     * @return the color of the collar
++     */
++    @NotNull DyeColor getCollarColor();
++
++    /**
++     * Set the collar color of this entity
++     *
++     * @param color the color to apply
++     */
++    void setCollarColor(@NotNull DyeColor color);
++}
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityDyeEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityDyeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityDyeEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import org.bukkit.DyeColor;
++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.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.
++ */
++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;
++
++    public EntityDyeEvent(@NotNull Entity entity, @NotNull DyeColor dyeColor, @Nullable Player player) {
++        super(entity);
++        this.dyeColor = dyeColor;
++        this.player = player;
++    }
++
++    /**
++     * Gets the DyeColor the entity is being dyed
++     *
++     * @return the DyeColor the entity is being dyed
++     */
++    public @NotNull DyeColor getColor() {
++        return this.dyeColor;
++    }
++
++    /**
++     * Sets the DyeColor the entity is being dyed
++     *
++     * @param dyeColor the DyeColor the entity will be dyed
++     */
++    public void setColor(@NotNull DyeColor dyeColor) {
++        this.dyeColor = dyeColor;
++    }
++
++    /**
++     * Returns the player dyeing the entity, if available.
++     *
++     * @return player or null
++     */
++    public @Nullable Player getPlayer() {
++        return player;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancel;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public static @NotNull HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}
+diff --git a/src/main/java/org/bukkit/entity/Cat.java b/src/main/java/org/bukkit/entity/Cat.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Cat.java
++++ b/src/main/java/org/bukkit/entity/Cat.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
+ /**
+  * Meow.
+  */
+-public interface Cat extends Tameable, Sittable {
++public interface Cat extends Tameable, Sittable, io.papermc.paper.entity.CollarColorable { // Paper - CollarColorable
+ 
+     /**
+      * Gets the current type of this cat.
+@@ -0,0 +0,0 @@ public interface Cat extends Tameable, Sittable {
+      * @return the color of the collar
+      */
+     @NotNull
++    @Override // Paper
+     public DyeColor getCollarColor();
+ 
+     /**
+@@ -0,0 +0,0 @@ public interface Cat extends Tameable, Sittable {
+      *
+      * @param color the color to apply
+      */
++    @Override // Paper
+     public void setCollarColor(@NotNull DyeColor color);
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/entity/Wolf.java b/src/main/java/org/bukkit/entity/Wolf.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Wolf.java
++++ b/src/main/java/org/bukkit/entity/Wolf.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
+ /**
+  * Represents a Wolf
+  */
+-public interface Wolf extends Tameable, Sittable {
++public interface Wolf extends Tameable, Sittable, io.papermc.paper.entity.CollarColorable { // Paper - CollarColorable
+ 
+     /**
+      * Checks if this wolf is angry
+@@ -0,0 +0,0 @@ public interface Wolf extends Tameable, Sittable {
+      * @return the color of the collar
+      */
+     @NotNull
++    @Override // Paper
+     public DyeColor getCollarColor();
+ 
+     /**
+@@ -0,0 +0,0 @@ public interface Wolf extends Tameable, Sittable {
+      *
+      * @param color the color to apply
+      */
++    @Override // Paper
+     public void setCollarColor(@NotNull DyeColor color);
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/event/entity/SheepDyeWoolEvent.java b/src/main/java/org/bukkit/event/entity/SheepDyeWoolEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/entity/SheepDyeWoolEvent.java
++++ b/src/main/java/org/bukkit/event/entity/SheepDyeWoolEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Called when a sheep's wool is dyed
+  */
+-public class SheepDyeWoolEvent extends EntityEvent implements Cancellable {
+-    private static final HandlerList handlers = new HandlerList();
+-    private boolean cancel;
+-    private DyeColor color;
+-    private final Player player;
++public class SheepDyeWoolEvent extends io.papermc.paper.event.entity.EntityDyeEvent implements Cancellable {
++    // Paper - move everything to superclass
+ 
+     @Deprecated
+     public SheepDyeWoolEvent(@NotNull final Sheep sheep, @NotNull final DyeColor color) {
+@@ -0,0 +0,0 @@ public class SheepDyeWoolEvent extends EntityEvent implements Cancellable {
+     }
+ 
+     public SheepDyeWoolEvent(@NotNull final Sheep sheep, @NotNull final DyeColor color, @Nullable Player player) {
+-        super(sheep);
+-        this.cancel = false;
+-        this.color = color;
+-        this.player = player;
+-    }
+-
+-    @Override
+-    public boolean isCancelled() {
+-        return cancel;
+-    }
+-
+-    @Override
+-    public void setCancelled(boolean cancel) {
+-        this.cancel = cancel;
++        super(sheep, color, player); // Paper
+     }
+ 
+     @NotNull
+@@ -0,0 +0,0 @@ public class SheepDyeWoolEvent extends EntityEvent implements Cancellable {
+     public Sheep getEntity() {
+         return (Sheep) entity;
+     }
+-
+-    /**
+-     * Returns the player dyeing the sheep, if available.
+-     *
+-     * @return player or null
+-     */
+-    @Nullable
+-    public Player getPlayer() {
+-        return player;
+-    }
+-
+-    /**
+-     * Gets the DyeColor the sheep is being dyed
+-     *
+-     * @return the DyeColor the sheep is being dyed
+-     */
+-    @NotNull
+-    public DyeColor getColor() {
+-        return color;
+-    }
+-
+-    /**
+-     * Sets the DyeColor the sheep is being dyed
+-     *
+-     * @param color the DyeColor the sheep will be dyed
+-     */
+-    public void setColor(@NotNull DyeColor color) {
+-        this.color = color;
+-    }
+-
+-    @NotNull
+-    @Override
+-    public HandlerList getHandlers() {
+-        return handlers;
+-    }
+-
+-    @NotNull
+-    public static HandlerList getHandlerList() {
+-        return handlers;
+-    }
+-
+ }

patches/unapplied/api/Add-EntityFertilizeEggEvent.patch

@@ -0,0 +1,140 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Fri, 24 Jun 2022 11:56:32 +0200
+Subject: [PATCH] Add EntityFertilizeEggEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityFertilizeEggEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityFertilizeEggEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityFertilizeEggEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import com.google.common.base.Preconditions;
++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.EntityEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when a mating occurs that results in a pregnancy.
++ * After a bit of time, the mother will lay an egg.
++ */
++public class EntityFertilizeEggEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final LivingEntity mother;
++    private final LivingEntity father;
++    private final Player breeder;
++    private final ItemStack bredWith;
++    private int experience;
++
++    private boolean cancel;
++
++    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;
++        this.bredWith = bredWith;
++        this.experience = experience;
++    }
++
++    @NotNull
++    @Override
++    public LivingEntity getEntity() {
++        return (LivingEntity) entity;
++    }
++
++    /**
++     * Gets the parent creating this entity.
++     *
++     * @return The "birth" parent
++     */
++    @NotNull
++    public LivingEntity getMother() {
++        return mother;
++    }
++
++    /**
++     * Gets the other parent of the newly born entity.
++     *
++     * @return the other parent
++     */
++    @NotNull
++    public LivingEntity getFather() {
++        return father;
++    }
++
++    /**
++     * Gets the Entity responsible for fertilization. Breeder is null for spontaneous
++     * conception.
++     *
++     * @return The Entity who initiated breeding.
++     */
++    @Nullable
++    public Player getBreeder() {
++        return breeder;
++    }
++
++    /**
++     * The ItemStack that was used to initiate fertilization, if present.
++     *
++     * @return ItemStack used to initiate breeding.
++     */
++    @Nullable
++    public ItemStack getBredWith() {
++        return bredWith;
++    }
++
++    /**
++     * Get the amount of experience granted by fertilization.
++     *
++     * @return experience amount
++     */
++    public int getExperience() {
++        return experience;
++    }
++
++    /**
++     * Set the amount of experience granted by fertilization.
++     * If the amount is negative or zero, no experience will be dropped.
++     *
++     * @param experience experience amount
++     */
++    public void setExperience(int experience) {
++        this.experience = experience;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancel;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}

patches/unapplied/api/Add-EntityInsideBlockEvent.patch

@@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 8 May 2021 18:02:06 -0700
+Subject: [PATCH] Add EntityInsideBlockEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityInsideBlockEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityInsideBlockEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityInsideBlockEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import org.bukkit.block.Block;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when an entity enters the hitbox of a block.
++ * Only called for blocks that react when an entity is inside.
++ * If cancelled, any action that would have resulted from that entity
++ * being in the block will not happen (such as extinguishing an entity in a cauldron).
++ * <p>
++ * Blocks this is currently called for:
++ * <ul>
++ *     <li>Big dripleaf</li>
++ *     <li>Bubble column</li>
++ *     <li>Buttons</li>
++ *     <li>Cactus</li>
++ *     <li>Campfire</li>
++ *     <li>Cauldron</li>
++ *     <li>Crops</li>
++ *     <li>Ender Portal</li>
++ *     <li>Fires</li>
++ *     <li>Frogspawn</li>
++ *     <li>Honey</li>
++ *     <li>Hopper</li>
++ *     <li>Detector rails</li>
++ *     <li>Nether portals</li>
++ *     <li>Powdered snow</li>
++ *     <li>Pressure plates</li>
++ *     <li>Sweet berry bush</li>
++ *     <li>Tripwire</li>
++ *     <li>Waterlily</li>
++ *     <li>Web</li>
++ *     <li>Wither rose</li>
++ * </ul>
++ */
++public class EntityInsideBlockEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Block block;
++    private boolean cancelled;
++
++    public EntityInsideBlockEvent(@NotNull Entity entity, @NotNull Block block) {
++        super(entity);
++        this.block = block;
++    }
++
++    /**
++     * Gets the block.
++     *
++     * @return the block
++     */
++    @NotNull
++    public Block getBlock() {
++        return block;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return 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/unapplied/api/Add-EntityKnockbackByEntityEvent-and-EntityPushedByE.patch

@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Mon, 18 Jun 2018 15:40:39 +0200
+Subject: [PATCH] Add EntityKnockbackByEntityEvent and
+ EntityPushedByEntityAttackEvent
+
+Co-authored-by: aerulion <aerulion@gmail.com>
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import io.papermc.paper.event.entity.EntityPushedByEntityAttackEvent;
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.LivingEntity;
++import org.bukkit.util.Vector;
++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;
++
++    public EntityKnockbackByEntityEvent(@NotNull LivingEntity entity, @NotNull Entity hitBy, float knockbackStrength, @NotNull Vector acceleration) {
++        super(entity, hitBy, acceleration);
++        this.knockbackStrength = knockbackStrength;
++    }
++
++    /**
++     * @return the entity which was knocked back
++     */
++    @NotNull
++    @Override
++    public LivingEntity getEntity() {
++        return (LivingEntity) super.getEntity();
++    }
++
++    /**
++     * @return the original knockback strength.
++     */
++    public float getKnockbackStrength() {
++        return knockbackStrength;
++    }
++
++    /**
++     * @return the Entity which hit
++     */
++    @NotNull
++    public Entity getHitBy() {
++        return super.getPushedBy();
++    }
++
++}
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityPushedByEntityAttackEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityPushedByEntityAttackEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityPushedByEntityAttackEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.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.util.Vector;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Fired when an entity is pushed by another entity's attack. The acceleration vector can be
++ * modified. If this event is cancelled, the entity will not get pushed.
++ * <p>
++ * Note: Some entities might trigger this multiple times on the same entity
++ * as multiple acceleration calculations are done.
++ */
++public class EntityPushedByEntityAttackEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList handlers = new HandlerList();
++
++    private final @NotNull Entity pushedBy;
++    private final @NotNull Vector acceleration;
++    private boolean cancelled = false;
++
++    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.
++     *
++     * @return the pushing entity
++     */
++    @NotNull
++    public Entity getPushedBy() {
++        return pushedBy;
++    }
++
++    /**
++     * Gets the acceleration that will be applied to the affected entity.
++     *
++     * @return the acceleration vector
++     */
++    @NotNull
++    public Vector getAcceleration() {
++        return acceleration;
++    }
++}

patches/unapplied/api/Add-EntityLoadCrossbowEvent.patch

@@ -0,0 +1,109 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Wed, 7 Oct 2020 12:04:17 -0400
+Subject: [PATCH] Add EntityLoadCrossbowEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityLoadCrossbowEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityLoadCrossbowEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityLoadCrossbowEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++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.EntityEvent;
++import org.bukkit.inventory.EquipmentSlot;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when a LivingEntity loads a crossbow with a projectile.
++ */
++public class EntityLoadCrossbowEvent extends EntityEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private final ItemStack crossbow;
++    private final EquipmentSlot hand;
++    private boolean cancelled;
++    private boolean consumeItem = true;
++
++    public EntityLoadCrossbowEvent(@NotNull LivingEntity entity, @Nullable ItemStack crossbow, @NotNull EquipmentSlot hand) {
++        super(entity);
++        this.crossbow = crossbow;
++        this.hand = hand;
++    }
++
++    @NotNull
++    @Override
++    public LivingEntity getEntity() {
++        return (LivingEntity) entity;
++    }
++
++    /**
++     * Gets the crossbow {@link ItemStack} being loaded.
++     *
++     * @return the crossbow involved in this event
++     */
++    @Nullable
++    public ItemStack getCrossbow() {
++        return crossbow;
++    }
++
++    /**
++     * Gets the hand from which the crossbow was loaded.
++     *
++     * @return the hand
++     */
++    @NotNull
++    public EquipmentSlot getHand() {
++        return hand;
++    }
++
++    /**
++     *
++     * @return should the itemstack be consumed
++     */
++    public boolean shouldConsumeItem() {
++        return consumeItem;
++    }
++
++    /**
++     *
++     * @param consume should the item be consumed
++     */
++    public void setConsumeItem(boolean consume) {
++        this.consumeItem = consume;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    /**
++     * Set whether or not 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) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-EntityPortalReadyEvent.patch

@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 12 May 2021 04:30:53 -0700
+Subject: [PATCH] Add EntityPortalReadyEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/EntityPortalReadyEvent.java b/src/main/java/io/papermc/paper/event/entity/EntityPortalReadyEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/EntityPortalReadyEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import org.bukkit.PortalType;
++import org.bukkit.World;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when an entity is ready to be teleported by a plugin.
++ * Currently this is only called after the required
++ * ticks have passed for a Nether Portal.
++ * <p>
++ * Cancelling this event resets the entity's readiness
++ * regarding the current portal.
++ */
++public class EntityPortalReadyEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private World targetWorld;
++    private final PortalType portalType;
++    private boolean cancelled;
++
++    public EntityPortalReadyEvent(final @NotNull Entity entity, final @Nullable World targetWorld, final @NotNull PortalType portalType) {
++        super(entity);
++        this.targetWorld = targetWorld;
++        this.portalType = portalType;
++    }
++
++    /**
++     * Gets the world this portal will teleport to.
++     * Can be 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}.
++     *
++     * @return the world the portal will teleport the entity to.
++     */
++    public @Nullable World getTargetWorld() {
++        return targetWorld;
++    }
++
++    /**
++     * Sets the world this portal will teleport to. A null value
++     * will essentially cancel the teleport and prevent further events
++     * such as {@link org.bukkit.event.player.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}.
++     *
++     * @param targetWorld the world
++     */
++    public void setTargetWorld(final @Nullable World targetWorld) {
++        this.targetWorld = targetWorld;
++    }
++
++    /**
++     * Gets the portal type for this event.
++     *
++     * @return the portal type
++     */
++    public @NotNull PortalType getPortalType() {
++        return portalType;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(final boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    public static @NotNull HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}

patches/unapplied/api/Add-EntityTeleportEndGatewayEvent.patch

@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sat, 9 Jun 2018 13:08:21 +0100
+Subject: [PATCH] Add EntityTeleportEndGatewayEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityTeleportEndGatewayEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityTeleportEndGatewayEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityTeleportEndGatewayEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.Location;
++import org.bukkit.block.EndGateway;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.entity.EntityTeleportEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Fired any time an entity attempts to teleport in an end gateway
++ */
++public class EntityTeleportEndGatewayEvent extends EntityTeleportEvent {
++
++    @NotNull private final EndGateway gateway;
++
++    public EntityTeleportEndGatewayEvent(@NotNull Entity what, @NotNull Location from, @NotNull Location to, @NotNull EndGateway gateway) {
++        super(what, from, to);
++        this.gateway = gateway;
++    }
++
++    /**
++     * The gateway triggering the teleport
++     *
++     * @return EndGateway used
++     */
++    @NotNull
++    public EndGateway getGateway() {
++        return gateway;
++    }
++
++}

patches/unapplied/api/Add-EntityZapEvent.patch

@@ -0,0 +1,122 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaBlend <whizkid3000@hotmail.com>
+Date: Sun, 16 Oct 2016 23:19:34 -0700
+Subject: [PATCH] Add EntityZapEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityZapEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityZapEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityZapEvent.java
+@@ -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;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityTransformEvent;
++
++import java.util.Collections;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ *  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;
++
++    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;
++    }
++
++    /**
++     * Gets the entity that will replace the struck entity.
++     * @return The entity that will replace the struck entity
++     */
++    @NotNull
++    public Entity getReplacementEntity() {
++        return getTransformedEntity();
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+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();
+     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);
+         this.bolt = bolt;
+         this.pigzombie = pigzombie;
+     }
+@@ -0,0 +0,0 @@ public class PigZapEvent extends EntityTransformEvent implements Cancellable {
+         return pigzombie;
+     }
+ 
++    // Paper start
++    /*
+     @NotNull
+     @Override
+     public HandlerList getHandlers() {
+@@ -0,0 +0,0 @@ public class PigZapEvent extends EntityTransformEvent implements Cancellable {
+     public static HandlerList getHandlerList() {
+         return handlers;
+     }
++    */
++    // Paper end
+ }

patches/unapplied/api/Add-EquipmentSlot-convenience-methods.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Sun, 16 Oct 2022 15:28:49 +0300
+Subject: [PATCH] Add EquipmentSlot convenience methods
+
+
+diff --git a/src/main/java/org/bukkit/inventory/EquipmentSlot.java b/src/main/java/org/bukkit/inventory/EquipmentSlot.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/EquipmentSlot.java
++++ b/src/main/java/org/bukkit/inventory/EquipmentSlot.java
+@@ -0,0 +0,0 @@ public enum EquipmentSlot {
+     LEGS,
+     CHEST,
+     HEAD
++    // Paper start
++    ;
++    /**
++     * Checks whether this equipment slot is a hand:
++     * either {@link #HAND} or {@link #OFF_HAND}
++     *
++     * @return whether this is a hand slot
++     */
++    public boolean isHand() {
++        return this == HAND || this == OFF_HAND;
++    }
++
++    /**
++     * Checks whether this equipment slot
++     * is one of the armor slots:
++     * {@link #HEAD}, {@link #CHEST},
++     * {@link #LEGS}, or {@link #FEET}
++     *
++     * @return whether this is an armor slot
++     */
++    public boolean isArmor() {
++        return this == HEAD || this == CHEST || this == LEGS || this == FEET;
++    }
++    // Paper end
+ }

patches/unapplied/api/Add-FastUtil-to-Bukkit.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 1 Apr 2016 00:02:47 -0400
+Subject: [PATCH] Add FastUtil to Bukkit
+
+Doesn't expose to plugins, just allows Paper-API to use it for optimization
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -0,0 +0,0 @@ dependencies {
+     api("com.googlecode.json-simple:json-simple:1.1.1") {
+         isTransitive = false // includes junit
+     }
++    api("it.unimi.dsi:fastutil:8.5.6")
+     // Paper end
+ 
+     compileOnly("org.apache.maven:maven-resolver-provider:3.8.5")

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

@@ -0,0 +1,424 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Sun, 17 Mar 2019 21:46:27 +0200
+Subject: [PATCH] Add GS4 Query event
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/server/GS4QueryEvent.java b/src/main/java/com/destroystokyo/paper/event/server/GS4QueryEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/server/GS4QueryEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.server;
++
++import com.google.common.base.Preconditions;
++import com.google.common.collect.ImmutableList;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++import java.net.InetAddress;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.Collection;
++import java.util.List;
++
++/**
++ * This event is fired if server is getting queried over GS4 Query protocol
++ *
++ * Adapted from Velocity's ProxyQueryEvent
++ *
++ * @author Mark Vainomaa
++ */
++public final class GS4QueryEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++
++    private final QueryType queryType;
++    private final InetAddress querierAddress;
++    private QueryResponse response;
++
++    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");
++    }
++
++    /**
++     * Get query type
++     * @return query type
++     */
++    @NotNull
++    public QueryType getQueryType() {
++        return queryType;
++    }
++
++    /**
++     * Get querier address
++     * @return querier address
++     */
++    @NotNull
++    public InetAddress getQuerierAddress() {
++        return querierAddress;
++    }
++
++    /**
++     * Get query response
++     * @return query response
++     */
++    @NotNull
++    public QueryResponse getResponse() {
++        return 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;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++    /**
++     * The type of query
++     */
++    public enum QueryType {
++        /**
++         * Basic query asks only a subset of information, such as motd, game type (hardcoded to <pre>MINECRAFT</pre>), map,
++         * current players, max players, server port and server motd
++         */
++        BASIC,
++
++        /**
++         * 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;
++        private final int currentPlayers;
++        private final int maxPlayers;
++        private final String hostname;
++        private final int port;
++        private final Collection<String> players;
++        private final String serverVersion;
++        private final Collection<PluginInformation> plugins;
++
++        private QueryResponse(String motd, String gameVersion, String map, int currentPlayers, int maxPlayers, String hostname, int port, Collection<String> players, String serverVersion, Collection<PluginInformation> plugins) {
++            this.motd = motd;
++            this.gameVersion = gameVersion;
++            this.map = map;
++            this.currentPlayers = currentPlayers;
++            this.maxPlayers = maxPlayers;
++            this.hostname = hostname;
++            this.port = port;
++            this.players = players;
++            this.serverVersion = serverVersion;
++            this.plugins = plugins;
++        }
++
++        /**
++         * Get motd which will be used to reply to the query. By default it is {@link org.bukkit.Server#getMotd()}.
++         * @return motd
++         */
++        @NotNull
++        public String getMotd() {
++            return 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;
++        }
++
++        /**
++         * 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;
++        }
++
++        /**
++         * Get current online player count which will be used to reply to the query.
++         * @return online player count
++         */
++        public int getCurrentPlayers() {
++            return currentPlayers;
++        }
++
++        /**
++         * Get max player count which will be used to reply to the query.
++         * @return max player count
++         */
++        public int getMaxPlayers() {
++            return maxPlayers;
++        }
++
++        /**
++         * Get server (public facing) hostname
++         * @return server hostname
++         */
++        @NotNull
++        public String getHostname() {
++            return hostname;
++        }
++
++        /**
++         * Get server (public facing) port
++         * @return server port
++         */
++        public int getPort() {
++            return 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;
++        }
++
++        /**
++         * Get server software (name and version) which will be used to reply to the query.
++         * @return server software
++         */
++        @NotNull
++        public String getServerVersion() {
++            return 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;
++        }
++
++
++        /**
++         * Creates a new {@link Builder} instance from data represented by this response
++         * @return {@link QueryResponse} builder
++         */
++        @NotNull
++        public Builder toBuilder() {
++            return QueryResponse.builder()
++                .motd(getMotd())
++                .gameVersion(getGameVersion())
++                .map(getMap())
++                .currentPlayers(getCurrentPlayers())
++                .maxPlayers(getMaxPlayers())
++                .hostname(getHostname())
++                .port(getPort())
++                .players(getPlayers())
++                .serverVersion(getServerVersion())
++                .plugins(getPlugins());
++        }
++
++        /**
++         * Creates a new {@link Builder} instance
++         * @return {@link QueryResponse} builder
++         */
++        @NotNull
++        public static Builder builder() {
++            return new Builder();
++        }
++
++        /**
++         * A builder for {@link QueryResponse} objects.
++         */
++        public static final class Builder {
++            private String motd;
++            private String gameVersion;
++            private String map;
++            private String hostname;
++            private String serverVersion;
++
++            private int currentPlayers;
++            private int maxPlayers;
++            private int port;
++
++            private List<String> players = new ArrayList<>();
++            private List<PluginInformation> plugins = new ArrayList<>();
++
++            private Builder() {}
++
++            @NotNull
++            public Builder motd(@NotNull String motd) {
++                this.motd = Preconditions.checkNotNull(motd, "motd");
++                return this;
++            }
++
++            @NotNull
++            public Builder gameVersion(@NotNull String gameVersion) {
++                this.gameVersion = Preconditions.checkNotNull(gameVersion, "gameVersion");
++                return this;
++            }
++
++            @NotNull
++            public Builder map(@NotNull String map) {
++                this.map = Preconditions.checkNotNull(map, "map");
++                return this;
++            }
++
++            @NotNull
++            public Builder currentPlayers(int currentPlayers) {
++                Preconditions.checkArgument(currentPlayers >= 0, "currentPlayers cannot be negative");
++                this.currentPlayers = currentPlayers;
++                return this;
++            }
++
++            @NotNull
++            public Builder maxPlayers(int maxPlayers) {
++                Preconditions.checkArgument(maxPlayers >= 0, "maxPlayers cannot be negative");
++                this.maxPlayers = maxPlayers;
++                return this;
++            }
++
++            @NotNull
++            public Builder hostname(@NotNull String hostname) {
++                this.hostname = Preconditions.checkNotNull(hostname, "hostname");
++                return this;
++            }
++
++            @NotNull
++            public Builder port(int port) {
++                Preconditions.checkArgument(port >= 1 && port <= 65535, "port must be between 1-65535");
++                this.port = port;
++                return this;
++            }
++
++            @NotNull
++            public Builder players(@NotNull Collection<String> players) {
++                this.players.addAll(Preconditions.checkNotNull(players, "players"));
++                return this;
++            }
++
++            @NotNull
++            public Builder players(@NotNull String... players) {
++                this.players.addAll(Arrays.asList(Preconditions.checkNotNull(players, "players")));
++                return this;
++            }
++
++            @NotNull
++            public Builder clearPlayers() {
++                this.players.clear();
++                return this;
++            }
++
++            @NotNull
++            public Builder serverVersion(@NotNull String serverVersion) {
++                this.serverVersion = Preconditions.checkNotNull(serverVersion, "serverVersion");
++                return this;
++            }
++
++            @NotNull
++            public Builder plugins(@NotNull Collection<PluginInformation> plugins) {
++                this.plugins.addAll(Preconditions.checkNotNull(plugins, "plugins"));
++                return this;
++            }
++
++            @NotNull
++            public Builder plugins(@NotNull PluginInformation... plugins) {
++                this.plugins.addAll(Arrays.asList(Preconditions.checkNotNull(plugins, "plugins")));
++                return this;
++            }
++
++            @NotNull
++            public Builder clearPlugins() {
++                this.plugins.clear();
++                return this;
++            }
++
++            /**
++             * Builds new {@link QueryResponse} with supplied data
++             * @return response
++             */
++            @NotNull
++            public QueryResponse build() {
++                return new QueryResponse(
++                    Preconditions.checkNotNull(motd, "motd"),
++                    Preconditions.checkNotNull(gameVersion, "gameVersion"),
++                    Preconditions.checkNotNull(map, "map"),
++                    currentPlayers,
++                    maxPlayers,
++                    Preconditions.checkNotNull(hostname, "hostname"),
++                    port,
++                    ImmutableList.copyOf(players),
++                    Preconditions.checkNotNull(serverVersion, "serverVersion"),
++                    ImmutableList.copyOf(plugins)
++                );
++            }
++        }
++
++        /**
++         * Plugin information
++         */
++        public static class PluginInformation {
++            private String name;
++            private String version;
++
++            public PluginInformation(@NotNull String name, @NotNull String version) {
++                this.name = Preconditions.checkNotNull(name, "name");
++                this.version = Preconditions.checkNotNull(version, "version");
++            }
++
++            @NotNull
++            public String getName() {
++                return name;
++            }
++
++            public void setName(@NotNull String name) {
++                this.name = name;
++            }
++
++            public void setVersion(@NotNull String version) {
++                this.version = version;
++            }
++
++            @NotNull
++            public String getVersion() {
++                return version;
++            }
++
++            @NotNull
++            public static PluginInformation of(@NotNull String name, @NotNull String version) {
++                return new PluginInformation(name, version);
++            }
++        }
++    }
++}

patches/unapplied/api/Add-GameEvent-tags.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 18 Dec 2021 10:34:21 -0800
+Subject: [PATCH] Add GameEvent tags
+
+
+diff --git a/src/main/java/org/bukkit/Tag.java b/src/main/java/org/bukkit/Tag.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Tag.java
++++ b/src/main/java/org/bukkit/Tag.java
+@@ -0,0 +0,0 @@ public interface Tag<T extends Keyed> extends Keyed {
+      */
+     @Deprecated(forRemoval = true)
+     Tag<EntityType> SKELETONS = ENTITY_TYPES_SKELETONS;
++
++    String REGISTRY_GAME_EVENTS = "game_events";
++
++    /**
++     * Tag for game events that trigger sculk sensors
++     */
++    Tag<GameEvent> GAME_EVENT_VIBRATIONS = Bukkit.getTag(REGISTRY_GAME_EVENTS, NamespacedKey.minecraft("vibrations"), GameEvent.class);
++
++    /**
++     * Tag for game events that are ignored if the entity is sneaking
++     */
++    Tag<GameEvent> GAME_EVENT_IGNORE_VIBRATIONS_SNEAKING = Bukkit.getTag(REGISTRY_GAME_EVENTS, NamespacedKey.minecraft("ignore_vibrations_sneaking"), GameEvent.class);
+     // Paper end
+ 
+     /**

patches/unapplied/api/Add-Git-information-to-version-command-on-startup.patch

@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Professor Bloodstone <git@bloodstone.dev>
+Date: Sun, 20 Jun 2021 01:48:31 +0200
+Subject: [PATCH] Add Git information to version command/on startup
+
+
+diff --git a/src/main/java/io/papermc/paper/util/JarManifests.java b/src/main/java/io/papermc/paper/util/JarManifests.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/util/JarManifests.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.util;
++
++import java.io.IOException;
++import java.io.InputStream;
++import java.net.URL;
++import java.util.Collections;
++import java.util.Map;
++import java.util.WeakHashMap;
++import java.util.jar.Manifest;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++@ApiStatus.Internal
++public final class JarManifests {
++    private JarManifests() {
++    }
++
++    private static final Map<ClassLoader, Manifest> MANIFESTS = Collections.synchronizedMap(new WeakHashMap<>());
++
++    public static @Nullable Manifest manifest(final @NotNull Class<?> clazz) {
++        return MANIFESTS.computeIfAbsent(clazz.getClassLoader(), classLoader -> {
++            final String classLocation = "/" + clazz.getName().replace(".", "/") + ".class";
++            final URL resource = clazz.getResource(classLocation);
++            if (resource == null) {
++                return null;
++            }
++            final String classFilePath = resource.toString().replace("\\", "/");
++            final String archivePath = classFilePath.substring(0, classFilePath.length() - classLocation.length());
++            try (final InputStream stream = new URL(archivePath + "/META-INF/MANIFEST.MF").openStream()) {
++                return new Manifest(stream);
++            } catch (final IOException ex) {
++                return null;
++            }
++        });
++    }
++}
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -0,0 +0,0 @@ import org.bukkit.util.CachedServerIcon;
+ import org.jetbrains.annotations.Contract;
+ import org.jetbrains.annotations.NotNull;
+ import org.jetbrains.annotations.Nullable;
++import io.papermc.paper.util.JarManifests; // Paper
+ 
+ /**
+  * Represents the Bukkit core, for version and Server singleton handling
+@@ -0,0 +0,0 @@ public final class Bukkit {
+         }
+ 
+         Bukkit.server = server;
+-        server.getLogger().info("This server is running " + getName() + " version " + getVersion() + " (Implementing API version " + getBukkitVersion() + ")");
++        // Paper start - add git information
++        server.getLogger().info(getVersionMessage());
++    }
++    /**
++      * Gets message describing the version server is running.
++      *
++      * @return message describing the version server is running
++      */
++    @NotNull
++    public static String getVersionMessage() {
++        final var manifest = JarManifests.manifest(Bukkit.getServer().getClass());
++        final String gitBranch = manifest == null ? null : manifest.getMainAttributes().getValue("Git-Branch");
++        final String gitCommit = manifest == null ? null : manifest.getMainAttributes().getValue("Git-Commit");
++        String branchMsg = " on " + gitBranch;
++        if ("master".equals(gitBranch) || "main".equals(gitBranch)) {
++            branchMsg = "";  // Don't show branch on main/master
++        }
++        return "This server is running " + getName() + " version " + getVersion() + " (Implementing API version " + getBukkitVersion() + ") (Git: " + gitCommit + branchMsg + ")";
++        // Paper end
+     }
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/command/defaults/VersionCommand.java b/src/main/java/org/bukkit/command/defaults/VersionCommand.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/command/defaults/VersionCommand.java
++++ b/src/main/java/org/bukkit/command/defaults/VersionCommand.java
+@@ -0,0 +0,0 @@ public class VersionCommand extends BukkitCommand {
+     private void setVersionMessage(final @NotNull net.kyori.adventure.text.Component msg) {
+         lastCheck = System.currentTimeMillis();
+         final net.kyori.adventure.text.Component message = net.kyori.adventure.text.TextComponent.ofChildren(
+-            net.kyori.adventure.text.Component.text("This server is running " + Bukkit.getName() + " version " + Bukkit.getVersion() + " (Implementing API version " + Bukkit.getBukkitVersion() + ")", net.kyori.adventure.text.format.NamedTextColor.WHITE),
++            net.kyori.adventure.text.Component.text(Bukkit.getVersionMessage(), net.kyori.adventure.text.format.NamedTextColor.WHITE),
+             net.kyori.adventure.text.Component.newline(),
+             msg
+         );

patches/unapplied/api/Add-Heightmap-API.patch

@@ -0,0 +1,196 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sat, 1 Dec 2018 19:00:36 -0800
+Subject: [PATCH] Add Heightmap API
+
+Changed to use upstream's heightmap API - Machine_Maker
+
+diff --git a/src/main/java/com/destroystokyo/paper/HeightmapType.java b/src/main/java/com/destroystokyo/paper/HeightmapType.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/HeightmapType.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper;
++
++import org.bukkit.*;
++
++/**
++ * Enumeration of different heightmap types maintained by the server. Generally using these maps is much faster
++ * than using an iterative search for a block in a given x, z coordinate.
++ *
++ * @deprecated Upstream has added their own API for using the game heightmaps. See {@link org.bukkit.HeightMap} and the
++ * non-deprecated getHighestBlock methods on World such as {@link org.bukkit.World#getHighestBlockAt(Location, HeightMap)}.
++ */
++@Deprecated
++public enum HeightmapType {
++
++    /**
++     * The highest block used for lighting in the world. Also the block returned by {@link World#getHighestBlockYAt(int, int)}}
++     */
++    LIGHT_BLOCKING,
++
++    /**
++     * References the highest block in the world.
++     */
++    ANY,
++
++    /**
++     * References the highest solid block in a world.
++     */
++    SOLID,
++
++    /**
++     * References the highest solid or liquid block in a world.
++     */
++    SOLID_OR_LIQUID,
++
++    /**
++     * References the highest solid or liquid block in a world, excluding leaves.
++     */
++    SOLID_OR_LIQUID_NO_LEAVES;
++}
+diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Location.java
++++ b/src/main/java/org/bukkit/Location.java
+@@ -0,0 +0,0 @@ public class Location implements Cloneable, ConfigurationSerializable, io.paperm
+         return centerLoc;
+     }
+ 
++    // Paper start - Add heightmap api
++
++    /**
++     * Returns a copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ())
++     * @return A copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ())
++     * @throws NullPointerException if {{@link #getWorld()}} is {@code null}
++     */
++    @NotNull
++    public Location toHighestLocation() {
++        return this.toHighestLocation(HeightMap.WORLD_SURFACE);
++    }
++
++    /**
++     * Returns a copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ(), heightmap)
++     * @param heightmap The heightmap to use for finding the highest y location.
++     * @return A copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ(), heightmap)
++     * @throws NullPointerException if {{@link #getWorld()}} is {@code null}
++     * @throws UnsupportedOperationException if {@link World#getHighestBlockYAt(int, int, com.destroystokyo.paper.HeightmapType)} does not support the specified heightmap
++     * @deprecated Use {@link org.bukkit.Location#toHighestLocation(HeightMap)}
++     */
++    @NotNull
++    @Deprecated
++    public Location toHighestLocation(@NotNull final com.destroystokyo.paper.HeightmapType heightmap) {
++        final Location ret = this.clone();
++        ret.setY(this.getWorld().getHighestBlockYAt(this, heightmap));
++        return ret;
++    }
++
++    /**
++     * Returns a copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ(), heightMap)
++     * @param heightMap The heightmap to use for finding the highest y location.
++     * @return A copy of this location except with y = getWorld().getHighestBlockYAt(this.getBlockX(), this.getBlockZ(), heightMap)
++     */
++    @NotNull
++    public Location toHighestLocation(@NotNull final HeightMap heightMap) {
++        final Location ret = this.clone();
++        ret.setY(this.getWorld().getHighestBlockYAt(this, heightMap));
++        return ret;
++    }
++    // Paper end
++
+     /**
+      * Creates explosion at this location with given power
+      *
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -0,0 +0,0 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     @NotNull
+     public Block getHighestBlockAt(@NotNull Location location);
+ 
++    // Paper start - Add heightmap API
++    /**
++     * Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions.
++     * <p>
++     * <b>implNote:</b> Implementations are recommended to use an iterative search as a fallback before resorting to
++     * throwing an {@code UnsupportedOperationException}.
++     * </p>
++     *
++     * @param x The block's x-coordinate.
++     * @param z The block's z-coordinate.
++     * @param heightmap The specified heightmap to use. See {@link com.destroystokyo.paper.HeightmapType}
++     * @return The highest block's y-coordinate at (x, z) that matches the specified heightmap's conditions.
++     * @throws UnsupportedOperationException If the heightmap type is not supported.
++     * @deprecated Upstream has added support for this, use {@link World#getHighestBlockYAt(int, int, HeightMap)}
++     *
++     * @see com.destroystokyo.paper.HeightmapType
++     */
++    @Deprecated
++    public int getHighestBlockYAt(int x, int z, @NotNull com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException;
++
++    /**
++     * Returns the highest block's y-coordinate at the specified block coordinates that match the specified heightmap's conditions.
++     * Note that the y-coordinate of the specified location is ignored.
++     * <p>
++     * <b>implNote:</b> Implementations are recommended to use an iterative search as a fallback before resorting to
++     * throwing an {@code UnsupportedOperationException}.
++     * </p>
++     *
++     * @param location The specified block coordinates.
++     * @param heightmap The specified heightmap to use. See {@link com.destroystokyo.paper.HeightmapType}
++     * @return The highest block's y-coordinate at {@code location} that matches the specified heightmap's conditions.
++     * @throws UnsupportedOperationException If the heightmap type is not supported.
++     * @deprecated Upstream has added support for this, use {@link World#getHighestBlockYAt(Location, HeightMap)}
++     * @see com.destroystokyo.paper.HeightmapType
++     */
++    @Deprecated
++    default int getHighestBlockYAt(@NotNull Location location, @NotNull com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException {
++        return this.getHighestBlockYAt(location.getBlockX(), location.getBlockZ(), heightmap);
++    }
++
++    /**
++     * Returns the highest {@link Block} at the specified block coordinates that match the specified heightmap's conditions.
++     * <p>
++     * <b>implNote:</b> Implementations are recommended to use an iterative search as a fallback before resorting to
++     * throwing an {@code UnsupportedOperationException}.
++     * </p>
++     * @param x The block's x-coordinate.
++     * @param z The block's z-coordinate.
++     * @param heightmap The specified heightmap to use. See {@link com.destroystokyo.paper.HeightmapType}
++     * @return The highest {@link Block} at (x, z) that matches the specified heightmap's conditions.
++     * @throws UnsupportedOperationException If the heightmap type is not supported.
++     * @deprecated Upstream has added support for this, use {@link World#getHighestBlockAt(int, int, HeightMap)}
++     * @see com.destroystokyo.paper.HeightmapType
++     */
++    @Deprecated
++    @NotNull
++    default Block getHighestBlockAt(int x, int z, @NotNull com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException {
++        return this.getBlockAt(x, this.getHighestBlockYAt(x, z, heightmap), z);
++    }
++
++    /**
++     * Returns the highest {@link Block} at the specified block coordinates that match the specified heightmap's conditions.
++     * Note that the y-coordinate of the specified location is ignored.
++     * <p>
++     * <b>implNote:</b> Implementations are recommended to use an iterative search as a fallback before resorting to
++     * throwing an {@code UnsupportedOperationException}.
++     * </p>
++     * @param location The specified block coordinates.
++     * @param heightmap The specified heightmap to use. See {@link com.destroystokyo.paper.HeightmapType}
++     * @return The highest {@link Block} at {@code location} that matches the specified heightmap's conditions.
++     * @throws UnsupportedOperationException If the heightmap type is not supported.
++     * @deprecated Upstream has added support for this, use {@link World#getHighestBlockAt(Location, HeightMap)}
++     * @see com.destroystokyo.paper.HeightmapType
++     */
++    @Deprecated
++    @NotNull
++    default Block getHighestBlockAt(@NotNull Location location, @NotNull com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException {
++        return this.getHighestBlockAt(location.getBlockX(), location.getBlockZ(), heightmap);
++    }
++    // Paper end
++
+     /**
+      * Gets the highest coordinate corresponding to the {@link HeightMap} at the
+      * given coordinates.

patches/unapplied/api/Add-ItemFactory-getSpawnEgg-API.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Thu, 14 Oct 2021 12:09:28 -0500
+Subject: [PATCH] Add ItemFactory#getSpawnEgg API
+
+
+diff --git a/src/main/java/org/bukkit/inventory/ItemFactory.java b/src/main/java/org/bukkit/inventory/ItemFactory.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/ItemFactory.java
++++ b/src/main/java/org/bukkit/inventory/ItemFactory.java
+@@ -0,0 +0,0 @@ public interface ItemFactory {
+     @NotNull
+     @Deprecated
+     net.md_5.bungee.api.chat.hover.content.Content hoverContentOf(@NotNull org.bukkit.entity.Entity entity, @NotNull net.md_5.bungee.api.chat.BaseComponent[] customName);
++
++    /**
++     * Get a spawn egg ItemStack from an EntityType
++     *
++     * @param type EntityType
++     * @return ItemStack spawner egg
++     */
++    @Nullable
++    ItemStack getSpawnEgg(@Nullable org.bukkit.entity.EntityType type);
+     // Paper end
+ }

patches/unapplied/api/Add-ItemStack-Recipe-API-helper-methods.patch

@@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 28 Jan 2014 19:13:57 -0500
+Subject: [PATCH] Add ItemStack Recipe API helper methods
+
+Allows using ExactChoice Recipes with easier methods
+
+Redirects some of upstream's APIs to these new methods to avoid
+usage of magic values and the deprecated RecipeChoice#getItemStack
+
+diff --git a/src/main/java/org/bukkit/inventory/ShapedRecipe.java b/src/main/java/org/bukkit/inventory/ShapedRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/ShapedRecipe.java
++++ b/src/main/java/org/bukkit/inventory/ShapedRecipe.java
+@@ -0,0 +0,0 @@ public class ShapedRecipe implements Recipe, Keyed {
+         return this;
+     }
+ 
++    // Paper start
++    @NotNull
++    public ShapedRecipe setIngredient(char key, @NotNull ItemStack item) {
++        return setIngredient(key, new RecipeChoice.ExactChoice(item));
++    }
++    // Paper end
++
+     /**
+      * Get a copy of the ingredients map.
+      *
+diff --git a/src/main/java/org/bukkit/inventory/ShapelessRecipe.java b/src/main/java/org/bukkit/inventory/ShapelessRecipe.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/ShapelessRecipe.java
++++ b/src/main/java/org/bukkit/inventory/ShapelessRecipe.java
+@@ -0,0 +0,0 @@ public class ShapelessRecipe implements Recipe, Keyed {
+         return this;
+     }
+ 
++    // Paper start
++    @NotNull
++    public ShapelessRecipe addIngredient(@NotNull ItemStack item) {
++        return addIngredient(item.getAmount(), item);
++    }
++
++    @NotNull
++    public ShapelessRecipe addIngredient(int count, @NotNull ItemStack item) {
++        Preconditions.checkArgument(ingredients.size() + count <= 9, "Shapeless recipes cannot have more than 9 ingredients");
++        while (count-- > 0) {
++            ingredients.add(new RecipeChoice.ExactChoice(item));
++        }
++        return this;
++    }
++
++    @NotNull
++    public ShapelessRecipe removeIngredient(@NotNull ItemStack item) {
++        return removeIngredient(1, item);
++    }
++
++    @NotNull
++    public ShapelessRecipe removeIngredient(int count, @NotNull ItemStack item) {
++        Iterator<RecipeChoice> iterator = ingredients.iterator();
++        while (count > 0 && iterator.hasNext()) {
++            RecipeChoice choice = iterator.next();
++            if (choice.test(item)) {
++                iterator.remove();
++                count--;
++            }
++        }
++        return this;
++    }
++    // Paper end
++
+     /**
+      * Removes an ingredient from the list.
+      *
+@@ -0,0 +0,0 @@ public class ShapelessRecipe implements Recipe, Keyed {
+      */
+     @NotNull
+     public ShapelessRecipe removeIngredient(@NotNull Material ingredient) {
+-        return removeIngredient(ingredient, 0);
++        return removeIngredient(new ItemStack(ingredient)); // Paper - avoid using deprecated methods (magic values; RecipeChoice#getItemStack)
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class ShapelessRecipe implements Recipe, Keyed {
+      */
+     @NotNull
+     public ShapelessRecipe removeIngredient(int count, @NotNull Material ingredient) {
+-        return removeIngredient(count, ingredient, 0);
++        return removeIngredient(count, new ItemStack(ingredient)); // Paper - avoid using deprecated methods (magic values; RecipeChoice#getItemStack)
+     }
+ 
+     /**

patches/unapplied/api/Add-ItemStackRecipeChoice-Draft-API.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 13 Sep 2018 21:39:26 -0400
+Subject: [PATCH] Add ItemStackRecipeChoice Draft API
+
+This is based on Spigots Draft API. This is subject to change
+
+Allows creating recipes that must match isSimilar to full item stack.
+
+diff --git a/src/main/java/com/destroystokyo/paper/inventory/ItemStackRecipeChoice.java b/src/main/java/com/destroystokyo/paper/inventory/ItemStackRecipeChoice.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/inventory/ItemStackRecipeChoice.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.inventory;
++
++import org.bukkit.inventory.ItemStack;
++import org.bukkit.inventory.RecipeChoice;
++
++import java.util.ArrayList;
++import java.util.List;
++
++/**
++ * Allows crafting Items that require full matching itemstacks to complete the recipe for custom items
++ * @deprecated Draft API
++ */
++@Deprecated
++public class ItemStackRecipeChoice implements RecipeChoice {
++
++    protected final List<ItemStack> choices = new ArrayList<>();
++
++    public ItemStackRecipeChoice(ItemStack choices) {
++        this.choices.add(choices);
++    }
++
++    public ItemStackRecipeChoice(List<ItemStack> choices) {
++        this.choices.addAll(choices);
++    }
++
++    @Override
++    public ItemStack getItemStack() {
++        return choices.isEmpty() ? null : choices.get(0);
++    }
++
++    @Override
++    public RecipeChoice clone() {
++        try {
++            ItemStackRecipeChoice clone = (ItemStackRecipeChoice) super.clone();
++            clone.choices.addAll(this.choices);
++            return clone;
++        } catch (CloneNotSupportedException ex) {
++            throw new AssertionError(ex);
++        }
++    }
++
++    @Override
++    public boolean test(ItemStack itemStack) {
++        for (ItemStack stack : choices) {
++            if (stack.isSimilar(itemStack)) {
++                return true;
++            }
++        }
++        return false;
++    }
++}

patches/unapplied/api/Add-LivingEntity-clearActiveItem.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Anrza <andrzejrzeczycki314@gmail.com>
+Date: Wed, 15 Jul 2020 12:07:58 +0200
+Subject: [PATCH] Add LivingEntity#clearActiveItem
+
+
+diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -0,0 +0,0 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+     @NotNull
+     org.bukkit.inventory.ItemStack getActiveItem();
+ 
++    // Paper start
++    /**
++     * Interrupts any ongoing active "usage" or consumption or an item.
++     */
++    void clearActiveItem();
++    // Paper end
++
+     /**
+      * Get's remaining time a player needs to keep hands raised with an item to finish using it.
+      * @return Remaining ticks to use the item

patches/unapplied/api/Add-LivingEntity-getTargetEntity.patch

@@ -0,0 +1,134 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 22 Sep 2018 00:32:53 -0500
+Subject: [PATCH] Add LivingEntity#getTargetEntity
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/TargetEntityInfo.java b/src/main/java/com/destroystokyo/paper/entity/TargetEntityInfo.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/TargetEntityInfo.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.util.Vector;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Represents information about a targeted entity
++ * @deprecated use {@link org.bukkit.util.RayTraceResult}
++ */
++@Deprecated(forRemoval = true)
++public class TargetEntityInfo {
++    private final Entity entity;
++    private final Vector hitVec;
++
++    public TargetEntityInfo(@NotNull Entity entity, @NotNull Vector hitVec) {
++        this.entity = entity;
++        this.hitVec = hitVec;
++    }
++
++    /**
++     * Get the entity that is targeted
++     *
++     * @return Targeted entity
++     */
++    @NotNull
++    public Entity getEntity() {
++        return entity;
++    }
++
++    /**
++     * Get the position the entity is targeted at
++     *
++     * @return Targeted position
++     */
++    @NotNull
++    public Vector getHitVector() {
++        return hitVec;
++    }
++}
+diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -0,0 +0,0 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+     @Deprecated(forRemoval = true)
+     @Nullable
+     public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, @NotNull com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode);
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @return entity being targeted, or null if no entity is targeted
++     */
++    @Nullable
++    public default Entity getTargetEntity(int maxDistance) {
++        return getTargetEntity(maxDistance, false);
++    }
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @param ignoreBlocks true to scan through blocks
++     * @return entity being targeted, or null if no entity is targeted
++     */
++    @Nullable
++    public Entity getTargetEntity(int maxDistance, boolean ignoreBlocks);
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @return TargetEntityInfo about the entity being targeted,
++     *     or null if no entity is targeted
++     * @deprecated use {@link #rayTraceEntities(int)}
++     */
++    @Deprecated(forRemoval = true)
++    @Nullable
++    public default com.destroystokyo.paper.entity.TargetEntityInfo getTargetEntityInfo(int maxDistance) {
++        return getTargetEntityInfo(maxDistance, false);
++    }
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @return RayTraceResult about the entity being targeted,
++     *     or null if no entity is targeted
++     */
++    @Nullable
++    default RayTraceResult rayTraceEntities(int maxDistance) {
++        return this.rayTraceEntities(maxDistance, false);
++    }
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @param ignoreBlocks true to scan through blocks
++     * @return TargetEntityInfo about the entity being targeted,
++     *     or null if no entity is targeted
++     * @deprecated use {@link #rayTraceEntities(int, boolean)}
++     */
++    @Deprecated(forRemoval = true)
++    @Nullable
++    public com.destroystokyo.paper.entity.TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks);
++
++    /**
++     * Gets information about the entity being targeted
++     *
++     * @param maxDistance this is the maximum distance to scan
++     * @param ignoreBlocks true to scan through blocks
++     * @return RayTraceResult about the entity being targeted,
++     *     or null if no entity is targeted
++     */
++    @Nullable
++    RayTraceResult rayTraceEntities(int maxDistance, boolean ignoreBlocks);
+     // Paper end
+ 
+     /**

patches/unapplied/api/Add-LivingEntity-swingHand-EquipmentSlot-convenience.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Tue, 11 Oct 2022 22:35:56 +0300
+Subject: [PATCH] Add LivingEntity#swingHand(EquipmentSlot) convenience method
+
+
+diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/LivingEntity.java
++++ b/src/main/java/org/bukkit/entity/LivingEntity.java
+@@ -0,0 +0,0 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
+      * @param hurtDirection hurt direction
+      */
+     void setHurtDirection(float hurtDirection);
++
++    /**
++     * Makes this entity swing their hand.
++     *
++     * <p>This method does nothing if this entity does not
++     * have an animation for swinging their hand.
++     *
++     * @param hand hand to be swung, either {@link org.bukkit.inventory.EquipmentSlot#HAND} or {@link org.bukkit.inventory.EquipmentSlot#OFF_HAND}
++     * @throws IllegalArgumentException if invalid hand is passed
++     */
++    default void swingHand(@NotNull org.bukkit.inventory.EquipmentSlot hand) {
++        com.google.common.base.Preconditions.checkArgument(hand != null && hand.isHand(), String.format("Expected a valid hand, got \"%s\" instead!", hand));
++        if (hand == org.bukkit.inventory.EquipmentSlot.HAND) {
++            this.swingMainHand();
++        } else {
++            this.swingOffHand();
++        }
++    }
+     // Paper end
+ }

patches/unapplied/api/Add-MetadataStoreBase.removeAll-Plugin.patch

@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 16 Jul 2013 21:26:50 -0400
+Subject: [PATCH] Add MetadataStoreBase.removeAll(Plugin)
+
+So that on reload, metadata will be cleared
+
+diff --git a/src/main/java/org/bukkit/metadata/MetadataStoreBase.java b/src/main/java/org/bukkit/metadata/MetadataStoreBase.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/metadata/MetadataStoreBase.java
++++ b/src/main/java/org/bukkit/metadata/MetadataStoreBase.java
+@@ -0,0 +0,0 @@ import java.util.ArrayList;
+ import java.util.Collection;
+ import java.util.Collections;
+ import java.util.HashMap;
++import java.util.Iterator; // Paper
+ import java.util.List;
+ import java.util.Map;
+ import java.util.WeakHashMap;
+@@ -0,0 +0,0 @@ public abstract class MetadataStoreBase<T> {
+         }
+     }
+ 
++    /**
++     * Removes all metadata in the metadata store that originates from the
++     * given plugin.
++     *
++     * @param owningPlugin the plugin requesting the invalidation.
++     * @throws IllegalArgumentException If plugin is null
++     */
++    public void removeAll(@NotNull Plugin owningPlugin) {
++        Preconditions.checkNotNull(owningPlugin, "Plugin cannot be null");
++        for (Iterator<Map<Plugin, MetadataValue>> iterator = metadataMap.values().iterator(); iterator.hasNext(); ) {
++            Map<Plugin, MetadataValue> values = iterator.next();
++            if (values.containsKey(owningPlugin)) {
++                values.remove(owningPlugin);
++            }
++            if (values.isEmpty()) {
++                iterator.remove();
++            }
++        }
++    }
++
+     /**
+      * Creates a unique name for the object receiving metadata by combining
+      * unique data from the subject with a metadataKey.

patches/unapplied/api/Add-Mob-Goal-API.patch

@@ -0,0 +1,564 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MiniDigger | Martin <admin@minidigger.dev>
+Date: Fri, 3 Jan 2020 16:24:46 +0100
+Subject: [PATCH] Add Mob Goal API
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java b/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity.ai;
++
++import org.jetbrains.annotations.NotNull;
++
++import java.util.EnumSet;
++
++import org.bukkit.entity.Mob;
++
++/**
++ * Represents an AI goal of an entity
++ */
++public interface Goal<T extends Mob> {
++
++    /**
++     * Checks if this goal should be activated
++     *
++     * @return if this goal should be activated
++     */
++    boolean shouldActivate();
++
++    /**
++     * Checks if this goal should stay active, defaults to {@link Goal#shouldActivate()}
++     *
++     * @return if this goal should stay active
++     */
++    default boolean shouldStayActive() {
++        return shouldActivate();
++    }
++
++    /**
++     * Called when this goal gets activated
++     */
++    default void start() {
++    }
++
++    /**
++     * Called when this goal gets stopped
++     */
++    default void stop() {
++    }
++
++    /**
++     * Called each tick the goal is activated
++     */
++    default void tick() {
++    }
++
++    /**
++     * A unique key that identifies this type of goal. Plugins should use their own namespace, not the minecraft
++     * namespace. Additionally, this key also specifies to what mobs this goal can be applied to
++     *
++     * @return the goal key
++     */
++    @NotNull
++    GoalKey<T> getKey();
++
++    /**
++     * Returns a list of all applicable flags for this goal.<br>
++     *
++     * This method is only called on construction.
++     *
++     * @return the subtypes.
++     */
++    @NotNull
++    EnumSet<GoalType> getTypes();
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java b/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity.ai;
++
++import com.google.common.base.Objects;
++
++import org.jetbrains.annotations.NotNull;
++
++import java.util.StringJoiner;
++
++import org.bukkit.NamespacedKey;
++import org.bukkit.entity.Mob;
++
++/**
++ *
++ * Used to identify a Goal. Consists of a {@link NamespacedKey} and the type of mob the goal can be applied to
++ *
++ * @param <T> the type of mob the goal can be applied to
++ */
++public class GoalKey<T extends Mob> {
++
++    private final Class<T> entityClass;
++    private final NamespacedKey namespacedKey;
++
++    private GoalKey(@NotNull Class<T> entityClass, @NotNull NamespacedKey namespacedKey) {
++        this.entityClass = entityClass;
++        this.namespacedKey = namespacedKey;
++    }
++
++    @NotNull
++    public Class<T> getEntityClass() {
++        return entityClass;
++    }
++
++    @NotNull
++    public NamespacedKey getNamespacedKey() {
++        return namespacedKey;
++    }
++
++    @Override
++    public boolean equals(Object o) {
++        if (this == o) return true;
++        if (o == null || getClass() != o.getClass()) return false;
++        GoalKey<?> goalKey = (GoalKey<?>) o;
++        return Objects.equal(entityClass, goalKey.entityClass) &&
++               Objects.equal(namespacedKey, goalKey.namespacedKey);
++    }
++
++    @Override
++    public int hashCode() {
++        return Objects.hashCode(entityClass, namespacedKey);
++    }
++
++    @Override
++    public String toString() {
++        return new StringJoiner(", ", GoalKey.class.getSimpleName() + "[", "]")
++            .add("entityClass=" + entityClass)
++            .add("namespacedKey=" + namespacedKey)
++            .toString();
++    }
++
++    @NotNull
++    public static <A extends Mob> GoalKey<A> of(@NotNull Class<A> entityClass, @NotNull NamespacedKey namespacedKey) {
++        return new GoalKey<>(entityClass, namespacedKey);
++    }
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java b/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity.ai;
++
++/**
++ * Represents the subtype of a goal. Used by minecraft to disable certain types of goals if needed.
++ */
++public enum GoalType {
++
++    MOVE,
++    LOOK,
++    JUMP,
++    TARGET,
++    /**
++     * Used to map vanilla goals, that are a behavior goal but don't have a type set...
++     */
++    UNKNOWN_BEHAVIOR,
++
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity.ai;
++
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.Collection;
++
++import org.bukkit.entity.Mob;
++
++/**
++ * Represents a part of the "brain" of a mob. It tracks all tasks (running or not), allows adding and removing goals
++ */
++public interface MobGoals {
++
++    <T extends Mob> void addGoal(@NotNull T mob, int priority, @NotNull Goal<T> goal);
++
++    <T extends Mob> void removeGoal(@NotNull T mob, @NotNull Goal<T> goal);
++
++    <T extends Mob> void removeAllGoals(@NotNull T mob);
++
++    <T extends Mob> void removeAllGoals(@NotNull T mob, @NotNull GoalType type);
++
++    <T extends Mob> void removeGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    <T extends Mob> boolean hasGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @Nullable
++    <T extends Mob> Goal<T> getGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getGoals(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoals(@NotNull T mob);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoals(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoalsWithout(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoals(@NotNull T mob);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoals(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoalsWithout(@NotNull T mob, @NotNull GoalType type);
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java b/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.entity.ai;
++
++import com.destroystokyo.paper.entity.RangedEntity;
++
++import org.bukkit.NamespacedKey;
++import org.bukkit.entity.*;
++
++/**
++ * Represents a vanilla goal. Plugins should never implement this.<br>
++ * Generated by VanillaPathfinderTest in paper-server
++ */
++public interface VanillaGoal<T extends Mob> extends Goal<T> {
++
++    GoalKey<Creature> AVOID_ENTITY = GoalKey.of(Creature.class, NamespacedKey.minecraft("avoid_entity"));
++    GoalKey<Wolf> BEG = GoalKey.of(Wolf.class, NamespacedKey.minecraft("beg"));
++    GoalKey<Mob> BREAK_DOOR = GoalKey.of(Mob.class, NamespacedKey.minecraft("break_door"));
++    GoalKey<Creature> BREATH_AIR = GoalKey.of(Creature.class, NamespacedKey.minecraft("breath_air"));
++    GoalKey<Animals> BREED = GoalKey.of(Animals.class, NamespacedKey.minecraft("breed"));
++    GoalKey<Cat> CAT_LIE_ON_BED = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_lie_on_bed"));
++    GoalKey<Cat> CAT_SIT_ON_BLOCK = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_sit_on_block"));
++    GoalKey<Dolphin> DOLPHIN_JUMP = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_jump"));
++    GoalKey<Mob> EAT_BLOCK = GoalKey.of(Mob.class, NamespacedKey.minecraft("eat_block"));
++    GoalKey<Creature> FLEE_SUN = GoalKey.of(Creature.class, NamespacedKey.minecraft("flee_sun"));
++    GoalKey<Mob> FLOAT = GoalKey.of(Mob.class, NamespacedKey.minecraft("float"));
++    GoalKey<Creature> FOLLOW_BOAT = GoalKey.of(Creature.class, NamespacedKey.minecraft("follow_boat"));
++    GoalKey<Fish> FOLLOW_FLOCK_LEADER = GoalKey.of(Fish.class, NamespacedKey.minecraft("follow_flock_leader"));
++    GoalKey<Mob> FOLLOW_MOB = GoalKey.of(Mob.class, NamespacedKey.minecraft("follow_mob"));
++    GoalKey<Tameable> FOLLOW_OWNER = GoalKey.of(Tameable.class, NamespacedKey.minecraft("follow_owner"));
++    GoalKey<Animals> FOLLOW_PARENT = GoalKey.of(Animals.class, NamespacedKey.minecraft("follow_parent"));
++    GoalKey<Creature> GOLEM_RANDOM_STROLL_IN_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("golem_random_stroll_in_village"));
++    GoalKey<Mob> INTERACT = GoalKey.of(Mob.class, NamespacedKey.minecraft("interact"));
++    GoalKey<Parrot> LAND_ON_OWNERS_SHOULDER = GoalKey.of(Parrot.class, NamespacedKey.minecraft("land_on_owners_shoulder"));
++    GoalKey<Mob> LEAP_AT = GoalKey.of(Mob.class, NamespacedKey.minecraft("leap_at"));
++    GoalKey<Llama> LLAMA_FOLLOW_CARAVAN = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_follow_caravan"));
++    GoalKey<Mob> LOOK_AT_PLAYER = GoalKey.of(Mob.class, NamespacedKey.minecraft("look_at_player"));
++    GoalKey<AbstractVillager> LOOK_AT_TRADING_PLAYER = GoalKey.of(AbstractVillager.class, NamespacedKey.minecraft("look_at_trading_player"));
++    GoalKey<Creature> MELEE_ATTACK = GoalKey.of(Creature.class, NamespacedKey.minecraft("melee_attack"));
++    GoalKey<Creature> MOVE_BACK_TO_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_back_to_village"));
++    GoalKey<Creature> MOVE_THROUGH_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_through_village"));
++    GoalKey<Creature> MOVE_TOWARDS_RESTRICTION = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_towards_restriction"));
++    GoalKey<Creature> MOVE_TOWARDS = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_towards"));
++    GoalKey<Mob> OCELOT_ATTACK = GoalKey.of(Mob.class, NamespacedKey.minecraft("ocelot_attack"));
++    GoalKey<IronGolem> OFFER_FLOWER = GoalKey.of(IronGolem.class, NamespacedKey.minecraft("offer_flower"));
++    GoalKey<Mob> OPEN_DOOR = GoalKey.of(Mob.class, NamespacedKey.minecraft("open_door"));
++    GoalKey<Creature> PANIC = GoalKey.of(Creature.class, NamespacedKey.minecraft("panic"));
++    GoalKey<Raider> PATHFIND_TO_RAID = GoalKey.of(Raider.class, NamespacedKey.minecraft("pathfind_to_raid"));
++    GoalKey<Mob> RANDOM_LOOK_AROUND = GoalKey.of(Mob.class, NamespacedKey.minecraft("random_look_around"));
++    GoalKey<AbstractHorse> RANDOM_STAND = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("random_stand"));
++    GoalKey<Creature> RANDOM_STROLL = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_stroll"));
++    GoalKey<Creature> RANDOM_SWIMMING = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_swimming"));
++    GoalKey<RangedEntity> RANGED_ATTACK = GoalKey.of(RangedEntity.class, NamespacedKey.minecraft("ranged_attack"));
++    GoalKey<Monster> RANGED_BOW_ATTACK = GoalKey.of(Monster.class, NamespacedKey.minecraft("ranged_bow_attack"));
++    GoalKey<Monster> RANGED_CROSSBOW_ATTACK = GoalKey.of(Monster.class, NamespacedKey.minecraft("ranged_crossbow_attack"));
++    GoalKey<Creature> REMOVE_BLOCK = GoalKey.of(Creature.class, NamespacedKey.minecraft("remove_block"));
++    GoalKey<Creature> RESTRICT_SUN = GoalKey.of(Creature.class, NamespacedKey.minecraft("restrict_sun"));
++    GoalKey<AbstractHorse> RUN_AROUND_LIKE_CRAZY = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("run_around_like_crazy"));
++    GoalKey<Tameable> SIT_WHEN_ORDERED_TO = GoalKey.of(Tameable.class, NamespacedKey.minecraft("sit_when_ordered_to"));
++    GoalKey<Creature> STROLL_THROUGH_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("stroll_through_village"));
++    GoalKey<Creeper> SWELL = GoalKey.of(Creeper.class, NamespacedKey.minecraft("swell"));
++    GoalKey<Creature> TEMPT = GoalKey.of(Creature.class, NamespacedKey.minecraft("tempt"));
++    GoalKey<AbstractVillager> TRADE_WITH_PLAYER = GoalKey.of(AbstractVillager.class, NamespacedKey.minecraft("trade_with_player"));
++    GoalKey<Creature> TRY_FIND_WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("try_find_water"));
++    GoalKey<Mob> USE_ITEM = GoalKey.of(Mob.class, NamespacedKey.minecraft("use_item"));
++    GoalKey<Creature> WATER_AVOIDING_RANDOM_FLYING = GoalKey.of(Creature.class, NamespacedKey.minecraft("water_avoiding_random_flying"));
++    GoalKey<Creature> WATER_AVOIDING_RANDOM_STROLL = GoalKey.of(Creature.class, NamespacedKey.minecraft("water_avoiding_random_stroll"));
++    GoalKey<Zombie> ZOMBIE_ATTACK = GoalKey.of(Zombie.class, NamespacedKey.minecraft("zombie_attack"));
++    GoalKey<IronGolem> DEFEND_VILLAGE = GoalKey.of(IronGolem.class, NamespacedKey.minecraft("defend_village"));
++    GoalKey<Creature> HURT_BY = GoalKey.of(Creature.class, NamespacedKey.minecraft("hurt_by"));
++    GoalKey<Mob> NEAREST_ATTACKABLE = GoalKey.of(Mob.class, NamespacedKey.minecraft("nearest_attackable"));
++    GoalKey<Raider> NEAREST_ATTACKABLE_WITCH = GoalKey.of(Raider.class, NamespacedKey.minecraft("nearest_attackable_witch"));
++    GoalKey<Raider> NEAREST_HEALABLE_RAIDER = GoalKey.of(Raider.class, NamespacedKey.minecraft("nearest_healable_raider"));
++    GoalKey<Tameable> NON_TAME_RANDOM = GoalKey.of(Tameable.class, NamespacedKey.minecraft("non_tame_random"));
++    GoalKey<Tameable> OWNER_HURT_BY = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt_by"));
++    GoalKey<Tameable> OWNER_HURT = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt"));
++    GoalKey<Mob> RESET_UNIVERSAL_ANGER = GoalKey.of(Mob.class, NamespacedKey.minecraft("reset_universal_anger"));
++    GoalKey<Fish> FISH_SWIM = GoalKey.of(Fish.class, NamespacedKey.minecraft("fish_swim"));
++    GoalKey<Bee> BEE_ATTACK = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_attack"));
++    GoalKey<Bee> BEE_BECOME_ANGRY = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_become_angry"));
++    GoalKey<Bee> BEE_ENTER_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_enter_hive"));
++    GoalKey<Bee> BEE_GO_TO_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_go_to_hive"));
++    GoalKey<Bee> BEE_GO_TO_KNOWN_FLOWER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_go_to_known_flower"));
++    GoalKey<Bee> BEE_GROW_CROP = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_grow_crop"));
++    GoalKey<Bee> BEE_HURT_BY_OTHER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_hurt_by_other"));
++    GoalKey<Bee> BEE_LOCATE_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_locate_hive"));
++    GoalKey<Bee> BEE_POLLINATE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_pollinate"));
++    GoalKey<Bee> BEE_WANDER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_wander"));
++    GoalKey<Cat> CAT_AVOID_ENTITY = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_avoid_entity"));
++    GoalKey<Cat> CAT_RELAX_ON_OWNER = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_relax_on_owner"));
++    GoalKey<Cat> CAT_TEMPT = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_tempt"));
++    GoalKey<Dolphin> DOLPHIN_SWIM_TO_TREASURE = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_swim_to_treasure"));
++    GoalKey<Dolphin> DOLPHIN_SWIM_WITH_PLAYER = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_swim_with_player"));
++    GoalKey<Dolphin> PLAY_WITH_ITEMS = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("play_with_items"));
++    GoalKey<Fox> DEFEND_TRUSTED = GoalKey.of(Fox.class, NamespacedKey.minecraft("defend_trusted"));
++    GoalKey<Fox> FACEPLANT = GoalKey.of(Fox.class, NamespacedKey.minecraft("faceplant"));
++    GoalKey<Fox> FOX_BREED = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_breed"));
++    GoalKey<Fox> FOX_EAT_BERRIES = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_eat_berries"));
++    GoalKey<Fox> FOX_FLOAT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_float"));
++    GoalKey<Fox> FOX_FOLLOW_PARENT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_follow_parent"));
++    GoalKey<Fox> FOX_LOOK_AT_PLAYER = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_look_at_player"));
++    GoalKey<Fox> FOX_MELEE_ATTACK = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_melee_attack"));
++    GoalKey<Fox> FOX_PANIC = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_panic"));
++    GoalKey<Fox> FOX_POUNCE = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_pounce"));
++    GoalKey<Fox> FOX_SEARCH_FOR_ITEMS = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_search_for_items"));
++    GoalKey<Fox> FOX_STROLL_THROUGH_VILLAGE = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_stroll_through_village"));
++    GoalKey<Fox> PERCH_AND_SEARCH = GoalKey.of(Fox.class, NamespacedKey.minecraft("perch_and_search"));
++    GoalKey<Fox> SEEK_SHELTER = GoalKey.of(Fox.class, NamespacedKey.minecraft("seek_shelter"));
++    GoalKey<Fox> SLEEP = GoalKey.of(Fox.class, NamespacedKey.minecraft("sleep"));
++    GoalKey<Fox> STALK_PREY = GoalKey.of(Fox.class, NamespacedKey.minecraft("stalk_prey"));
++    GoalKey<Ocelot> OCELOT_AVOID_ENTITY = GoalKey.of(Ocelot.class, NamespacedKey.minecraft("ocelot_avoid_entity"));
++    GoalKey<Ocelot> OCELOT_TEMPT = GoalKey.of(Ocelot.class, NamespacedKey.minecraft("ocelot_tempt"));
++    GoalKey<Panda> PANDA_ATTACK = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_attack"));
++    GoalKey<Panda> PANDA_AVOID = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_avoid"));
++    GoalKey<Panda> PANDA_BREED = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_breed"));
++    GoalKey<Panda> PANDA_HURT_BY = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_hurt_by"));
++    GoalKey<Panda> PANDA_LIE_ON_BACK = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_lie_on_back"));
++    GoalKey<Panda> PANDA_LOOK_AT_PLAYER = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_look_at_player"));
++    GoalKey<Panda> PANDA_PANIC = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_panic"));
++    GoalKey<Panda> PANDA_ROLL = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_roll"));
++    GoalKey<Panda> PANDA_SIT = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_sit"));
++    GoalKey<Panda> PANDA_SNEEZE = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_sneeze"));
++    GoalKey<PolarBear> POLAR_BEAR_ATTACK_PLAYERS = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polar_bear_attack_players"));
++    GoalKey<PolarBear> POLAR_BEAR_HURT_BY = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polar_bear_hurt_by"));
++    GoalKey<PolarBear> POLAR_BEAR_MELEE_ATTACK = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polar_bear_melee_attack"));
++    GoalKey<PolarBear> POLAR_BEAR_PANIC = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polar_bear_panic"));
++    GoalKey<PufferFish> PUFFERFISH_PUFF = GoalKey.of(PufferFish.class, NamespacedKey.minecraft("pufferfish_puff"));
++    GoalKey<Rabbit> EVIL_RABBIT_ATTACK = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("evil_rabbit_attack"));
++    GoalKey<Rabbit> RABBIT_AVOID_ENTITY = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("rabbit_avoid_entity"));
++    GoalKey<Rabbit> RABBIT_PANIC = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("rabbit_panic"));
++    GoalKey<Rabbit> RAID_GARDEN = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("raid_garden"));
++    GoalKey<Squid> SQUID_FLEE = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid_flee"));
++    GoalKey<Squid> SQUID_RANDOM_MOVEMENT = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid_random_movement"));
++    GoalKey<Turtle> TURTLE_BREED = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_breed"));
++    GoalKey<Turtle> TURTLE_GO_HOME = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_go_home"));
++    GoalKey<Turtle> TURTLE_GO_TO_WATER = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_go_to_water"));
++    GoalKey<Turtle> TURTLE_LAY_EGG = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_lay_egg"));
++    GoalKey<Turtle> TURTLE_PANIC = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_panic"));
++    GoalKey<Turtle> TURTLE_RANDOM_STROLL = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_random_stroll"));
++    GoalKey<Turtle> TURTLE_TRAVEL = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_travel"));
++    GoalKey<Wolf> WOLF_AVOID_ENTITY = GoalKey.of(Wolf.class, NamespacedKey.minecraft("wolf_avoid_entity"));
++    GoalKey<Llama> LLAMA_ATTACK_WOLF = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_attack_wolf"));
++    GoalKey<Llama> LLAMA_HURT_BY = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_hurt_by"));
++    GoalKey<SkeletonHorse> SKELETON_TRAP = GoalKey.of(SkeletonHorse.class, NamespacedKey.minecraft("skeleton_trap"));
++    GoalKey<Llama> TRADER_LLAMA_DEFEND_WANDERING_TRADER = GoalKey.of(Llama.class, NamespacedKey.minecraft("trader_llama_defend_wandering_trader"));
++    GoalKey<Wither> WITHER_DO_NOTHING = GoalKey.of(Wither.class, NamespacedKey.minecraft("wither_do_nothing"));
++    GoalKey<Illager> RAIDER_OPEN_DOOR = GoalKey.of(Illager.class, NamespacedKey.minecraft("raider_open_door"));
++    GoalKey<AbstractSkeleton> SKELETON_MELEE = GoalKey.of(AbstractSkeleton.class, NamespacedKey.minecraft("abstract_skeleton_melee"));
++    GoalKey<Blaze> BLAZE_ATTACK = GoalKey.of(Blaze.class, NamespacedKey.minecraft("blaze_attack"));
++    GoalKey<Drowned> DROWNED_ATTACK = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_attack"));
++    GoalKey<Drowned> DROWNED_GO_TO_BEACH = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_go_to_beach"));
++    GoalKey<Creature> DROWNED_GO_TO_WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("drowned_go_to_water"));
++    GoalKey<Drowned> DROWNED_SWIM_UP = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_swim_up"));
++    GoalKey<RangedEntity> DROWNED_TRIDENT_ATTACK = GoalKey.of(RangedEntity.class, NamespacedKey.minecraft("drowned_trident_attack"));
++    GoalKey<Enderman> ENDERMAN_FREEZE_WHEN_LOOKED_AT = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_freeze_when_looked_at"));
++    GoalKey<Enderman> ENDERMAN_LEAVE_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_leave_block"));
++    GoalKey<Enderman> ENDERMAN_LOOK_FOR_PLAYER = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_look_for_player"));
++    GoalKey<Enderman> ENDERMAN_TAKE_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_take_block"));
++    GoalKey<Evoker> EVOKER_ATTACK_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_attack_spell"));
++    GoalKey<Evoker> EVOKER_CASTING_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_casting_spell"));
++    GoalKey<Evoker> EVOKER_SUMMON_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_summon_spell"));
++    GoalKey<Evoker> EVOKER_WOLOLO_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_wololo_spell"));
++    GoalKey<Ghast> GHAST_LOOK = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_look"));
++    GoalKey<Ghast> GHAST_SHOOT_FIREBALL = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_shoot_fireball"));
++    GoalKey<Ghast> RANDOM_FLOAT_AROUND = GoalKey.of(Ghast.class, NamespacedKey.minecraft("random_float_around"));
++    GoalKey<Guardian> GUARDIAN_ATTACK = GoalKey.of(Guardian.class, NamespacedKey.minecraft("guardian_attack"));
++    GoalKey<Illusioner> ILLUSIONER_BLINDNESS_SPELL = GoalKey.of(Illusioner.class, NamespacedKey.minecraft("illusioner_blindness_spell"));
++    GoalKey<Illusioner> ILLUSIONER_MIRROR_SPELL = GoalKey.of(Illusioner.class, NamespacedKey.minecraft("illusioner_mirror_spell"));
++    GoalKey<Raider> LONG_DISTANCE_PATROL = GoalKey.of(Raider.class, NamespacedKey.minecraft("long_distance_patrol"));
++    GoalKey<Phantom> PHANTOM_ATTACK_PLAYER = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_attack_player"));
++    GoalKey<Phantom> PHANTOM_ATTACK_STRATEGY = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_attack_strategy"));
++    GoalKey<Phantom> PHANTOM_CIRCLE_AROUND_ANCHOR = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_circle_around_anchor"));
++    GoalKey<Phantom> PHANTOM_SWEEP_ATTACK = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_sweep_attack"));
++    GoalKey<Ravager> RAVAGER_MELEE_ATTACK = GoalKey.of(Ravager.class, NamespacedKey.minecraft("ravager_melee_attack"));
++    GoalKey<Shulker> SHULKER_ATTACK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_attack"));
++    GoalKey<Shulker> SHULKER_DEFENSE_ATTACK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_defense_attack"));
++    GoalKey<Shulker> SHULKER_NEAREST_ATTACK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_nearest_attack"));
++    GoalKey<Shulker> SHULKER_PEEK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_peek"));
++    GoalKey<Silverfish> SILVERFISH_MERGE_WITH_STONE = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_merge_with_stone"));
++    GoalKey<Silverfish> SILVERFISH_WAKE_UP_FRIENDS = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_wake_up_friends"));
++    GoalKey<Slime> SLIME_ATTACK = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_attack"));
++    GoalKey<Slime> SLIME_FLOAT = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_float"));
++    GoalKey<Slime> SLIME_KEEP_ON_JUMPING = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_keep_on_jumping"));
++    GoalKey<Slime> SLIME_RANDOM_DIRECTION = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_random_direction"));
++    GoalKey<Spellcaster> SPELLCASTER_CASTING_SPELL = GoalKey.of(Spellcaster.class, NamespacedKey.minecraft("spellcaster_casting_spell"));
++    GoalKey<Spider> SPIDER_ATTACK = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_attack"));
++    GoalKey<Spider> SPIDER = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider"));
++    GoalKey<Strider> STRIDER_GO_TO_LAVA = GoalKey.of(Strider.class, NamespacedKey.minecraft("strider_go_to_lava"));
++    GoalKey<Vex> VEX_CHARGE_ATTACK = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_charge_attack"));
++    GoalKey<Vex> VEX_COPY_OWNER = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_copy_owner"));
++    GoalKey<Vex> VEX_RANDOM_MOVE = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_random_move"));
++    GoalKey<Mob> VINDICATOR_BREAK_DOOR = GoalKey.of(Mob.class, NamespacedKey.minecraft("vindicator_break_door"));
++    GoalKey<Vindicator> VINDICATOR_JOHNNY_ATTACK = GoalKey.of(Vindicator.class, NamespacedKey.minecraft("vindicator_johnny_attack"));
++    GoalKey<Vindicator> VINDICATOR_MELEE_ATTACK = GoalKey.of(Vindicator.class, NamespacedKey.minecraft("vindicator_melee_attack"));
++    GoalKey<Zombie> ZOMBIE_ATTACK_TURTLE_EGG = GoalKey.of(Zombie.class, NamespacedKey.minecraft("zombie_attack_turtle_egg"));
++    GoalKey<WanderingTrader> WANDER_TO_POSITION = GoalKey.of(WanderingTrader.class, NamespacedKey.minecraft("wander_to_position"));
++    GoalKey<Raider> HOLD_GROUND_ATTACK = GoalKey.of(Raider.class, NamespacedKey.minecraft("hold_ground_attack"));
++    GoalKey<Raider> OBTAIN_RAID_LEADER_BANNER = GoalKey.of(Raider.class, NamespacedKey.minecraft("obtain_raid_leader_banner"));
++    GoalKey<Raider> RAIDER_CELEBRATION = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_celebration"));
++    GoalKey<Raider> RAIDER_MOVE_THROUGH_VILLAGE = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_move_through_village"));
++    GoalKey<Creature> PARROT_WANDER = GoalKey.of(Creature.class, NamespacedKey.minecraft("parrot_wander"));
++    GoalKey<Mob> CLIMB_ON_TOP_OF_POWDER_SNOW = GoalKey.of(Mob.class, NamespacedKey.minecraft("climb_on_top_of_powder_snow"));
++    GoalKey<Wolf> WOLF_PANIC = GoalKey.of(Wolf.class, NamespacedKey.minecraft("wolf_panic"));
++
++    /**
++     * @deprecated removed in 1.16
++     */
++    @Deprecated GoalKey<PigZombie> ANGER = GoalKey.of(PigZombie.class, NamespacedKey.minecraft("anger"));
++    /**
++     * @deprecated removed in 1.16
++     */
++    @Deprecated GoalKey<PigZombie> ANGER_OTHER = GoalKey.of(PigZombie.class, NamespacedKey.minecraft("anger_other"));
++
++    // the constants below use spigot names, they no longer work
++    @Deprecated GoalKey<Blaze> BLAZE_FIREBALL = GoalKey.of(Blaze.class, NamespacedKey.minecraft("blaze_fireball"));
++    @Deprecated GoalKey<Cat> TEMPT_CHANCE = GoalKey.of(Cat.class, NamespacedKey.minecraft("tempt_chance"));
++    @Deprecated GoalKey<Dolphin> DOLPHIN_PLAY_WITH_ITEMS = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_play_with_items"));
++    @Deprecated GoalKey<Drowned> DROWNED_GOTO_BEACH = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_goto_beach"));
++    @Deprecated GoalKey<Creature> DROWNED_GOTO_WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("drowned_goto_water"));
++    @Deprecated GoalKey<Enderman> ENDERMAN_PICKUP_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_pickup_block"));
++    @Deprecated GoalKey<Enderman> ENDERMAN_PLACE_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_place_block"));
++    @Deprecated GoalKey<Enderman> PLAYER_WHO_LOOKED_AT_TARGET = GoalKey.of(Enderman.class, NamespacedKey.minecraft("player_who_looked_at_target"));
++    @Deprecated GoalKey<Evoker> EVOKER_CAST_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_cast_spell"));
++    @Deprecated GoalKey<Fox> FOX_DEFEND_TRUSTED = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_defend_trusted"));
++    @Deprecated GoalKey<Fox> FOX_FACEPLANT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_faceplant"));
++    @Deprecated GoalKey<Fox> FOX_PERCH_AND_SEARCH = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_perch_and_search"));
++    @Deprecated GoalKey<Fox> FOX_SLEEP = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_sleep"));
++    @Deprecated GoalKey<Fox> FOX_SEEK_SHELTER = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_seek_shelter"));
++    @Deprecated GoalKey<Fox> FOX_STALK_PREY = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_stalk_prey"));
++    @Deprecated GoalKey<Ghast> GHAST_ATTACK_TARGET = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_attack_target"));
++    @Deprecated GoalKey<Ghast> GHAST_IDLE_MOVE = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_idle_move"));
++    @Deprecated GoalKey<Ghast> GHAST_MOVE_TOWARDS_TARGET = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_move_towards_target"));
++    @Deprecated GoalKey<Spellcaster> SPELLCASTER_CAST_SPELL = GoalKey.of(Spellcaster.class, NamespacedKey.minecraft("spellcaster_cast_spell"));
++    @Deprecated GoalKey<TraderLlama> LLAMATRADER_DEFENDED_WANDERING_TRADER = GoalKey.of(TraderLlama.class, NamespacedKey.minecraft("llamatrader_defended_wandering_trader"));
++    @Deprecated GoalKey<Panda> PANDA_HURT_BY_TARGET = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_hurt_by_target"));
++    @Deprecated GoalKey<PolarBear> POLARBEAR_ATTACK_PLAYERS = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_attack_players"));
++    @Deprecated GoalKey<PolarBear> POLARBEAR_HURT_BY = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_hurt_by"));
++    @Deprecated GoalKey<PolarBear> POLARBEAR_MELEE = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_melee"));
++    @Deprecated GoalKey<PolarBear> POLARBEAR_PANIC = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_panic"));
++    @Deprecated GoalKey<Rabbit> EAT_CARROTS = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("eat_carrots"));
++    @Deprecated GoalKey<Rabbit> KILLER_RABBIT_MELEE_ATTACK = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("killer_rabbit_melee_attack"));
++    @Deprecated GoalKey<Rabbit> RABBIT_AVOID_TARGET = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("rabbit_avoid_target"));
++    @Deprecated GoalKey<Raider> RAIDER_HOLD_GROUND = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_hold_ground"));
++    @Deprecated GoalKey<Raider> RAIDER_OBTAIN_BANNER = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_obtain_banner"));
++    @Deprecated GoalKey<Shulker> SHULKER_DEFENSE = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_defense"));
++    @Deprecated GoalKey<Shulker> SHULKER_NEAREST = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_nearest"));
++    @Deprecated GoalKey<Silverfish> SILVERFISH_HIDE_IN_BLOCK = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_hide_in_block"));
++    @Deprecated GoalKey<Silverfish> SILVERFISH_WAKE_OTHERS = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_wake_others"));
++    @Deprecated GoalKey<Slime> SLIME_IDLE = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_idle"));
++    @Deprecated GoalKey<Slime> SLIME_NEAREST_PLAYER = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_nearest_player"));
++    @Deprecated GoalKey<Slime> SLIME_RANDOM_JUMP = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_random_jump"));
++    @Deprecated GoalKey<Spider> SPIDER_MELEE_ATTACK = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_melee_attack"));
++    @Deprecated GoalKey<Spider> SPIDER_NEAREST_ATTACKABLE_TARGET = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_nearest_attackable_target"));
++    @Deprecated GoalKey<Squid> SQUID = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid"));
++    @Deprecated GoalKey<Turtle> TURTLE_GOTO_WATER = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_goto_water"));
++    @Deprecated GoalKey<Turtle> TURTLE_TEMPT = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_tempt"));
++    @Deprecated GoalKey<Vex> VEX_COPY_TARGET_OF_OWNER = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_copy_target_of_owner"));
++    @Deprecated GoalKey<WanderingTrader> VILLAGERTRADER_WANDER_TO_POSITION = GoalKey.of(WanderingTrader.class, NamespacedKey.minecraft("villagertrader_wander_to_position"));
++    @Deprecated GoalKey<RangedEntity> ARROW_ATTACK = GoalKey.of(RangedEntity.class, NamespacedKey.minecraft("arrow_attack"));
++    @Deprecated GoalKey<Creature> AVOID_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("avoid_target"));
++    @Deprecated GoalKey<Monster> BOW_SHOOT = GoalKey.of(Monster.class, NamespacedKey.minecraft("bow_shoot"));
++    @Deprecated GoalKey<Creature> BREATH = GoalKey.of(Creature.class, NamespacedKey.minecraft("breath"));
++    @Deprecated GoalKey<Cat> CAT_SIT_ON_BED = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_sit_on_bed"));
++    @Deprecated GoalKey<Monster> CROSSBOW_ATTACK = GoalKey.of(Monster.class, NamespacedKey.minecraft("crossbow_attack"));
++    @Deprecated GoalKey<Mob> DOOR_OPEN = GoalKey.of(Mob.class, NamespacedKey.minecraft("door_open"));
++    @Deprecated GoalKey<Mob> EAT_TILE = GoalKey.of(Mob.class, NamespacedKey.minecraft("eat_tile"));
++    @Deprecated GoalKey<Fish> FISH_SCHOOL = GoalKey.of(Fish.class, NamespacedKey.minecraft("fish_school"));
++    @Deprecated GoalKey<Mob> FOLLOW_ENTITY = GoalKey.of(Mob.class, NamespacedKey.minecraft("follow_entity"));
++    @Deprecated GoalKey<SkeletonHorse> HORSE_TRAP = GoalKey.of(SkeletonHorse.class, NamespacedKey.minecraft("horse_trap"));
++    @Deprecated GoalKey<Creature> HURT_BY_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("hurt_by_target"));
++    @Deprecated GoalKey<Cat> JUMP_ON_BLOCK = GoalKey.of(Cat.class, NamespacedKey.minecraft("jump_on_block"));
++    @Deprecated GoalKey<Mob> LEAP_AT_TARGET = GoalKey.of(Mob.class, NamespacedKey.minecraft("leap_at_target"));
++    @Deprecated GoalKey<Llama> LLAMA_FOLLOW = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_follow"));
++    @Deprecated GoalKey<Creature> MOVE_TOWARDS_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_towards_target"));
++    @Deprecated GoalKey<Mob> NEAREST_ATTACKABLE_TARGET = GoalKey.of(Mob.class, NamespacedKey.minecraft("nearest_attackable_target"));
++    @Deprecated GoalKey<Raider> NEAREST_ATTACKABLE_TARGET_WITCH = GoalKey.of(Raider.class, NamespacedKey.minecraft("nearest_attackable_target_witch"));
++    @Deprecated GoalKey<Creature> NEAREST_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("nearest_village"));
++    @Deprecated GoalKey<Tameable> OWNER_HURT_BY_TARGET = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt_by_target"));
++    @Deprecated GoalKey<Tameable> OWNER_HURT_TARGET = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt_target"));
++    @Deprecated GoalKey<Parrot> PERCH = GoalKey.of(Parrot.class, NamespacedKey.minecraft("perch"));
++    @Deprecated GoalKey<Raider> RAID = GoalKey.of(Raider.class, NamespacedKey.minecraft("raid"));
++    @Deprecated GoalKey<Creature> RANDOM_FLY = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_fly"));
++    @Deprecated GoalKey<Mob> RANDOM_LOOKAROUND = GoalKey.of(Mob.class, NamespacedKey.minecraft("random_lookaround"));
++    @Deprecated GoalKey<Creature> RANDOM_STROLL_LAND = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_stroll_land"));
++    @Deprecated GoalKey<Creature> RANDOM_SWIM = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_swim"));
++    @Deprecated GoalKey<Tameable> RANDOM_TARGET_NON_TAMED = GoalKey.of(Tameable.class, NamespacedKey.minecraft("random_target_non_tamed"));
++    @Deprecated GoalKey<Tameable> SIT = GoalKey.of(Tameable.class, NamespacedKey.minecraft("sit"));
++    @Deprecated GoalKey<Creature> STROLL_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("stroll_village"));
++    @Deprecated GoalKey<AbstractHorse> TAME = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("tame"));
++    @Deprecated GoalKey<Creature> WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("water"));
++    @Deprecated GoalKey<Dolphin> WATER_JUMP = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("water_jump"));
++    @Deprecated GoalKey<Creature> STROLL_VILLAGE_GOLEM = GoalKey.of(Creature.class, NamespacedKey.minecraft("stroll_village_golem"));
++    @Deprecated GoalKey<Mob> UNIVERSAL_ANGER_RESET = GoalKey.of(Mob.class, NamespacedKey.minecraft("universal_anger_reset"));
++}
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -0,0 +0,0 @@ public final class Bukkit {
+     public static boolean isStopping() {
+         return server.isStopping();
+     }
++
++    /**
++     * Returns the {@link com.destroystokyo.paper.entity.ai.MobGoals} manager
++     *
++     * @return the mob goals manager
++     */
++    @NotNull
++    public static com.destroystokyo.paper.entity.ai.MobGoals getMobGoals() {
++        return server.getMobGoals();
++    }
+     // Paper end
+ 
+     @NotNull
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -0,0 +0,0 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+      * @return true if server is in the process of being shutdown
+      */
+     boolean isStopping();
++
++    /**
++     * Returns the {@link com.destroystokyo.paper.entity.ai.MobGoals} manager
++     *
++     * @return the mob goals manager
++     */
++    @NotNull
++    com.destroystokyo.paper.entity.ai.MobGoals getMobGoals();
+     // Paper end
+ }

patches/unapplied/api/Add-Mob-lookAt-API.patch

@@ -0,0 +1,99 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Fri, 14 May 2021 13:42:06 -0500
+Subject: [PATCH] Add Mob#lookAt API
+
+
+diff --git a/src/main/java/org/bukkit/entity/Mob.java b/src/main/java/org/bukkit/entity/Mob.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Mob.java
++++ b/src/main/java/org/bukkit/entity/Mob.java
+@@ -0,0 +0,0 @@ public interface Mob extends LivingEntity, Lootable {
+      * @return True if mob is exposed to daylight
+      */
+     boolean isInDaylight();
++
++    /**
++     * Instruct this Mob to look at a specific Location
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param location location to look at
++     */
++    void lookAt(@NotNull org.bukkit.Location location);
++
++    /**
++     * Instruct this Mob to look at a specific Location
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param location location to look at
++     * @param headRotationSpeed head rotation speed
++     * @param maxHeadPitch max head pitch rotation
++     */
++    void lookAt(@NotNull org.bukkit.Location location, float headRotationSpeed, float maxHeadPitch);
++
++    /**
++     * Instruct this Mob to look at a specific Entity
++     * <p>
++     * If a LivingEntity, look at eye location
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param entity entity to look at
++     */
++    void lookAt(@NotNull Entity entity);
++
++    /**
++     * Instruct this Mob to look at a specific Entity
++     * <p>
++     * If a LivingEntity, look at eye location
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param entity entity to look at
++     * @param headRotationSpeed head rotation speed
++     * @param maxHeadPitch max head pitch rotation
++     */
++    void lookAt(@NotNull Entity entity, float headRotationSpeed, float maxHeadPitch);
++
++    /**
++     * Instruct this Mob to look at a specific position
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param x x coordinate
++     * @param y y coordinate
++     * @param z z coordinate
++     */
++    void lookAt(double x, double y, double z);
++
++    /**
++     * Instruct this Mob to look at a specific position
++     * <p>
++     * Useful when implementing custom mob goals
++     *
++     * @param x x coordinate
++     * @param y y coordinate
++     * @param z z coordinate
++     * @param headRotationSpeed head rotation speed
++     * @param maxHeadPitch max head pitch rotation
++     */
++    void lookAt(double x, double y, double z, float headRotationSpeed, float maxHeadPitch);
++
++    /**
++     * Gets the head rotation speed
++     *
++     * @return the head rotation speed
++     */
++    int getHeadRotationSpeed();
++
++    /**
++     * Gets the max head pitch rotation
++     *
++     * @return the max head pitch rotation
++     */
++    int getMaxHeadPitch();
+     // Paper end
+     /**
+      * Instructs this Mob to set the specified LivingEntity as its target.

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

@@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Aug 2018 11:50:16 -0500
+Subject: [PATCH] Add More Creeper API
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/CreeperIgniteEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/CreeperIgniteEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/CreeperIgniteEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.entity.Creeper;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a Creeper is ignited either by a
++ * flint and steel, {@link Creeper#ignite()} or
++ * {@link Creeper#setIgnited(boolean)}.
++ */
++public class CreeperIgniteEvent extends EntityEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private boolean canceled;
++    private boolean ignited;
++
++    public CreeperIgniteEvent(@NotNull Creeper creeper, boolean ignited) {
++        super(creeper);
++        this.ignited = ignited;
++    }
++
++    @NotNull
++    @Override
++    public Creeper getEntity() {
++        return (Creeper) entity;
++    }
++
++    public boolean isIgnited() {
++        return ignited;
++    }
++
++    public void setIgnited(boolean ignited) {
++        this.ignited = ignited;
++    }
++
++    public boolean isCancelled() {
++        return canceled;
++    }
++
++    public void setCancelled(boolean cancel) {
++        canceled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/org/bukkit/entity/Creeper.java b/src/main/java/org/bukkit/entity/Creeper.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Creeper.java
++++ b/src/main/java/org/bukkit/entity/Creeper.java
+@@ -0,0 +0,0 @@ public interface Creeper extends Monster {
+      * griefing gamerule.
+      */
+     public void ignite();
++    // Paper start
++
++    /**
++     * Set whether creeper is ignited or not (armed to explode)
++     *
++     * @param ignited New ignited state
++     */
++    public void setIgnited(boolean ignited);
++
++    /**
++     * Check if creeper is ignited or not (armed to explode)
++     *
++     * @return Ignited state
++     */
++    public boolean isIgnited();
++    // Paper end
+ }

patches/unapplied/api/Add-Moving-Piston-API.patch

@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sat, 4 Dec 2021 13:29:45 -0500
+Subject: [PATCH] Add Moving Piston API
+
+
+diff --git a/src/main/java/io/papermc/paper/block/MovingPiston.java b/src/main/java/io/papermc/paper/block/MovingPiston.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/block/MovingPiston.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.block;
++
++import org.bukkit.block.BlockFace;
++import org.bukkit.block.TileState;
++import org.bukkit.block.data.BlockData;
++import org.jetbrains.annotations.NotNull;
++
++public interface MovingPiston extends TileState {
++
++    /**
++     * Gets the block that is being pushed
++     *
++     * @return the pushed block
++     */
++    @NotNull
++    BlockData getMovingBlock();
++
++    /**
++     * The direction that the current moving piston
++     * is pushing/pulling a block in.
++     *
++     * @return the direction
++     */
++    @NotNull
++    BlockFace getDirection();
++
++    /**
++     * Gets if the piston is extending or not.
++     * Returns false if the piston is retracting.
++     *
++     * @return is extending or not
++     */
++    boolean isExtending();
++
++    /**
++     * Returns if this moving piston represents the main piston head
++     * from the original piston.
++     *
++     * @return is the piston head or not
++     */
++    boolean isPistonHead();
++
++}

patches/unapplied/api/Add-NamespacedKey-biome-methods.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Sun, 14 Aug 2022 12:22:54 -0400
+Subject: [PATCH] Add NamespacedKey biome methods
+
+Co-authored-by: Thonk <30448663+ExcessiveAmountsOfZombies@users.noreply.github.com>
+
+diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/UnsafeValues.java
++++ b/src/main/java/org/bukkit/UnsafeValues.java
+@@ -0,0 +0,0 @@ public interface UnsafeValues {
+      * @throws IllegalArgumentException if {@link Material#isBlock()} is false
+      */
+     boolean isCollidable(@org.jetbrains.annotations.NotNull Material material);
++
++    /**
++     * Gets the {@link NamespacedKey} for the biome at the given location.
++     *
++     * @param accessor The {@link RegionAccessor} of the provided coordinates
++     * @param x X-coordinate of the block
++     * @param y Y-coordinate of the block
++     * @param z Z-coordinate of the block
++     * @return the biome's {@link NamespacedKey}
++     */
++    @org.jetbrains.annotations.NotNull
++    NamespacedKey getBiomeKey(RegionAccessor accessor, int x, int y, int z);
++
++    /**
++     * Sets the biome at the given location to a biome registered
++     * to the given {@link NamespacedKey}. If no biome by the given
++     * {@link NamespacedKey} exists, an {@link IllegalStateException}
++     * will be thrown.
++     *
++     * @param accessor The {@link RegionAccessor} of the provided coordinates
++     * @param x X-coordinate of the block
++     * @param y Y-coordinate of the block
++     * @param z Z-coordinate of the block
++     * @param biomeKey Biome key
++     * @throws IllegalStateException if no biome by the given key is registered.
++     */
++    void setBiomeKey(RegionAccessor accessor, int x, int y, int z, NamespacedKey biomeKey);
+     // Paper end
+ }

patches/unapplied/api/Add-OBSTRUCTED-reason-to-BedEnterResult.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 24 Dec 2020 12:43:30 -0800
+Subject: [PATCH] Add OBSTRUCTED reason to BedEnterResult
+
+
+diff --git a/src/main/java/org/bukkit/event/player/PlayerBedEnterEvent.java b/src/main/java/org/bukkit/event/player/PlayerBedEnterEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerBedEnterEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerBedEnterEvent.java
+@@ -0,0 +0,0 @@ public class PlayerBedEnterEvent extends PlayerEvent implements Cancellable {
+          * Entering the bed is prevented due to the player being too far away.
+          */
+         TOO_FAR_AWAY,
++        // Paper start
++        /**
++         * Bed was obstructed.
++         */
++        OBSTRUCTED,
++        // Paper end
+         /**
+          * Entering the bed is prevented due to there being monsters nearby.
+          */

patches/unapplied/api/Add-PaperRegistry.patch

@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 2 Mar 2022 13:36:21 -0800
+Subject: [PATCH] Add PaperRegistry
+
+
+diff --git a/src/main/java/io/papermc/paper/registry/Reference.java b/src/main/java/io/papermc/paper/registry/Reference.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/Reference.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry;
++
++import org.bukkit.Keyed;
++import org.bukkit.NamespacedKey;
++import org.bukkit.Registry;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Represents a reference to a server-backed registry value that may
++ * change.
++ *
++ * @param <T> type of the value
++ */
++public interface Reference<T extends Keyed> extends Keyed {
++
++    /**
++     * Gets the value from the registry with the key.
++     *
++     * @return the value
++     * @throws java.util.NoSuchElementException if there is no value with this key
++     */
++    @NotNull T value();
++
++    /**
++     * Gets the value from the registry with the key.
++     *
++     * @return the value or null if it doesn't exist
++     */
++    @Nullable T valueOrNull();
++
++    /**
++     * Creates a reference to a registered value.
++     *
++     * @param registry the registry the value is located in
++     * @param key the key to the value
++     * @param <T> the type of the value
++     * @return a reference
++     */
++    static <T extends Keyed> @NotNull Reference<T> create(@NotNull Registry<T> registry, @NotNull NamespacedKey key) {
++        return new ReferenceImpl<>(registry, key);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/ReferenceImpl.java b/src/main/java/io/papermc/paper/registry/ReferenceImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/ReferenceImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry;
++
++import org.bukkit.Keyed;
++import org.bukkit.NamespacedKey;
++import org.bukkit.Registry;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.NoSuchElementException;
++
++record ReferenceImpl<T extends Keyed>(@NotNull Registry<T> registry, @NotNull NamespacedKey key) implements Reference<T> {
++
++    @Override
++    public @NotNull T value() {
++        final T value = this.registry.get(this.key);
++        if (value == null) {
++            throw new NoSuchElementException("No such value with key " + this.key);
++        }
++        return value;
++    }
++
++    @Override
++    public @Nullable T valueOrNull() {
++        return this.registry.get(this.key);
++    }
++
++    @Override
++    public @NotNull NamespacedKey getKey() {
++        return this.key;
++    }
++}

patches/unapplied/api/Add-PhantomPreSpawnEvent.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 25 Aug 2018 19:56:42 -0500
+Subject: [PATCH] Add PhantomPreSpawnEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/PhantomPreSpawnEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/PhantomPreSpawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/PhantomPreSpawnEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.Location;
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.EntityType;
++import org.bukkit.event.entity.CreatureSpawnEvent;
++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;
++
++    public PhantomPreSpawnEvent(@NotNull Location location, @NotNull Entity entity, @NotNull CreatureSpawnEvent.SpawnReason reason) {
++        super(location, EntityType.PHANTOM, reason);
++        this.entity = entity;
++    }
++
++    /**
++     * Get the entity this phantom is spawning for
++     *
++     * @return Entity
++     */
++    @Nullable
++    public Entity getSpawningEntity() {
++        return entity;
++    }
++}
+diff --git a/src/main/java/org/bukkit/entity/Phantom.java b/src/main/java/org/bukkit/entity/Phantom.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Phantom.java
++++ b/src/main/java/org/bukkit/entity/Phantom.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.entity;
+ 
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
+ /**
+  * Represents a phantom.
+  */
+@@ -0,0 +0,0 @@ public interface Phantom extends Flying, Enemy {
+      * @param sz The new size of the phantom.
+      */
+     public void setSize(int sz);
++
++    // Paper start
++    /**
++     * Get the UUID of the entity that caused this phantom to spawn
++     *
++     * @return UUID
++     */
++    @Nullable
++    public java.util.UUID getSpawningEntity();
++    // Paper end
+ }

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

@@ -0,0 +1,247 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MiniDigger | Martin <admin@minidigger.dev>
+Date: Mon, 20 Jan 2020 21:38:34 +0100
+Subject: [PATCH] Add Player Client Options API
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/ClientOption.java b/src/main/java/com/destroystokyo/paper/ClientOption.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/ClientOption.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper;
++
++import net.kyori.adventure.translation.Translatable;
++import net.kyori.adventure.util.Index;
++import org.jetbrains.annotations.NotNull;
++
++import org.bukkit.inventory.MainHand;
++
++public final class ClientOption<T> {
++
++    public static final ClientOption<SkinParts> SKIN_PARTS = new ClientOption<>(SkinParts.class);
++    public static final ClientOption<Boolean> CHAT_COLORS_ENABLED = new ClientOption<>(Boolean.class);
++    public static final ClientOption<ChatVisibility> CHAT_VISIBILITY = new ClientOption<>(ChatVisibility.class);
++    public static final ClientOption<String> LOCALE = new ClientOption<>(String.class);
++    public static final ClientOption<MainHand> MAIN_HAND = new ClientOption<>(MainHand.class);
++    public static final ClientOption<Integer> VIEW_DISTANCE = new ClientOption<>(Integer.class);
++    public static final ClientOption<Boolean> ALLOW_SERVER_LISTINGS = new ClientOption<>(Boolean.class);
++    public static final ClientOption<Boolean> TEXT_FILTERING_ENABLED = new ClientOption<>(Boolean.class);
++
++    private final Class<T> type;
++
++    private ClientOption(@NotNull Class<T> type) {
++        this.type = type;
++    }
++
++    @NotNull
++    public Class<T> getType() {
++        return type;
++    }
++
++    public enum ChatVisibility implements Translatable {
++        FULL("full"),
++        SYSTEM("system"),
++        HIDDEN("hidden"),
++        UNKNOWN("unknown");
++
++        public static Index<String, ChatVisibility> NAMES = Index.create(ChatVisibility.class, chatVisibility -> chatVisibility.name);
++        private final String name;
++
++        ChatVisibility(String name) {
++            this.name = name;
++        }
++
++        @Override
++        public @NotNull String translationKey() {
++            if (this == UNKNOWN) {
++                throw new UnsupportedOperationException(this.name + " doesn't have a translation key");
++            }
++            return "options.chat.visibility." + this.name;
++        }
++    }
++}
+diff --git a/src/main/java/com/destroystokyo/paper/SkinParts.java b/src/main/java/com/destroystokyo/paper/SkinParts.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/SkinParts.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper;
++
++public interface SkinParts {
++
++    boolean hasCapeEnabled();
++
++    boolean hasJacketEnabled();
++
++    boolean hasLeftSleeveEnabled();
++
++    boolean hasRightSleeveEnabled();
++
++    boolean hasLeftPantsEnabled();
++
++    boolean hasRightPantsEnabled();
++
++    boolean hasHatsEnabled();
++
++    int getRaw();
++}
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerClientOptionsChangeEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerClientOptionsChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerClientOptionsChangeEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import com.destroystokyo.paper.ClientOption;
++import com.destroystokyo.paper.ClientOption.ChatVisibility;
++import com.destroystokyo.paper.SkinParts;
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.inventory.MainHand;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.Map;
++
++/**
++ * Called when the player changes their client settings
++ */
++public class PlayerClientOptionsChangeEvent extends PlayerEvent {
++
++    private static final HandlerList handlers = new HandlerList();
++
++    private final String locale;
++    private final int viewDistance;
++    private final ChatVisibility chatVisibility;
++    private final boolean chatColors;
++    private final SkinParts skinparts;
++    private final MainHand mainHand;
++    private final boolean allowsServerListings;
++    private final boolean textFilteringEnabled;
++
++    @Deprecated
++    public PlayerClientOptionsChangeEvent(@NotNull Player player, @NotNull String locale, int viewDistance, @NotNull ChatVisibility chatVisibility, boolean chatColors, @NotNull SkinParts skinParts, @NotNull MainHand mainHand) {
++        super(player);
++        this.locale = locale;
++        this.viewDistance = viewDistance;
++        this.chatVisibility = chatVisibility;
++        this.chatColors = chatColors;
++        this.skinparts = skinParts;
++        this.mainHand = mainHand;
++        this.allowsServerListings = false;
++        this.textFilteringEnabled = false;
++    }
++
++    public PlayerClientOptionsChangeEvent(@NotNull Player player, @NotNull Map<ClientOption<?>, ?> options) {
++        super(player);
++
++        this.locale = (String) options.get(ClientOption.LOCALE);
++        this.viewDistance = (int) options.get(ClientOption.VIEW_DISTANCE);
++        this.chatVisibility = (ChatVisibility) options.get(ClientOption.CHAT_VISIBILITY);
++        this.chatColors = (boolean) options.get(ClientOption.CHAT_COLORS_ENABLED);
++        this.skinparts = (SkinParts) options.get(ClientOption.SKIN_PARTS);
++        this.mainHand = (MainHand) options.get(ClientOption.MAIN_HAND);
++        this.allowsServerListings = (boolean) options.get(ClientOption.ALLOW_SERVER_LISTINGS);
++        this.textFilteringEnabled = (boolean) options.get(ClientOption.TEXT_FILTERING_ENABLED);
++    }
++
++    @NotNull
++    public String getLocale() {
++        return locale;
++    }
++
++    public boolean hasLocaleChanged() {
++        return !locale.equals(player.getClientOption(ClientOption.LOCALE));
++    }
++
++    public int getViewDistance() {
++        return viewDistance;
++    }
++
++    public boolean hasViewDistanceChanged() {
++        return viewDistance != player.getClientOption(ClientOption.VIEW_DISTANCE);
++    }
++
++    @NotNull
++    public ChatVisibility getChatVisibility() {
++        return chatVisibility;
++    }
++
++    public boolean hasChatVisibilityChanged() {
++        return chatVisibility != player.getClientOption(ClientOption.CHAT_VISIBILITY);
++    }
++
++    public boolean hasChatColorsEnabled() {
++        return chatColors;
++    }
++
++    public boolean hasChatColorsEnabledChanged() {
++        return chatColors != player.getClientOption(ClientOption.CHAT_COLORS_ENABLED);
++    }
++
++    @NotNull
++    public SkinParts getSkinParts() {
++        return skinparts;
++    }
++
++    public boolean hasSkinPartsChanged() {
++        return skinparts.getRaw() != player.getClientOption(ClientOption.SKIN_PARTS).getRaw();
++    }
++
++    @NotNull
++    public MainHand getMainHand() {
++        return mainHand;
++    }
++
++    public boolean hasMainHandChanged() {
++        return mainHand != player.getClientOption(ClientOption.MAIN_HAND);
++    }
++
++    public boolean allowsServerListings() {
++        return allowsServerListings;
++    }
++
++    public boolean hasAllowServerListingsChanged() {
++        return allowsServerListings != player.getClientOption(ClientOption.ALLOW_SERVER_LISTINGS);
++    }
++
++    public boolean hasTextFilteringEnabled() {
++        return textFilteringEnabled;
++    }
++
++    public boolean hasTextFilteringChanged() {
++        return textFilteringEnabled != player.getClientOption(ClientOption.TEXT_FILTERING_ENABLED);
++    }
++
++    @Override
++    @NotNull
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      * Reset the cooldown counter to 0, effectively starting the cooldown period.
+      */
+     void resetCooldown();
++
++    /**
++     * @return the client option value of the player
++     */
++    @NotNull
++    <T> T getClientOption(@NotNull com.destroystokyo.paper.ClientOption<T> option);
+     // Paper end
+ 
+     // Spigot start

patches/unapplied/api/Add-Player-Warden-Warning-API.patch

@@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dawon <dawon@dawon.eu>
+Date: Sat, 15 Oct 2022 00:46:32 +0200
+Subject: [PATCH] Add Player Warden Warning API
+
+
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      * @param silent whether sound should be silenced
+      */
+     void showElderGuardian(boolean silent);
++
++    /**
++     * Returns the player's cooldown in ticks until the next Warden warning can occur.
++     *
++     * @return ticks until next Warden warning can occur. 0 means there is no cooldown left.
++     */
++    int getWardenWarningCooldown();
++
++    /**
++     * Sets the player's cooldown in ticks until next Warden warning can occur.
++     *
++     * @param cooldown ticks until next Warden warning can occur. 0 means there is no cooldown left. Values less than 0 are set to 0.
++     */
++    void setWardenWarningCooldown(int cooldown);
++
++    /**
++     * Returns time since last Warden warning in ticks.
++     *
++     * @return ticks since last Warden warning
++     */
++    int getWardenTimeSinceLastWarning();
++
++    /**
++     * Sets time since last Warden warning in ticks.
++     *
++     * @param time ticks since last Warden warning
++     */
++    void setWardenTimeSinceLastWarning(int time);
++
++    /**
++     * Returns the player's current Warden warning level.
++     *
++     * @return current Warden warning level
++     */
++    int getWardenWarningLevel();
++
++    /**
++     * Sets the player's Warden warning level.
++     * <p>
++     * <b>Note:</b> This will not actually spawn the Warden.
++     * Even if the warning level is over threshold, the player still needs to activate a Shrieker in order to summon the Warden.
++     *
++     * @param warningLevel player's Warden warning level. The warning level is internally limited to valid values.
++     */
++    void setWardenWarningLevel(int warningLevel);
++
++    /**
++     * Increases the player's Warden warning level if possible and not on cooldown.
++     * <p>
++     * <b>Note:</b> This will not actually spawn the Warden.
++     * Even if the warning level is over threshold, the player still needs to activate a Shrieker in order to summon the Warden.
++     */
++    void increaseWardenWarningLevel();
+     // Paper end
+ 
+     @NotNull

patches/unapplied/api/Add-Player-getFishHook.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: u9g <git@u9g.dev>
+Date: Tue, 14 Jun 2022 19:35:21 -0400
+Subject: [PATCH] Add Player#getFishHook
+
+
+diff --git a/src/main/java/org/bukkit/entity/HumanEntity.java b/src/main/java/org/bukkit/entity/HumanEntity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/HumanEntity.java
++++ b/src/main/java/org/bukkit/entity/HumanEntity.java
+@@ -0,0 +0,0 @@ public interface HumanEntity extends LivingEntity, AnimalTamer, InventoryHolder
+     @Nullable
+     public Location getPotentialBedLocation();
+     // Paper end
++    // Paper start
++    /**
++     * @return the player's fishing hook if they are fishing
++     */
++    @Nullable
++    FishHook getFishHook();
++    // Paper end
+ 
+     /**
+      * Attempts to make the entity sleep at the given location.

patches/unapplied/api/Add-PlayerArmorChangeEvent.patch

@@ -0,0 +1,149 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: pkt77 <parkerkt77@gmail.com>
+Date: Fri, 10 Nov 2017 23:45:59 -0500
+Subject: [PATCH] Add PlayerArmorChangeEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerArmorChangeEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerArmorChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerArmorChangeEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.Material;
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++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.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import static org.bukkit.Material.*;
++
++/**
++ * Called when the player themselves change their armor items
++ * <p>
++ * 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();
++
++    @NotNull private final SlotType slotType;
++    @Nullable private final ItemStack oldItem;
++    @Nullable private final ItemStack newItem;
++
++    public PlayerArmorChangeEvent(@NotNull Player player, @NotNull SlotType slotType, @Nullable ItemStack oldItem, @Nullable ItemStack newItem) {
++        super(player);
++        this.slotType = slotType;
++        this.oldItem = oldItem;
++        this.newItem = newItem;
++    }
++
++    /**
++     * Gets the type of slot being altered.
++     *
++     * @return type of slot being altered
++     */
++    @NotNull
++    public SlotType getSlotType() {
++        return this.slotType;
++    }
++
++    /**
++     * Gets the existing item that's being replaced
++     *
++     * @return old item
++     */
++    @Nullable
++    public ItemStack getOldItem() {
++        return this.oldItem;
++    }
++
++    /**
++     * Gets the new item that's replacing the old
++     *
++     * @return new item
++     */
++    @Nullable
++    public ItemStack getNewItem() {
++        return this.newItem;
++    }
++
++    @Override
++    public String toString() {
++        return "ArmorChangeEvent{" + "player=" + player + ", slotType=" + slotType + ", oldItem=" + oldItem + ", newItem=" + newItem + '}';
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++
++    public enum SlotType {
++        HEAD(NETHERITE_HELMET, DIAMOND_HELMET, GOLDEN_HELMET, IRON_HELMET, CHAINMAIL_HELMET, LEATHER_HELMET, CARVED_PUMPKIN, PLAYER_HEAD, SKELETON_SKULL, ZOMBIE_HEAD, CREEPER_HEAD, WITHER_SKELETON_SKULL, TURTLE_HELMET),
++        CHEST(NETHERITE_CHESTPLATE, DIAMOND_CHESTPLATE, GOLDEN_CHESTPLATE, IRON_CHESTPLATE, CHAINMAIL_CHESTPLATE, LEATHER_CHESTPLATE, ELYTRA),
++        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;
++
++        SlotType(Material... types) {
++            this.mutableTypes.addAll(Arrays.asList(types));
++        }
++
++        /**
++         * Gets an immutable set of all allowed material types that can be placed in an
++         * armor slot.
++         *
++         * @return immutable set of material types
++         */
++        @NotNull
++        public Set<Material> getTypes() {
++            if (immutableTypes == null) {
++                immutableTypes = Collections.unmodifiableSet(mutableTypes);
++            }
++
++            return immutableTypes;
++        }
++
++        /**
++         * 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
++         */
++        @Nullable
++        public static SlotType getByMaterial(@NotNull Material material) {
++            for (SlotType slotType : values()) {
++                if (slotType.getTypes().contains(material)) {
++                    return slotType;
++                }
++            }
++            return null;
++        }
++
++        /**
++         * Gets whether or not this material can be equipped to a slot
++         *
++         * @param material material to check
++         * @return whether or not this material can be equipped
++         */
++        public static boolean isEquipable(@NotNull Material material) {
++            return getByMaterial(material) != null;
++        }
++    }
++}

patches/unapplied/api/Add-PlayerAttackEntityCooldownResetEvent.patch

@@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: nossr50 <nossr50@gmail.com>
+Date: Thu, 26 Mar 2020 19:30:58 -0700
+Subject: [PATCH] Add PlayerAttackEntityCooldownResetEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerAttackEntityCooldownResetEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerAttackEntityCooldownResetEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerAttackEntityCooldownResetEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.entity.Entity;
++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.NotNull;
++
++/**
++ * Called when processing a player's attack on an entity when the player's attack strength cooldown is reset
++ */
++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;
++
++    public PlayerAttackEntityCooldownResetEvent(@NotNull Player who, @NotNull Entity attackedEntity, float cooledAttackStrength) {
++        super(who);
++        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;
++    }
++
++    /**
++     * Returns the entity attacked by the player
++     *
++     * @return the entity attacked by the player
++     */
++    @NotNull
++    public Entity getAttackedEntity() {
++        return attackedEntity;
++    }
++}

patches/unapplied/api/Add-PlayerConnectionCloseEvent.patch

@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 7 Oct 2018 12:05:06 -0700
+Subject: [PATCH] Add PlayerConnectionCloseEvent
+
+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.
+
+The event is invoked for players who have not yet logged into the world, whereas
+PlayerQuitEvent is only invoked on players who have logged into the world.
+
+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 PlayerQuitEvent, if the player has already logged into
+the world.
+
+This event is guaranteed to never fire unless AsyncPlayerPreLoginEvent has
+been called beforehand, and this event may not be called in parallel with
+AsyncPlayerPreLoginEvent for the same connection.
+
+Cancelling the AsyncPlayerPreLoginEvent guarantees the corresponding
+PlayerConnectionCloseEvent is never called.
+
+The event may be invoked asynchronously or synchronously. As it stands,
+it is never invoked asynchronously. However, plugins should check
+Event#isAsynchronous to be future-proof.
+
+On purpose, the deprecated PlayerPreLoginEvent event is left out of the
+API spec for this event. Plugins should not be using that event, and
+how PlayerPreLoginEvent interacts with PlayerConnectionCloseEvent
+is undefined.
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerConnectionCloseEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++
++import java.net.InetAddress;
++import java.util.UUID;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * <p>
++ * 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>
++ *
++ * <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>
++ *
++ * <p>
++ * This event is guaranteed to never fire unless {@link org.bukkit.event.player.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>
++ *
++ * <p>
++ * Cancelling the {@link org.bukkit.event.player.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();
++
++    @NotNull private final UUID playerUniqueId;
++    @NotNull private final String playerName;
++    @NotNull private final InetAddress ipAddress;
++
++    public PlayerConnectionCloseEvent(@NotNull final UUID playerUniqueId, @NotNull final String playerName, @NotNull final InetAddress ipAddress, final boolean async) {
++        super(async);
++        this.playerUniqueId = playerUniqueId;
++        this.playerName = playerName;
++        this.ipAddress = ipAddress;
++    }
++
++    /**
++     * Returns the {@code UUID} of the player disconnecting.
++     */
++    @NotNull
++    public UUID getPlayerUniqueId() {
++        return this.playerUniqueId;
++    }
++
++    /**
++     * Returns the name of the player disconnecting.
++     */
++    @NotNull
++    public String getPlayerName() {
++        return this.playerName;
++    }
++
++    /**
++     * Returns the player's IP address.
++     */
++    @NotNull
++    public InetAddress getIpAddress() {
++        return this.ipAddress;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}

patches/unapplied/api/Add-PlayerFlowerPotManipulateEvent.patch

@@ -0,0 +1,94 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MisterVector <whizkid3000@hotmail.com>
+Date: Tue, 13 Aug 2019 19:44:19 -0700
+Subject: [PATCH] Add PlayerFlowerPotManipulateEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerFlowerPotManipulateEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerFlowerPotManipulateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerFlowerPotManipulateEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.block.Block;
++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.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();
++
++    @NotNull
++    private final Block flowerpot;
++    @NotNull
++    private final ItemStack item;
++    private final boolean placing;
++
++    private boolean cancel = false;
++
++    public PlayerFlowerPotManipulateEvent(@NotNull final Player player, @NotNull final Block flowerpot, @NotNull final ItemStack item, final boolean placing) {
++        super(player);
++        this.flowerpot = flowerpot;
++        this.item = item;
++        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.
++     *
++     * @return the flowerpot that is involved with this event
++     */
++    @NotNull
++    public Block getFlowerpot() {
++        return flowerpot;
++    }
++
++    /**
++     * Gets the item being placed, or taken from, the flower pot.
++     * Check if placing with {@link #isPlacing()}.
++     *
++     * @return the item placed, or taken from, the flowerpot
++     */
++    @NotNull
++    public ItemStack getItem() {
++        return item;
++    }
++
++    /**
++     * Gets if the item is being placed into the flowerpot.
++     *
++     * @return if the item is being placed into the flowerpot
++     */
++    public boolean isPlacing() {
++        return placing;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerInitialSpawnEvent.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Steve Anton <anxuiz.nx@gmail.com>
+Date: Mon, 29 Feb 2016 18:13:58 -0600
+Subject: [PATCH] Add PlayerInitialSpawnEvent
+
+For modifying a player's initial spawn location as they join the server
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerInitialSpawnEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerInitialSpawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerInitialSpawnEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.Location;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++import org.spigotmc.event.player.PlayerSpawnLocationEvent;
++
++/**
++ * @deprecated Use {@link PlayerSpawnLocationEvent}, Duplicate API
++ */
++@Deprecated
++public class PlayerInitialSpawnEvent extends PlayerSpawnLocationEvent {
++
++    public PlayerInitialSpawnEvent(@NotNull Player who, @NotNull Location spawnLocation) {
++        super(who, spawnLocation);
++    }
++}

patches/unapplied/api/Add-PlayerInventorySlotChangeEvent.patch

@@ -0,0 +1,111 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jakub Zacek <dawon@dawon.eu>
+Date: Sun, 24 Apr 2022 22:56:31 +0200
+Subject: [PATCH] Add PlayerInventorySlotChangeEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerInventorySlotChangeEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerInventorySlotChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerInventorySlotChangeEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.inventory.Inventory;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a slot contents change in a player's inventory.
++ */
++public class PlayerInventorySlotChangeEvent extends PlayerEvent {
++    private static final HandlerList handlers = new HandlerList();
++    private final int rawSlot;
++    private final int slot;
++    private final ItemStack oldItemStack;
++    private final ItemStack newItemStack;
++    private boolean triggerAdvancements = true;
++
++    public PlayerInventorySlotChangeEvent(@NotNull Player player, int rawSlot, @NotNull ItemStack oldItemStack, @NotNull ItemStack newItemStack) {
++        super(player);
++        this.rawSlot = rawSlot;
++        this.slot = player.getOpenInventory().convertSlot(rawSlot);
++        this.oldItemStack = oldItemStack;
++        this.newItemStack = newItemStack;
++    }
++
++    /**
++     * The raw slot number that was changed.
++     *
++     * @return The raw slot number.
++     */
++    public int getRawSlot() {
++        return rawSlot;
++    }
++
++    /**
++     * The slot number that was changed, ready for passing to
++     * {@link Inventory#getItem(int)}. Note that there may be two slots with
++     * the same slot number, since a view links two different inventories.
++     * <p>
++     * If no inventory is opened, internal crafting view is used for conversion.
++     *
++     * @return The slot number.
++     */
++    public int getSlot() {
++        return slot;
++    }
++
++    /**
++     * Clone of ItemStack that was in the slot before the change.
++     *
++     * @return The old ItemStack in the slot.
++     */
++    @NotNull
++    public ItemStack getOldItemStack() {
++        return oldItemStack;
++    }
++
++    /**
++     * Clone of ItemStack that is in the slot after the change.
++     *
++     * @return The new ItemStack in the slot.
++     */
++    @NotNull
++    public ItemStack getNewItemStack() {
++        return newItemStack;
++    }
++
++    /**
++     * Gets whether the slot change advancements will be triggered.
++     *
++     * @return Whether the slot change advancements will be triggered.
++     */
++    public boolean shouldTriggerAdvancements() {
++        return triggerAdvancements;
++    }
++
++    /**
++     * Sets whether the slot change advancements will be triggered.
++     *
++     * @param triggerAdvancements Whether the slot change advancements will be triggered.
++     */
++    public void setShouldTriggerAdvancements(boolean triggerAdvancements) {
++        this.triggerAdvancements = triggerAdvancements;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerItemCooldownEvent.patch

@@ -0,0 +1,89 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nassim Jahnke <nassim@njahnke.dev>
+Date: Tue, 25 Aug 2020 13:45:15 +0200
+Subject: [PATCH] Add PlayerItemCooldownEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerItemCooldownEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerItemCooldownEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerItemCooldownEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import com.google.common.base.Preconditions;
++import org.bukkit.Material;
++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.NotNull;
++
++/**
++ * Fired when a player receives an item cooldown.
++ */
++public class PlayerItemCooldownEvent extends PlayerEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    @NotNull
++    private final Material type;
++    private boolean cancelled;
++    private int cooldown;
++
++    public PlayerItemCooldownEvent(@NotNull Player player, @NotNull Material type, int cooldown) {
++        super(player);
++        this.type = type;
++        this.cooldown = cooldown;
++    }
++
++    /**
++     * Get the material affected by the cooldown.
++     *
++     * @return material affected by the cooldown
++     */
++    @NotNull
++    public Material getType() {
++        return type;
++    }
++
++    /**
++     * Gets the cooldown in ticks.
++     *
++     * @return cooldown in ticks
++     */
++    public int getCooldown() {
++        return cooldown;
++    }
++
++    /**
++     * Sets the cooldown of the material in ticks.
++     * Setting the cooldown to 0 results in removing an already existing cooldown for the material.
++     *
++     * @param cooldown cooldown in ticks, has to be a positive number
++     */
++    public void setCooldown(int cooldown) {
++        Preconditions.checkArgument(cooldown >= 0, "The cooldown has to be equal to or greater than 0!");
++        this.cooldown = cooldown;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerItemFrameChangeEvent.patch

@@ -0,0 +1,109 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SamB440 <sam@islandearth.net>
+Date: Mon, 15 Nov 2021 18:09:46 +0000
+Subject: [PATCH] Add PlayerItemFrameChangeEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerItemFrameChangeEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerItemFrameChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerItemFrameChangeEvent.java
+@@ -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.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when an {@link ItemFrame} is having an item rotated, added, or removed from it.
++ */
++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;
++
++    public PlayerItemFrameChangeEvent(@NotNull Player player, @NotNull ItemFrame itemFrame,
++                                      @NotNull ItemStack itemStack, @NotNull ItemFrameChangeAction action) {
++        super(player);
++        this.itemFrame = itemFrame;
++        this.itemStack = itemStack;
++        this.action = action;
++    }
++
++    /**
++     * Gets the {@link ItemFrame} involved in this event.
++     * @return the {@link ItemFrame}
++     */
++    @NotNull
++    public ItemFrame getItemFrame() {
++        return 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>
++     * @return the {@link ItemStack} being added, rotated, or removed
++     */
++    @NotNull
++    public ItemStack getItemStack() {
++        return 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.
++     * @param itemStack {@link ItemFrame} item
++     */
++    public void setItemStack(@Nullable ItemStack itemStack) {
++        this.itemStack = itemStack == null ? new ItemStack(Material.AIR) : 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;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    @NotNull
++    public HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++
++    public enum ItemFrameChangeAction {
++        PLACE,
++        REMOVE,
++        ROTATE
++    }
++}

patches/unapplied/api/Add-PlayerJumpEvent.patch

@@ -0,0 +1,118 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <1254957+zachbr@users.noreply.github.com>
+Date: Thu, 28 Sep 2017 17:21:32 -0400
+Subject: [PATCH] Add PlayerJumpEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerJumpEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerJumpEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerJumpEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import com.google.common.base.Preconditions;
++import org.bukkit.Location;
++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.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
++ * 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;
++
++    public PlayerJumpEvent(@NotNull final Player player, @NotNull final Location from, @NotNull final Location to) {
++        super(player);
++        this.from = from;
++        this.to = to;
++    }
++
++    /**
++     * 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 a jump event is cancelled, the player will be moved or
++     * teleported back to the Location as defined by getFrom(). This will not
++     * fire an event
++     *
++     * @return true if this event is cancelled
++     */
++    public boolean isCancelled() {
++        return cancel;
++    }
++
++    /**
++     * Sets 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 a jump event is cancelled, the player will be moved or
++     * teleported back to the Location as defined by getFrom(). This will not
++     * fire an event
++     *
++     * @param cancel true if you wish to cancel this event
++     */
++    public void setCancelled(boolean cancel) {
++        this.cancel = cancel;
++    }
++
++    /**
++     * Gets the location this player jumped from
++     *
++     * @return Location the player jumped from
++     */
++    @NotNull
++    public Location getFrom() {
++        return from;
++    }
++
++    /**
++     * Sets the location to mark as where the player jumped from
++     *
++     * @param from New location to mark as the players previous location
++     */
++    public void setFrom(@NotNull Location from) {
++        validateLocation(from);
++        this.from = from;
++    }
++
++    /**
++     * Gets the location this player jumped to
++     *
++     * This information is based on what the client sends, it typically
++     * has little relation to the arc of the jump at any given point.
++     *
++     * @return Location the player jumped to
++     */
++    @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!");
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerKickEvent-causes.patch

@@ -0,0 +1,141 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 15 May 2021 20:30:34 -0700
+Subject: [PATCH] Add PlayerKickEvent causes
+
+
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      * @param message kick message
+      */
+     void kick(final @Nullable net.kyori.adventure.text.Component message);
++
++    /**
++     * Kicks player with custom kick message and cause.
++     *
++     * @param message kick message
++     * @param cause kick cause
++     */
++    void kick(final @Nullable net.kyori.adventure.text.Component message, @NotNull org.bukkit.event.player.PlayerKickEvent.Cause cause);
+     // Paper end
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/event/player/PlayerKickEvent.java b/src/main/java/org/bukkit/event/player/PlayerKickEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerKickEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerKickEvent.java
+@@ -0,0 +0,0 @@ public class PlayerKickEvent extends PlayerEvent implements Cancellable {
+     private static final HandlerList handlers = new HandlerList();
+     private net.kyori.adventure.text.Component leaveMessage; // Paper
+     private net.kyori.adventure.text.Component kickReason; // Paper
++    private final Cause cause; // Paper
+     private boolean cancel;
+ 
+     @Deprecated // Paper
+@@ -0,0 +0,0 @@ public class PlayerKickEvent extends PlayerEvent implements Cancellable {
+         super(playerKicked);
+         this.kickReason = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(kickReason); // Paper
+         this.leaveMessage = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(leaveMessage); // Paper
++        this.cause  = Cause.UNKNOWN; // Paper
+         this.cancel = false;
+     }
+     // Paper start
++    @Deprecated
+     public PlayerKickEvent(@NotNull final Player playerKicked, @NotNull final net.kyori.adventure.text.Component kickReason, @NotNull final net.kyori.adventure.text.Component leaveMessage) {
+         super(playerKicked);
+         this.kickReason = kickReason;
+         this.leaveMessage = leaveMessage;
+         this.cancel = false;
++        this.cause = Cause.UNKNOWN;
++    }
++
++    public PlayerKickEvent(@NotNull final Player playerKicked, @NotNull final net.kyori.adventure.text.Component kickReason, @NotNull final net.kyori.adventure.text.Component leaveMessage, @NotNull final Cause cause) {
++        super(playerKicked);
++        this.kickReason = kickReason;
++        this.leaveMessage = leaveMessage;
++        this.cancel = false;
++        this.cause = cause;
+     }
+ 
+     /**
+@@ -0,0 +0,0 @@ public class PlayerKickEvent extends PlayerEvent implements Cancellable {
+     public static HandlerList getHandlerList() {
+         return handlers;
+     }
++    // Paper start
++    /**
++     * Gets the cause of this kick
++     *
++     * @return
++     */
++    @NotNull
++    public org.bukkit.event.player.PlayerKickEvent.Cause getCause() {
++        return cause;
++    }
++
++    public enum Cause {
++
++        PLUGIN,
++
++        WHITELIST,
++
++        BANNED,
++
++        IP_BANNED,
++
++        KICK_COMMAND,
++
++        FLYING_PLAYER,
++
++        FLYING_VEHICLE,
++
++        TIMEOUT,
++
++        IDLING,
++
++        INVALID_VEHICLE_MOVEMENT,
++
++        INVALID_PLAYER_MOVEMENT,
++
++        INVALID_ENTITY_ATTACKED,
++
++        INVALID_PAYLOAD,
++
++        SPAM,
++
++        ILLEGAL_ACTION,
++
++        ILLEGAL_CHARACTERS,
++
++        OUT_OF_ORDER_CHAT,
++
++        UNSIGNED_CHAT,
++
++        CHAT_VALIDATION_FAILED,
++
++        EXPIRED_PROFILE_PUBLIC_KEY,
++
++        INVALID_PUBLIC_KEY_SIGNATURE,
++
++        TOO_MANY_PENDING_CHATS,
++
++        SELF_INTERACTION,
++
++        DUPLICATE_LOGIN,
++
++        RESOURCE_PACK_REJECTION,
++
++        /**
++         * Spigot's restart command
++         */
++        RESTART_COMMAND,
++        /**
++         * Fallback cause
++         */
++        UNKNOWN,
++    }
++    // Paper end
+ }

patches/unapplied/api/Add-PlayerLocaleChangeEvent.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Isaac Moore <rmsy@me.com>
+Date: Mon, 29 Feb 2016 18:02:25 -0600
+Subject: [PATCH] Add PlayerLocaleChangeEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerLocaleChangeEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerLocaleChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLocaleChangeEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++
++/**
++ * Called when the locale of the player is changed.
++ *
++ * @deprecated Replaced by {@link org.bukkit.event.player.PlayerLocaleChangeEvent} upstream
++ */
++@Deprecated
++public class PlayerLocaleChangeEvent extends PlayerEvent {
++    private static final HandlerList handlers = new HandlerList();
++    private final String oldLocale;
++    private final String newLocale;
++
++    public PlayerLocaleChangeEvent(final Player player, final String oldLocale, final String newLocale) {
++        super(player);
++        this.oldLocale = oldLocale;
++        this.newLocale = newLocale;
++    }
++
++    /**
++     * Gets the locale the player switched from.
++     *
++     * @return player's old locale
++     */
++    public String getOldLocale() {
++        return oldLocale;
++    }
++
++    /**
++     * Gets the locale the player is changed to.
++     *
++     * @return player's new locale
++     */
++    public String getNewLocale() {
++        return newLocale;
++    }
++
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerPostRespawnEvent.patch

@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MisterVector <whizkid3000@hotmail.com>
+Date: Fri, 26 Oct 2018 21:33:13 -0700
+Subject: [PATCH] Add PlayerPostRespawnEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerPostRespawnEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerPostRespawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerPostRespawnEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.Location;
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++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 Location respawnedLocation;
++    private final boolean isBedSpawn;
++
++    public PlayerPostRespawnEvent(@NotNull final Player respawnPlayer, @NotNull final Location respawnedLocation, final boolean isBedSpawn) {
++        super(respawnPlayer);
++        this.respawnedLocation = respawnedLocation;
++        this.isBedSpawn = isBedSpawn;
++    }
++
++    /**
++     * Returns the location of the respawned player
++     *
++     * @return location of the respawned player
++     */
++    @NotNull
++    public Location getRespawnedLocation() {
++        return respawnedLocation.clone();
++    }
++
++    /**
++     * Checks if the player respawned to their bed
++     *
++     * @return whether the player respawned to their bed
++     */
++    public boolean isBedSpawn() {
++        return isBedSpawn;
++    }
++
++    @Override
++    @NotNull
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java b/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java
++++ b/src/main/java/org/bukkit/event/player/PlayerRespawnEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
+ 
+ /**
+  * Called when a player respawns.
++ * <p>
++ * If changing player state, see {@link com.destroystokyo.paper.event.player.PlayerPostRespawnEvent}
++ * because the player is "reset" between this event and that event and some changes won't persist.
+  */
+ public class PlayerRespawnEvent extends PlayerEvent {
+     private static final HandlerList handlers = new HandlerList();

patches/unapplied/api/Add-PlayerSetSpawnEvent.patch

@@ -0,0 +1,187 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 19 May 2021 18:58:24 -0700
+Subject: [PATCH] Add PlayerSetSpawnEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerSetSpawnEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerSetSpawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerSetSpawnEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import net.kyori.adventure.text.Component;
++import org.bukkit.Location;
++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.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * 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 {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Cause cause;
++    private Location location;
++    private boolean forced;
++    private boolean notifyPlayer;
++    private Component notification;
++
++    private boolean cancelled;
++
++    public PlayerSetSpawnEvent(@NotNull Player who, @NotNull Cause cause, @Nullable Location location, boolean forced, boolean notifyPlayer, @Nullable Component notification) {
++        super(who);
++        this.cause = cause;
++        this.location = location;
++        this.forced = forced;
++        this.notifyPlayer = notifyPlayer;
++        this.notification = notification;
++    }
++
++    /**
++     * Gets the cause of this event.
++     *
++     * @return the cause
++     */
++    @NotNull
++    public Cause getCause() {
++        return cause;
++    }
++
++    /**
++     * Gets the location that the spawn is set to. The yaw
++     * of this location is the spawn angle. Mutating this location
++     * 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
++     */
++    @Nullable
++    public Location getLocation() {
++        return 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
++     */
++    public void setLocation(@Nullable Location location) {
++        this.location = location;
++    }
++
++    /**
++     * Gets if this is a force spawn location
++     *
++     * @return true if forced
++     */
++    public boolean isForced() {
++        return forced;
++    }
++
++    /**
++     * Sets if this is a forced spawn location
++     *
++     * @param forced true to force
++     */
++    public void setForced(boolean forced) {
++        this.forced = forced;
++    }
++
++    /**
++     * Gets if this action will notify the player their spawn
++     * has been set.
++     *
++     * @return true to notify
++     */
++    public boolean willNotifyPlayer() {
++        return notifyPlayer;
++    }
++
++    /**
++     * Sets if this action will notify the player that their spawn
++     * has been set.
++     *
++     * @param notifyPlayer true to notify
++     */
++    public void setNotifyPlayer(boolean notifyPlayer) {
++        this.notifyPlayer = notifyPlayer;
++    }
++
++    /**
++     * Gets the notification message that will be sent to the player
++     * if {@link #willNotifyPlayer()} returns true.
++     *
++     * @return null if no notification
++     */
++    @Nullable
++    public Component getNotification() {
++        return notification;
++    }
++
++    /**
++     * Sets the notification message that will be sent to the player.
++     *
++     * @param notification null to send no message
++     */
++    public void setNotification(@Nullable Component notification) {
++        this.notification = notification;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++
++    public enum Cause {
++        /**
++         * When a player interacts successfully with a bed.
++         */
++        BED,
++        /**
++         * When a player interacts successfully with a respawn anchor.
++         */
++        RESPAWN_ANCHOR,
++        /**
++         * When a player respawns.
++         */
++        PLAYER_RESPAWN,
++        /**
++         * When the {@code /spawnpoint} command is used on a player.
++         */
++        COMMAND,
++        /**
++         * When a plugin uses {@link Player#setBedSpawnLocation(Location)} or
++         * {@link Player#setBedSpawnLocation(Location, boolean)}.
++         */
++        PLUGIN,
++        /**
++         * Fallback cause.
++         */
++        UNKNOWN,
++    }
++}

patches/unapplied/api/Add-PlayerShearBlockEvent.patch

@@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <10731363+JRoy@users.noreply.github.com>
+Date: Thu, 27 Aug 2020 12:32:35 -0400
+Subject: [PATCH] Add PlayerShearBlockEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/PlayerShearBlockEvent.java b/src/main/java/io/papermc/paper/event/block/PlayerShearBlockEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/PlayerShearBlockEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++import org.bukkit.block.Block;
++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.EquipmentSlot;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.List;
++
++/**
++ * Called when a player uses sheers on a block.
++ * <p>
++ * This event is <b>not</b> called when breaking blocks with shears but instead only when a
++ * player uses the sheer item on a block to garner drops from said block and/or change its state.
++ * <p>
++ * 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 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);
++        this.block = block;
++        this.item = item;
++        this.hand = hand;
++        this.drops = drops;
++    }
++
++    /**
++     * Gets the block being sheared in this event.
++     *
++     * @return The {@link Block} which block is being sheared in this event.
++     */
++    @NotNull
++    public Block getBlock() {
++        return block;
++    }
++
++    /**
++     * Gets the item used to shear the block.
++     *
++     * @return The {@link ItemStack} of the shears.
++     */
++    @NotNull
++    public ItemStack getItem() {
++        return item;
++    }
++
++    /**
++     * Gets the hand used to shear the block.
++     *
++     * @return Either {@link EquipmentSlot#HAND} OR {@link EquipmentSlot#OFF_HAND}.
++     */
++    @NotNull
++    public EquipmentSlot getHand() {
++        return hand;
++    }
++
++    /**
++     * Gets the resulting drops of this event.
++     *
++     * @return A {@link List list} of {@link ItemStack items} that will be dropped as result of this event.
++     */
++    @NotNull
++    public List<ItemStack> getDrops() {
++        return drops;
++    }
++
++    /**
++     * Gets whether the shearing of the block should be cancelled or not.
++     *
++     * @return Whether the shearing of the block should be cancelled or not.
++     */
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    /**
++     * Sets whether the shearing of the block should be cancelled or not.
++     *
++     * @param cancel whether the shearing of the block should be cancelled or not.
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerSignCommandPreprocessEvent.patch

@@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 9 Jul 2021 17:44:33 -0700
+Subject: [PATCH] Add PlayerSignCommandPreprocessEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerSignCommandPreprocessEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerSignCommandPreprocessEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerSignCommandPreprocessEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.block.Sign;
++import org.bukkit.entity.Player;
++import org.bukkit.event.player.PlayerCommandPreprocessEvent;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.Set;
++
++/**
++ * Called when a {@link Player} clicks a sign that causes a command to run.
++ * <p>
++ * This command is run with elevated permissions which allows players to access commands on signs they wouldn't
++ * normally be able to run.
++ */
++public class PlayerSignCommandPreprocessEvent extends PlayerCommandPreprocessEvent {
++
++    private final Sign sign;
++
++    public PlayerSignCommandPreprocessEvent(@NotNull Player player, @NotNull String message, @NotNull Set<Player> recipients, @NotNull Sign sign) {
++        super(player, message, recipients);
++        this.sign = sign;
++    }
++
++    /**
++     * Gets the sign that the command originated from.
++     *
++     * @return the sign
++     */
++    @NotNull
++    public Sign getSign() {
++        return sign;
++    }
++}

patches/unapplied/api/Add-PlayerStopUsingItemEvent.patch

@@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: u9g <git@u9g.dev>
+Date: Tue, 3 May 2022 20:41:30 -0400
+Subject: [PATCH] Add PlayerStopUsingItemEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PlayerStopUsingItemEvent.java b/src/main/java/io/papermc/paper/event/player/PlayerStopUsingItemEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PlayerStopUsingItemEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when the server detects a player stopping using an item.
++ * 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();
++    @NotNull private final ItemStack item;
++    private final int ticksHeldFor;
++
++    public PlayerStopUsingItemEvent(@NotNull final Player player, @NotNull final ItemStack item, final int ticksHeldFor) {
++        super(player);
++        this.item = item;
++        this.ticksHeldFor = ticksHeldFor;
++    }
++
++    /**
++     * Gets the exact item the player is releasing
++     *
++     * @return ItemStack the exact item the player released
++     */
++    @NotNull
++    public ItemStack getItem() {
++        return item;
++    }
++
++    /**
++     * Gets the number of ticks the item was held for
++     *
++     * @return int the number of ticks the item was held for
++     */
++    public int getTicksHeldFor() {
++        return ticksHeldFor;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-PlayerUseUnknownEntityEvent.patch

@@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jedediah Smith <jedediah@silencegreys.com>
+Date: Sat, 2 Apr 2016 05:08:36 -0400
+Subject: [PATCH] Add PlayerUseUnknownEntityEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerUseUnknownEntityEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerUseUnknownEntityEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerUseUnknownEntityEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.player;
++
++import org.bukkit.entity.Player;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.inventory.EquipmentSlot;
++import org.jetbrains.annotations.NotNull;
++
++public class PlayerUseUnknownEntityEvent extends PlayerEvent {
++
++    private static final HandlerList handlers = new HandlerList();
++    private final int entityId;
++    private final boolean attack;
++    @NotNull private final EquipmentSlot hand;
++
++    public PlayerUseUnknownEntityEvent(@NotNull Player who, int entityId, boolean attack, @NotNull EquipmentSlot hand) {
++        super(who);
++        this.entityId = entityId;
++        this.attack = attack;
++        this.hand = hand;
++    }
++
++    public int getEntityId() {
++        return this.entityId;
++    }
++
++    public boolean isAttack() {
++        return this.attack;
++    }
++
++    @NotNull
++    public EquipmentSlot getHand() {
++        return this.hand;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-Position.patch

@@ -0,0 +1,422 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 20 Mar 2022 10:42:28 -0700
+Subject: [PATCH] Add Position
+
+
+diff --git a/src/main/java/io/papermc/paper/math/BlockPosition.java b/src/main/java/io/papermc/paper/math/BlockPosition.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/math/BlockPosition.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.math;
++
++import org.bukkit.Axis;
++import org.bukkit.block.BlockFace;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A position represented with integers.
++ * <p>
++ * <b>May see breaking changes until Experimental annotation is removed.</b>
++ * @see FinePosition
++ */
++@ApiStatus.Experimental
++public interface BlockPosition extends Position {
++
++    @Override
++    default double x() {
++        return this.blockX();
++    }
++
++    @Override
++    default double y() {
++        return this.blockY();
++    }
++
++    @Override
++    default double z() {
++        return this.blockZ();
++    }
++
++    @Override
++    default boolean isBlock() {
++        return true;
++    }
++
++    @Override
++    default boolean isFine() {
++        return false;
++    }
++
++    @Override
++    default @NotNull BlockPosition toBlock() {
++        return this;
++    }
++
++    @Override
++    default @NotNull BlockPosition offset(int x, int y, int z) {
++        return x == 0 && y == 0 && z == 0 ? this : new BlockPositionImpl(this.blockX() + x, this.blockY() + y, this.blockZ() + z);
++    }
++
++    @Override
++    default @NotNull FinePosition offset(double x, double y, double z) {
++        return new FinePositionImpl(this.blockX() + z, this.blockY() + y, this.blockZ() + z);
++    }
++
++    /**
++     * Returns a block position offset by 1 in the direction specified.
++     *
++     * @param blockFace the block face to offset towards
++     * @return the offset block position
++     */
++    @Contract(value = "_ -> new", pure = true)
++    default @NotNull BlockPosition offset(@NotNull BlockFace blockFace) {
++        return this.offset(blockFace, 1);
++    }
++
++    /**
++     * Returns a block position offset in the direction specified
++     * multiplied by the amount.
++     *
++     * @param blockFace the block face to offset towards
++     * @param amount the number of times to move in that direction
++     * @return the offset block position
++     */
++    @Contract(pure = true)
++    default @NotNull BlockPosition offset(@NotNull BlockFace blockFace, int amount) {
++        return amount == 0 ? this : new BlockPositionImpl(this.blockX() + (blockFace.getModX() * amount), this.blockY() + (blockFace.getModY() * amount), this.blockZ() + (blockFace.getModZ() * amount));
++    }
++
++    /**
++     * Returns a block position offset by the amount along
++     * the specified axis.
++     *
++     * @param axis the axis to offset along
++     * @param amount the amount to offset along that axis
++     * @return the offset block position
++     */
++    @Contract(pure = true)
++    default @NotNull BlockPosition offset(@NotNull Axis axis, int amount) {
++        return amount == 0 ? this : switch (axis) {
++            case X -> new BlockPositionImpl(this.blockX() + amount, this.blockY(), this.blockZ());
++            case Y -> new BlockPositionImpl(this.blockX(), this.blockY() + amount, this.blockZ());
++            case Z -> new BlockPositionImpl(this.blockX(), this.blockY(), this.blockZ() + amount);
++        };
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/math/BlockPositionImpl.java b/src/main/java/io/papermc/paper/math/BlockPositionImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/math/BlockPositionImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.math;
++
++record BlockPositionImpl(int blockX, int blockY, int blockZ) implements BlockPosition {
++}
+diff --git a/src/main/java/io/papermc/paper/math/FinePosition.java b/src/main/java/io/papermc/paper/math/FinePosition.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/math/FinePosition.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.math;
++
++import org.bukkit.util.NumberConversions;
++import org.bukkit.util.Vector;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A position represented with doubles.
++ * <p>
++ * <b>May see breaking changes until Experimental annotation is removed.</b>
++ * @see BlockPosition
++ */
++@ApiStatus.Experimental
++public interface FinePosition extends Position {
++
++    @Override
++    default int blockX() {
++        return NumberConversions.floor(this.x());
++    }
++
++    @Override
++    default int blockY() {
++        return NumberConversions.floor(this.y());
++    }
++
++    @Override
++    default int blockZ() {
++        return NumberConversions.floor(this.z());
++    }
++
++    @Override
++    default boolean isBlock() {
++        return false;
++    }
++
++    @Override
++    default boolean isFine() {
++        return true;
++    }
++
++    @Override
++    default @NotNull BlockPosition toBlock() {
++        return new BlockPositionImpl(this.blockX(), this.blockY(), this.blockZ());
++    }
++
++    @Override
++    default @NotNull FinePosition offset(int x, int y, int z) {
++        return this.offset((double) x, y, z);
++    }
++
++    @Override
++    default @NotNull FinePosition offset(double x, double y, double z) {
++        return x == 0.0 && y == 0.0 && z == 0.0 ? this : new FinePositionImpl(this.x() + x, this.y() + y, this.z() + z);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/math/FinePositionImpl.java b/src/main/java/io/papermc/paper/math/FinePositionImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/math/FinePositionImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.math;
++
++record FinePositionImpl(double x, double y, double z) implements FinePosition {
++}
+diff --git a/src/main/java/io/papermc/paper/math/Position.java b/src/main/java/io/papermc/paper/math/Position.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/math/Position.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.math;
++
++import org.bukkit.Location;
++import org.bukkit.World;
++import org.bukkit.util.Vector;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Common interface for {@link FinePosition} and {@link BlockPosition}.
++ * <p>
++ * <b>May see breaking changes until Experimental annotation is removed.</b>
++ */
++@ApiStatus.Experimental
++public interface Position {
++
++    FinePosition FINE_ZERO = new FinePositionImpl(0, 0, 0);
++    BlockPosition BLOCK_ZERO = new BlockPositionImpl(0, 0, 0);
++
++    /**
++     * Gets the block x value for this position
++     *
++     * @return the block x value
++     */
++    int blockX();
++
++    /**
++     * Gets the block x value for this position
++     *
++     * @return the block x value
++     */
++    int blockY();
++
++    /**
++     * Gets the block x value for this position
++     *
++     * @return the block x value
++     */
++    int blockZ();
++
++    /**
++     * Gets the x value for this position
++     *
++     * @return the x value
++     */
++    double x();
++
++    /**
++     * Gets the y value for this position
++     *
++     * @return the y value
++     */
++    double y();
++
++    /**
++     * Gets the z value for this position
++     *
++     * @return the z value
++     */
++    double z();
++
++    /**
++     * Checks of this position represents a {@link BlockPosition}
++     *
++     * @return true if block
++     */
++    boolean isBlock();
++
++    /**
++     * Checks if this position represents a {@link FinePosition}
++     *
++     * @return true if fine
++     */
++    boolean isFine();
++
++    /**
++     * Returns a position offset by the specified amounts.
++     *
++     * @param x x value to offset
++     * @param y y value to offset
++     * @param z z value to offset
++     * @return the offset position
++     */
++    @NotNull Position offset(int x, int y, int z);
++
++    /**
++     * Returns a position offset by the specified amounts.
++     *
++     * @param x x value to offset
++     * @param y y value to offset
++     * @param z z value to offset
++     * @return the offset position
++     */
++    @NotNull FinePosition offset(double x, double y, double z);
++
++    /**
++     * Returns a new position at the center of the block position this represents
++     *
++     * @return a new center position
++     */
++    @Contract(value = "-> new", pure = true)
++    default @NotNull FinePosition toCenter() {
++        return new FinePositionImpl(this.blockX() + 0.5, this.blockY() + 0.5, this.blockZ() + 0.5);
++    }
++
++    /**
++     * Returns the block position of this position
++     * or itself if it already is a block position
++     *
++     * @return the block position
++     */
++    @Contract(pure = true)
++    @NotNull BlockPosition toBlock();
++
++    /**
++     * Converts this position to a vector
++     *
++     * @return a new vector
++     */
++    @Contract(value = "-> new", pure = true)
++    default @NotNull Vector toVector() {
++        return new Vector(this.x(), this.y(), this.z());
++    }
++
++    /**
++     * Creates a new location object at this position with the specified world
++     *
++     * @param world the world for the location object
++     * @return a new location
++     */
++    @Contract(value = "_ -> new", pure = true)
++    default @NotNull Location toLocation(@NotNull World world) {
++        return new Location(world, this.x(), this.y(), this.z());
++    }
++
++    /**
++     * Creates a position at the coordinates
++     *
++     * @param x x coord
++     * @param y y coord
++     * @param z z coord
++     * @return a position with those coords
++     */
++    @Contract(value = "_, _, _ -> new", pure = true)
++    static @NotNull BlockPosition block(int x, int y, int z) {
++        return new BlockPositionImpl(x, y, z);
++    }
++
++    /**
++     * Creates a position from the location.
++     *
++     * @param location the location to copy the position of
++     * @return a new position at that location
++     */
++    @Contract(value = "_ -> new", pure = true)
++    static @NotNull BlockPosition block(@NotNull Location location) {
++        return new BlockPositionImpl(location.getBlockX(), location.getBlockY(), location.getBlockZ());
++    }
++
++    /**
++     * Creates a position at the coordinates
++     *
++     * @param x x coord
++     * @param y y coord
++     * @param z z coord
++     * @return a position with those coords
++     */
++    @Contract(value = "_, _, _ -> new", pure = true)
++    static @NotNull FinePosition fine(double x, double y, double z) {
++        return new FinePositionImpl(x, y, z);
++    }
++
++    /**
++     * Creates a position from the location.
++     *
++     * @param location the location to copy the position of
++     * @return a new position at that location
++     */
++    @Contract(value = "_ -> new", pure = true)
++    static @NotNull FinePosition fine(@NotNull Location location) {
++        return new FinePositionImpl(location.getX(), location.getY(), location.getZ());
++    }
++}
+diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Location.java
++++ b/src/main/java/org/bukkit/Location.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+  * magnitude than 360 are valid, but may be normalized to any other equivalent
+  * representation by the implementation.
+  */
+-public class Location implements Cloneable, ConfigurationSerializable {
++public class Location implements Cloneable, ConfigurationSerializable, io.papermc.paper.math.FinePosition { // Paper
+     private Reference<World> world;
+     private double x;
+     private double y;
+@@ -0,0 +0,0 @@ public class Location implements Cloneable, ConfigurationSerializable {
+         }
+         return pitch;
+     }
++
++    // Paper - add Position
++    @Override
++    public double x() {
++        return this.getX();
++    }
++
++    @Override
++    public double y() {
++        return this.getY();
++    }
++
++    @Override
++    public double z() {
++        return this.getZ();
++    }
++
++    @Override
++    public @NotNull Location toLocation(@NotNull World world) {
++        return new Location(world, this.x(), this.y(), this.z(), this.getYaw(), this.getPitch());
++    }
++    // Paper end
+ }

patches/unapplied/api/Add-PrePlayerAttackEntityEvent.patch

@@ -0,0 +1,99 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Sun, 18 Sep 2022 13:10:28 -0400
+Subject: [PATCH] Add PrePlayerAttackEntityEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/player/PrePlayerAttackEntityEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.player;
++
++import org.bukkit.entity.Entity;
++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.NotNull;
++
++/**
++ * Called when the player tries to attack an entity.
++ *
++ * This occurs before any of the damage logic, so cancelling this event
++ * will prevent any sort of sounds from being played when attacking.
++ *
++ * 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
++ */
++public class PrePlayerAttackEntityEvent extends PlayerEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    @NotNull
++    private final Entity attacked;
++    private boolean cancelled;
++    private final boolean willAttack;
++
++    public PrePlayerAttackEntityEvent(@NotNull Player who, @NotNull Entity attacked, boolean willAttack) {
++        super(who);
++        this.attacked = attacked;
++        this.willAttack = willAttack;
++        this.cancelled = !willAttack;
++    }
++
++    /**
++     * Gets the entity that was attacked in this event.
++     * @return entity that was attacked
++     */
++    @NotNull
++    public Entity getAttacked() {
++        return this.attacked;
++    }
++
++    /**
++     * Gets if this entity will be attacked normally.
++     * Entities like falling sand will return 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
++     * @return if the entity will actually be attacked
++     */
++    public boolean willAttack() {
++        return this.willAttack;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    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/unapplied/api/Add-PrepareResultEvent-PrepareGrindstoneEvent.patch

@@ -0,0 +1,196 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 3 Jul 2020 11:58:56 -0500
+Subject: [PATCH] Add PrepareResultEvent / PrepareGrindstoneEvent
+
+Adds a new event for all crafting stations that generate a result slot item
+
+Anvil, Grindstone and Smithing now extend this event
+
+Grindstone is a backwards compat from a previous PrepareGrindstoneEvent
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/inventory/PrepareGrindstoneEvent.java b/src/main/java/com/destroystokyo/paper/event/inventory/PrepareGrindstoneEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/inventory/PrepareGrindstoneEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.inventory;
++
++import org.bukkit.inventory.GrindstoneInventory;
++import org.bukkit.inventory.InventoryView;
++import org.bukkit.inventory.ItemStack;
++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
++public class PrepareGrindstoneEvent extends PrepareResultEvent {
++
++    public PrepareGrindstoneEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
++        super(inventory, result);
++    }
++
++    @NotNull
++    @Override
++    public GrindstoneInventory getInventory() {
++        return (GrindstoneInventory) super.getInventory();
++    }
++
++}
+diff --git a/src/main/java/com/destroystokyo/paper/event/inventory/PrepareResultEvent.java b/src/main/java/com/destroystokyo/paper/event/inventory/PrepareResultEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/inventory/PrepareResultEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.inventory;
++
++import org.bukkit.event.inventory.PrepareInventoryResultEvent;
++import org.bukkit.inventory.InventoryView;
++import org.bukkit.inventory.ItemStack;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when an item is put in an inventory containing a result slot
++ */
++public class PrepareResultEvent extends PrepareInventoryResultEvent {
++
++    // HandlerList on PrepareInventoryResultEvent to ensure api compat
++    public PrepareResultEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
++        super(inventory, result);
++    }
++
++    /**
++     * Get result item, may be null.
++     *
++     * @return result item
++     */
++    @Nullable
++    public ItemStack getResult() {
++        return super.getResult();
++    }
++
++    /**
++     * Set result item, may be null.
++     *
++     * @param result result item
++     */
++    public void setResult(@Nullable ItemStack result) {
++        super.setResult(result);
++    }
++}
+diff --git a/src/main/java/org/bukkit/event/inventory/PrepareAnvilEvent.java b/src/main/java/org/bukkit/event/inventory/PrepareAnvilEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/inventory/PrepareAnvilEvent.java
++++ b/src/main/java/org/bukkit/event/inventory/PrepareAnvilEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Called when an item is put in a slot for repair by an anvil.
+  */
+-public class PrepareAnvilEvent extends PrepareInventoryResultEvent {
++public class PrepareAnvilEvent extends com.destroystokyo.paper.event.inventory.PrepareResultEvent {
+ 
+-    private static final HandlerList handlers = new HandlerList();
++    // Paper - move HandlerList to PrepareInventoryResultEvent
+ 
+     public PrepareAnvilEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
+         super(inventory, result);
+@@ -0,0 +0,0 @@ public class PrepareAnvilEvent extends PrepareInventoryResultEvent {
+         return (AnvilInventory) super.getInventory();
+     }
+ 
+-    @NotNull
+-    @Override
+-    public HandlerList getHandlers() {
+-        return handlers;
+-    }
+-
+-    @NotNull
+-    public static HandlerList getHandlerList() {
+-        return handlers;
+-    }
++    // Paper - move HandlerList to PrepareInventoryResultEvent
+ }
+diff --git a/src/main/java/org/bukkit/event/inventory/PrepareGrindstoneEvent.java b/src/main/java/org/bukkit/event/inventory/PrepareGrindstoneEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/inventory/PrepareGrindstoneEvent.java
++++ b/src/main/java/org/bukkit/event/inventory/PrepareGrindstoneEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Called when an item is put in a slot for repair or unenchanting in a grindstone.
+  */
+-public class PrepareGrindstoneEvent extends PrepareInventoryResultEvent {
++public class PrepareGrindstoneEvent extends com.destroystokyo.paper.event.inventory.PrepareGrindstoneEvent { // Paper
+ 
+-    private static final HandlerList handlers = new HandlerList();
++    // Paper - move HandlerList to PrepareInventoryResultEvent
+ 
+     public PrepareGrindstoneEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
+         super(inventory, result);
+@@ -0,0 +0,0 @@ public class PrepareGrindstoneEvent extends PrepareInventoryResultEvent {
+         return (GrindstoneInventory) super.getInventory();
+     }
+ 
+-    @NotNull
+-    @Override
+-    public HandlerList getHandlers() {
+-        return handlers;
+-    }
+-
+-    @NotNull
+-    public static HandlerList getHandlerList() {
+-        return handlers;
+-    }
++    // Paper - move HandlerList to PrepareInventoryResultEvent
+ }
+diff --git a/src/main/java/org/bukkit/event/inventory/PrepareInventoryResultEvent.java b/src/main/java/org/bukkit/event/inventory/PrepareInventoryResultEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/inventory/PrepareInventoryResultEvent.java
++++ b/src/main/java/org/bukkit/event/inventory/PrepareInventoryResultEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ 
+ /**
+  * Called when an item is put in a slot and the result is calculated.
++ * @deprecated use {@link com.destroystokyo.paper.event.inventory.PrepareResultEvent}
+  */
++@Deprecated @org.bukkit.Warning(false) // Paper
+ public class PrepareInventoryResultEvent extends InventoryEvent {
+ 
+     private static final HandlerList handlers = new HandlerList();
+diff --git a/src/main/java/org/bukkit/event/inventory/PrepareSmithingEvent.java b/src/main/java/org/bukkit/event/inventory/PrepareSmithingEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/inventory/PrepareSmithingEvent.java
++++ b/src/main/java/org/bukkit/event/inventory/PrepareSmithingEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Called when an item is put in a slot for upgrade by a Smithing Table.
+  */
+-public class PrepareSmithingEvent extends PrepareInventoryResultEvent {
++public class PrepareSmithingEvent extends com.destroystokyo.paper.event.inventory.PrepareResultEvent {
+ 
+-    private static final HandlerList handlers = new HandlerList();
++    // Paper - move HandlerList ot PrepareInventoryResultEvent
+ 
+     public PrepareSmithingEvent(@NotNull InventoryView inventory, @Nullable ItemStack result) {
+         super(inventory, result);
+@@ -0,0 +0,0 @@ public class PrepareSmithingEvent extends PrepareInventoryResultEvent {
+         return (SmithingInventory) super.getInventory();
+     }
+ 
+-    @NotNull
+-    @Override
+-    public HandlerList getHandlers() {
+-        return handlers;
+-    }
+-
+-    @NotNull
+-    public static HandlerList getHandlerList() {
+-        return handlers;
+-    }
++    // Paper - move HandlerList to PrepareInventoryResultEvent
+ }

patches/unapplied/api/Add-ProjectileCollideEvent.patch

@@ -0,0 +1,82 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Techcable <Techcable@outlook.com>
+Date: Fri, 16 Dec 2016 21:25:39 -0600
+Subject: [PATCH] Add ProjectileCollideEvent
+
+Now deprecated and replaced with ProjectileHitEvent
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/ProjectileCollideEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/ProjectileCollideEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/ProjectileCollideEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.Projectile;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++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
++ * @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 {
++    @NotNull private final Entity collidedWith;
++
++    /**
++     * Get the entity the projectile collided with
++     *
++     * @return the entity collided with
++     */
++    @NotNull
++    public Entity getCollidedWith() {
++        return collidedWith;
++    }
++
++    public ProjectileCollideEvent(@NotNull Projectile what, @NotNull Entity collidedWith) {
++        super(what);
++        this.collidedWith = collidedWith;
++    }
++
++    /**
++     * Get the projectile that collided
++     *
++     * @return the projectile that collided
++     */
++    @NotNull
++    public Projectile getEntity() {
++        return (Projectile) super.getEntity();
++    }
++
++    private static final HandlerList handlerList = new HandlerList();
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlerList;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlerList;
++    }
++
++    private boolean cancelled = false;
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++}

patches/unapplied/api/Add-PufferFishStateChangeEvent.patch

@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: HexedHero <6012891+HexedHero@users.noreply.github.com>
+Date: Mon, 10 May 2021 16:58:38 +0100
+Subject: [PATCH] Add PufferFishStateChangeEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/PufferFishStateChangeEvent.java b/src/main/java/io/papermc/paper/event/entity/PufferFishStateChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/PufferFishStateChangeEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import org.bukkit.entity.PufferFish;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++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;
++
++    public PufferFishStateChangeEvent(@NotNull PufferFish entity, int newPuffState) {
++        super(entity);
++        this.newPuffState = newPuffState;
++    }
++
++    @NotNull
++    @Override
++    public PufferFish getEntity() {
++        return (PufferFish) entity;
++    }
++
++    /**
++     * Get the <strong>new</strong> puff state of the {@link PufferFish}.
++     * <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() {
++        return this.newPuffState;
++    }
++
++    /**
++     * Get if the {@link PufferFish} is going to inflate.
++     * @return If its going to inflate
++     */
++    public boolean isInflating() {
++        return getNewPuffState() > getEntity().getPuffState();
++    }
++
++    /**
++     * Get if the {@link PufferFish} is going to deflate.
++     * @return If its going to deflate
++     */
++    public boolean isDeflating() {
++        return getNewPuffState() < getEntity().getPuffState();
++    }
++
++    /**
++     * Set whether or not to cancel the {@link PufferFish} (in/de)flating.
++     *
++     * @param cancel true if you wish to cancel the (in/de)flation
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-Raw-Byte-Entity-Serialization.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sun, 24 Oct 2021 16:19:26 -0400
+Subject: [PATCH] Add Raw Byte Entity Serialization
+
+
+diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/UnsafeValues.java
++++ b/src/main/java/org/bukkit/UnsafeValues.java
+@@ -0,0 +0,0 @@ public interface UnsafeValues {
+ 
+     ItemStack deserializeItem(byte[] data);
+ 
++    byte[] serializeEntity(org.bukkit.entity.Entity entity);
++
++    default org.bukkit.entity.Entity deserializeEntity(byte[] data, World world) {
++        return deserializeEntity(data, world, false);
++    }
++
++    org.bukkit.entity.Entity deserializeEntity(byte[] data, World world, boolean preserveUUID);
++
+     /**
+      * Creates and returns the next EntityId available.
+      * <p>
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -0,0 +0,0 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+      * @return players in tracking range
+      */
+     @NotNull Set<Player> getTrackedPlayers();
++
++    /**
++     * Spawns the entity in the world at the given {@link Location} with the default spawn reason.
++     * <p>
++     * This will not spawn the entity if the entity is already spawned or has previously been despawned.
++     * <p>
++     * Also, this method will fire the same events as a normal entity spawn.
++     *
++     * @param location The location to spawn the entity at.
++     * @return Whether the entity was successfully spawned.
++     */
++    public default boolean spawnAt(@NotNull Location location) {
++        return spawnAt(location, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DEFAULT);
++    }
++
++    /**
++     * Spawns the entity in the world at the given {@link Location} with the reason given.
++     * <p>
++     * This will not spawn the entity if the entity is already spawned or has previously been despawned.
++     * <p>
++     * Also, this method will fire the same events as a normal entity spawn.
++     *
++     * @param location The location to spawn the entity at.
++     * @param reason   The reason for the entity being spawned.
++     * @return Whether the entity was successfully spawned.
++     */
++    public boolean spawnAt(@NotNull Location location, @NotNull org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason);
+     // Paper end
+ }

patches/unapplied/api/Add-Raw-Byte-ItemStack-Serialization.patch

@@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Thu, 30 Apr 2020 16:56:31 +0200
+Subject: [PATCH] Add Raw Byte ItemStack Serialization
+
+Serializes using NBT which is safer for server data migrations than bukkits format.
+
+diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/UnsafeValues.java
++++ b/src/main/java/org/bukkit/UnsafeValues.java
+@@ -0,0 +0,0 @@ public interface UnsafeValues {
+     default com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() {
+         return new com.destroystokyo.paper.util.VersionFetcher.DummyVersionFetcher();
+     }
++
++    byte[] serializeItem(ItemStack item);
++
++    ItemStack deserializeItem(byte[] data);
+     // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/inventory/ItemStack.java b/src/main/java/org/bukkit/inventory/ItemStack.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/ItemStack.java
++++ b/src/main/java/org/bukkit/inventory/ItemStack.java
+@@ -0,0 +0,0 @@ public class ItemStack implements Cloneable, ConfigurationSerializable, Translat
+         return Bukkit.getServer().getItemFactory().ensureServerConversions(this);
+     }
+ 
++    /**
++     * Deserializes this itemstack from raw NBT bytes. NBT is safer for data migrations as it will
++     * use the built in data converter instead of bukkits dangerous serialization system.
++     *
++     * This expects that the DataVersion was stored on the root of the Compound, as saved from
++     * the {@link #serializeAsBytes()} API returned.
++     * @param bytes bytes representing an item in NBT
++     * @return ItemStack migrated to this version of Minecraft if needed.
++     */
++    @NotNull
++    public static ItemStack deserializeBytes(@NotNull byte[] bytes) {
++        return org.bukkit.Bukkit.getUnsafe().deserializeItem(bytes);
++    }
++
++    /**
++     * Serializes this itemstack to raw bytes in NBT. NBT is safer for data migrations as it will
++     * use the built in data converter instead of bukkits dangerous serialization system.
++     * @return bytes representing this item in NBT.
++     */
++    @NotNull
++    public byte[] serializeAsBytes() {
++        return org.bukkit.Bukkit.getUnsafe().serializeItem(this);
++    }
++
+     /**
+      * Gets the Display name as seen in the Client.
+      * Currently the server only supports the English language. To override this,

patches/unapplied/api/Add-Sneaking-API-for-Entities.patch

@@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dawon <dawon@dawon.eu>
+Date: Wed, 19 Oct 2022 23:36:42 +0200
+Subject: [PATCH] Add Sneaking API for Entities
+
+
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -0,0 +0,0 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
+     @NotNull
+     Pose getPose();
+ 
++    // Paper start
++    /**
++     * Returns if the entity is in sneak mode
++     *
++     * @return true if the entity is in sneak mode
++     */
++    boolean isSneaking();
++
++    /**
++     * Sets the sneak mode the entity.
++     * <p>
++     * Note: For most Entities this does not update Entity's pose
++     * and just makes its name tag less visible.
++     *
++     * @param sneak true if the entity should be sneaking
++     */
++    void setSneaking(boolean sneak);
++    // Paper end
++
+     /**
+      * Get the category of spawn to which this entity belongs.
+      *
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      *
+      * @return true if player is in sneak mode
+      */
++    @Override // Paper
+     public boolean isSneaking();
+ 
+     /**
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      *
+      * @param sneak true if player should appear sneaking
+      */
++    @Override // Paper
+     public void setSneaking(boolean sneak);
+ 
+     /**

patches/unapplied/api/Add-String-based-Action-Bar-API.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 20 Dec 2016 15:55:55 -0500
+Subject: [PATCH] Add String based Action Bar API
+
+
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+     public void sendMap(@NotNull MapView map);
+ 
+     // Paper start
++
++    /**
++     * Sends an Action Bar message to the client.
++     *
++     * Use Section symbols for legacy color codes to send formatting.
++     *
++     * @param message The message to send
++     * @deprecated use {@link #sendActionBar(net.kyori.adventure.text.Component)}
++     */
++    @Deprecated
++    public void sendActionBar(@NotNull String message);
++
++    /**
++     * Sends an Action Bar message to the client.
++     *
++     * Use supplied alternative character to the section symbol to represent legacy color codes.
++     *
++     * @param alternateChar Alternate symbol such as '&'
++     * @param message The message to send
++     * @deprecated use {@link #sendActionBar(net.kyori.adventure.text.Component)}
++     */
++    @Deprecated
++    public void sendActionBar(char alternateChar, @NotNull String message);
++
++    /**
++     * Sends an Action Bar message to the client.
++     *
++     * @param message The components to send
++     * @deprecated use {@link #sendActionBar(net.kyori.adventure.text.Component)}
++     */
++    @Deprecated
++    public void sendActionBar(@NotNull net.md_5.bungee.api.chat.BaseComponent... message);
++
+     /**
+      * Sends the component to the player
+      *
+@@ -0,0 +0,0 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+     /**
+      * Sends an array of components as a single message to the specified screen position of this player
+      *
++     * @deprecated This is unlikely the API you want to use. See {@link #sendActionBar(String)} for a more proper Action Bar API. This deprecated API may send unsafe items to the client.
+      * @param position the screen position
+      * @param components the components to send
+      */
++    @Deprecated
+     public default void sendMessage(net.md_5.bungee.api.ChatMessageType position, net.md_5.bungee.api.chat.BaseComponent... components) {
+         spigot().sendMessage(position, components);
+     }

patches/unapplied/api/Add-StructuresLocateEvent.patch

@@ -0,0 +1,522 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dfsek <dfsek@protonmail.com>
+Date: Tue, 15 Sep 2020 21:59:16 -0700
+Subject: [PATCH] Add StructuresLocateEvent
+
+Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
+
+diff --git a/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java b/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.world;
++
++import org.bukkit.Location;
++import org.bukkit.StructureType;
++import org.bukkit.World;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.world.WorldEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called <b>before</b> a structure/feature is located.
++ * This happens when:
++ * <ul>
++ *     <li>The /locate command is used.<br></li>
++ *     <li>An Eye of Ender is used.</li>
++ *     <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)
++public class StructureLocateEvent extends WorldEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++    private final Location origin;
++    private Location result = null;
++    private StructureType type;
++    private int radius;
++    private boolean findUnexplored;
++    private boolean cancelled = false;
++
++    public StructureLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull StructureType structureType, int radius, boolean findUnexplored) {
++        super(world);
++        this.origin = origin;
++        this.type = structureType;
++        this.radius = radius;
++        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.
++     * @see World#locateNearestStructure(Location, StructureType, int, boolean)
++     */
++    @Nullable
++    public Location getResult() {
++        return result;
++    }
++
++    /**
++     * Sets the result {@link Location}. This causes the search to be skipped, and the location passed here to be used as the result.
++     *
++     * @param result the {@link Location} of the structure.
++     */
++    public void setResult(@Nullable Location result) {
++        this.result = result;
++    }
++
++    /**
++     * Gets the {@link StructureType} that is to be located.
++     *
++     * @return the structure type.
++     */
++    @NotNull
++    public StructureType getType() {
++        return type;
++    }
++
++    /**
++     * Sets the {@link StructureType} that is to be located.
++     *
++     * @param type the structure type.
++     */
++    public void setType(@NotNull StructureType type) {
++        this.type = type;
++    }
++
++    /**
++     * Gets the {@link Location} from which the search is to be conducted.
++     *
++     * @return {@link Location} where search begins
++     */
++    @NotNull
++    public Location getOrigin() {
++        return origin;
++    }
++
++    /**
++     * Gets the search radius in which to attempt locating the structure.
++     * <p>
++     * This radius may not always be obeyed during the structure search!
++     *
++     * @return the search radius.
++     */
++    public int getRadius() {
++        return radius;
++    }
++
++    /**
++     * Sets the search radius in which to attempt locating the structure.
++     * <p>
++     * This radius may not always be obeyed during the structure search!
++     *
++     * @param radius the search radius.
++     */
++    public void setRadius(int radius) {
++        this.radius = radius;
++    }
++
++    /**
++     * Gets whether to search exclusively for unexplored structures.
++     * <p>
++     * As with the search radius, this value is not always obeyed.
++     *
++     * @return Whether to search for only unexplored structures.
++     */
++    public boolean shouldFindUnexplored() {
++        return findUnexplored;
++    }
++
++    /**
++     * Sets whether to search exclusively for unexplored structures.
++     * <p>
++     * As with the search radius, this value is not always obeyed.
++     *
++     * @param findUnexplored Whether to search for only unexplored structures.
++     */
++    public void setFindUnexplored(boolean findUnexplored) {
++        this.findUnexplored = findUnexplored;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++}
+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
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.world;
++
++import io.papermc.paper.math.Position;
++import io.papermc.paper.util.TransformingRandomAccessList;
++import io.papermc.paper.world.structure.ConfiguredStructure;
++import java.util.Collections;
++import java.util.List;
++import java.util.Objects;
++import org.bukkit.Location;
++import org.bukkit.World;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.world.WorldEvent;
++import org.bukkit.generator.structure.Structure;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++import org.jetbrains.annotations.UnmodifiableView;
++
++/**
++ * Called <b>before</b> a set of configured structures is located.
++ * This happens when:
++ * <ul>
++ *     <li>The /locate command is used.<br></li>
++ *     <li>An Eye of Ender is used.</li>
++ *     <li>An Explorer/Treasure Map is activated.</li>
++ *     <li>A dolphin swims to a treasure location.</li>
++ *     <li>A trade is done with a villager for a map.</li>
++ *     <li>{@link World#locateNearestStructure(Location, org.bukkit.StructureType, int, boolean)} is invoked.</li>
++ * </ul>
++ */
++public class StructuresLocateEvent extends WorldEvent implements Cancellable {
++
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Location origin;
++    private Result result;
++    private List<Structure> structures;
++    private List<ConfiguredStructure> legacy$structures;
++    private int radius;
++    private boolean findUnexplored;
++    private boolean cancelled;
++
++    public StructuresLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull List<Structure> structures, int radius, boolean findUnexplored) {
++        super(world);
++        this.origin = origin;
++        this.setStructures(structures);
++        this.radius = radius;
++        this.findUnexplored = findUnexplored;
++    }
++
++    /**
++     * Gets the {@link Location} from which the search is to be conducted.
++     *
++     * @return {@link Location} where search begins
++     */
++    public @NotNull Location getOrigin() {
++        return this.origin;
++    }
++
++    /**
++     * Gets the {@link Location} and {@link Structure} set as the result, if it was defined.
++     * <p>
++     * 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)
++     */
++    public @Nullable Result getResult() {
++        return this.result;
++    }
++
++    /**
++     * Sets the result {@link Location} and {@link Structure}. This causes the search to be
++     * skipped, and the result object passed here to be used as the result.
++     *
++     * @param result the {@link Location} and {@link Structure} of the search.
++     */
++    public void setResult(@Nullable Result result) {
++        this.result = result;
++    }
++
++    /**
++     * Gets a mutable list of ConfiguredStructures that are valid targets for the search.
++     *
++     * @return a mutable list of ConfiguredStructures
++     * @deprecated use {@link #getStructures()}
++     */
++    @Deprecated(forRemoval = true)
++    public @NotNull List<ConfiguredStructure> getConfiguredStructures() {
++        return this.legacy$structures;
++    }
++
++    /**
++     * Sets the list of ConfiguredStructures that are valid targets for the search.
++     *
++     * @param configuredStructures a list of ConfiguredStructure targets
++     * @deprecated use {@link #setStructures(List)}
++     */
++    @Deprecated(forRemoval = true)
++    public void setConfiguredStructures(@NotNull List<ConfiguredStructure> configuredStructures) {
++        this.setStructures(configuredStructures.stream().map(ConfiguredStructure::toModern).toList());
++    }
++
++    /**
++     * Gets an unmodifiable list of Structures that are valid targets for the search.
++     *
++     * @return an unmodifiable list of Structures
++     */
++    public @NotNull @UnmodifiableView List<Structure> getStructures() {
++        return Collections.unmodifiableList(this.structures);
++    }
++
++    /**
++     * Sets the list of Structures that are valid targets for the search.
++     *
++     * @param structures a list of Structures targets
++     */
++    public void setStructures(final @NotNull List<Structure> structures) {
++        this.structures = structures;
++        this.legacy$structures = new TransformingRandomAccessList<>(this.structures, ConfiguredStructure::fromModern, ConfiguredStructure::toModern);
++    }
++
++    /**
++     * Gets the search radius in which to attempt locating the structure.
++     * <p>
++     * This radius may not always be obeyed during the structure search!
++     *
++     * @return the search radius (in chunks)
++     */
++    public int getRadius() {
++        return this.radius;
++    }
++
++    /**
++     * Sets the search radius in which to attempt locating the structure.
++     * <p>
++     * This radius may not always be obeyed during the structure search!
++     *
++     * @param radius the search radius (in chunks)
++     */
++    public void setRadius(int radius) {
++        this.radius = radius;
++    }
++
++    /**
++     * Gets whether to search exclusively for unexplored structures.
++     * <p>
++     * As with the search radius, this value is not always obeyed.
++     *
++     * @return Whether to search for only unexplored structures.
++     */
++    public boolean shouldFindUnexplored() {
++        return this.findUnexplored;
++    }
++
++    /**
++     * Sets whether to search exclusively for unexplored structures.
++     * <p>
++     * As with the search radius, this value is not always obeyed.
++     *
++     * @param findUnexplored Whether to search for only unexplored structures.
++     */
++    public void setFindUnexplored(boolean findUnexplored) {
++        this.findUnexplored = findUnexplored;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @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;
++    }
++
++    /**
++     * Result for {@link StructuresLocateEvent}.
++     */
++    public record Result(@NotNull Position pos, @NotNull Structure structure) {
++
++        @Deprecated(forRemoval = true)
++        public Result(final @NotNull Location position, @NotNull ConfiguredStructure configuredStructure) {
++            this(position, configuredStructure.toModern());
++        }
++
++        @Deprecated(forRemoval = true)
++        public @NotNull ConfiguredStructure configuredStructure() {
++            return Objects.requireNonNull(ConfiguredStructure.fromModern(this.structure), "Please use the newer Structure API");
++        }
++
++        @Deprecated(forRemoval = true)
++        public @NotNull Location position() {
++            //noinspection DataFlowIssue
++            return this.pos.toLocation(null);
++        }
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java b/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.world.structure;
++
++import io.papermc.paper.registry.Reference;
++import java.util.Objects;
++import org.bukkit.Keyed;
++import org.bukkit.NamespacedKey;
++import org.bukkit.Registry;
++import org.bukkit.StructureType;
++import org.bukkit.generator.structure.Structure;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Represents a configured structure each with a
++ * {@link StructureType}. Multiple ConfiguredStructures can have
++ * the same {@link StructureType}.
++ * @deprecated use {@link Structure}
++ */
++@Deprecated(forRemoval = true)
++public final class ConfiguredStructure implements Keyed {
++
++    public static final Reference<ConfiguredStructure> PILLAGER_OUTPOST = create("pillager_outpost");
++    public static final Reference<ConfiguredStructure> MINESHAFT = create("mineshaft");
++    public static final Reference<ConfiguredStructure> MINESHAFT_MESA = create("mineshaft_mesa");
++    public static final Reference<ConfiguredStructure> WOODLAND_MANSION = create("mansion");
++    public static final Reference<ConfiguredStructure> JUNGLE_TEMPLE = create("jungle_pyramid");
++    public static final Reference<ConfiguredStructure> DESERT_PYRAMID = create("desert_pyramid");
++    public static final Reference<ConfiguredStructure> IGLOO = create("igloo");
++    public static final Reference<ConfiguredStructure> SHIPWRECK = create("shipwreck");
++    public static final Reference<ConfiguredStructure> SHIPWRECK_BEACHED = create("shipwreck_beached");
++    public static final Reference<ConfiguredStructure> SWAMP_HUT = create("swamp_hut");
++    public static final Reference<ConfiguredStructure> STRONGHOLD = create("stronghold");
++    public static final Reference<ConfiguredStructure> OCEAN_MONUMENT = create("monument");
++    public static final Reference<ConfiguredStructure> OCEAN_RUIN_COLD = create("ocean_ruin_cold");
++    public static final Reference<ConfiguredStructure> OCEAN_RUIN_WARM = create("ocean_ruin_warm");
++    public static final Reference<ConfiguredStructure> FORTRESS = create("fortress");
++    public static final Reference<ConfiguredStructure> NETHER_FOSSIL = create("nether_fossil");
++    public static final Reference<ConfiguredStructure> END_CITY = create("end_city");
++    public static final Reference<ConfiguredStructure> BURIED_TREASURE = create("buried_treasure");
++    public static final Reference<ConfiguredStructure> BASTION_REMNANT = create("bastion_remnant");
++    public static final Reference<ConfiguredStructure> VILLAGE_PLAINS = create("village_plains");
++    public static final Reference<ConfiguredStructure> VILLAGE_DESERT = create("village_desert");
++    public static final Reference<ConfiguredStructure> VILLAGE_SAVANNA = create("village_savanna");
++    public static final Reference<ConfiguredStructure> VILLAGE_SNOWY = create("village_snowy");
++    public static final Reference<ConfiguredStructure> VILLAGE_TAIGA = create("village_taiga");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_STANDARD = create("ruined_portal");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_DESERT = create("ruined_portal_desert");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_JUNGLE = create("ruined_portal_jungle");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_SWAMP = create("ruined_portal_swamp");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_MOUNTAIN = create("ruined_portal_mountain");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_OCEAN = create("ruined_portal_ocean");
++    public static final Reference<ConfiguredStructure> RUINED_PORTAL_NETHER = create("ruined_portal_nether");
++    // public static final Reference<ConfiguredStructure> ANCIENT_CITY = create("ancient_city"); // TODO remove when upstream adds "jigsaw" StructureType
++
++    private final NamespacedKey key;
++    private final StructureType structureType;
++
++    ConfiguredStructure(@NotNull NamespacedKey key, @NotNull StructureType structureType) {
++        this.key = key;
++        this.structureType = structureType;
++    }
++
++    @Override
++    public @NotNull NamespacedKey getKey() {
++        return this.key;
++    }
++
++    /**
++     * Gets the structure type for this configure structure.
++     *
++     * @return the structure type
++     */
++    public @NotNull StructureType getStructureType() {
++        return this.structureType;
++    }
++
++    @Override
++    public boolean equals(Object o) {
++        if (this == o) return true;
++        if (o == null || getClass() != o.getClass()) return false;
++        ConfiguredStructure structure = (ConfiguredStructure) o;
++        return this.key.equals(structure.key) && this.structureType.equals(structure.structureType);
++    }
++
++    @Override
++    public int hashCode() {
++        return Objects.hash(this.key, this.structureType);
++    }
++
++    @Override
++    public String toString() {
++        return "ConfiguredStructure{" +
++            "key=" + this.key +
++            ", structureType=" + this.structureType +
++            '}';
++    }
++
++    private static @NotNull Reference<ConfiguredStructure> create(@NotNull String name) {
++        return Reference.create(Registry.CONFIGURED_STRUCTURE, NamespacedKey.minecraft(name));
++    }
++
++    @ApiStatus.Internal
++    public @NotNull Structure toModern() {
++        return Objects.requireNonNull(Registry.STRUCTURE.get(this.key));
++    }
++
++    @ApiStatus.Internal
++    public static @Nullable ConfiguredStructure fromModern(@NotNull Structure structure) {
++        return Registry.CONFIGURED_STRUCTURE.get(structure.getKey());
++    }
++}
+diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Registry.java
++++ b/src/main/java/org/bukkit/Registry.java
+@@ -0,0 +0,0 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+             return GameEvent.getByKey(key);
+         }
+     };
++    // Paper start
++    /**
++     * Configured structures.
++     * @see io.papermc.paper.world.structure.ConfiguredStructure
++     * @deprecated use {@link #STRUCTURE}
++     */
++    @Deprecated(forRemoval = true)
++    Registry<io.papermc.paper.world.structure.ConfiguredStructure> CONFIGURED_STRUCTURE = Bukkit.getRegistry(io.papermc.paper.world.structure.ConfiguredStructure.class);
++    // Paper end
+ 
+     /**
+      * Get the object by its key.

patches/unapplied/api/Add-TNTPrimeEvent.patch

@@ -0,0 +1,126 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Sun, 15 Jul 2018 22:17:55 +0300
+Subject: [PATCH] Add TNTPrimeEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.block;
++
++import org.bukkit.block.Block;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.block.BlockEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when TNT block is about to turn into {@link org.bukkit.entity.TNTPrimed}
++ * <p>
++ * Cancelling it won't turn TNT into {@link org.bukkit.entity.TNTPrimed} and leaves
++ * the TNT block as-is
++ *
++ * @author Mark Vainomaa
++ */
++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;
++
++    public TNTPrimeEvent(@NotNull Block theBlock, @NotNull PrimeReason reason, @Nullable Entity primerEntity) {
++        super(theBlock);
++        this.reason = reason;
++        this.primerEntity = primerEntity;
++    }
++
++    /**
++     * Gets the TNT prime reason
++     *
++     * @return Prime reason
++     */
++    @NotNull
++    public PrimeReason getReason() {
++        return this.reason;
++    }
++
++    /**
++     * 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}
++     *
++     * @return The {@link Entity} who primed the TNT
++     */
++    @Nullable
++    public Entity getPrimerEntity() {
++        return this.primerEntity;
++    }
++
++    /**
++     * Gets whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     *
++     * @return Whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     */
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    /**
++     * Sets whether to cancel spawning {@link org.bukkit.entity.TNTPrimed} or not
++     *
++     * @param cancel whether spawning {@link org.bukkit.entity.TNTPrimed} should be cancelled or not
++     */
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Nullable
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @Nullable
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++    public enum PrimeReason {
++        /**
++         * When TNT prime was caused by other explosion (chain reaction)
++         */
++        EXPLOSION,
++
++        /**
++         * When TNT prime was caused by fire
++         */
++        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
++         */
++        ITEM,
++
++        /**
++         * When TNT prime was caused by an {@link Entity} shooting TNT
++         * using a bow with {@link org.bukkit.enchantments.Enchantment#ARROW_FIRE} enchantment
++         */
++        PROJECTILE,
++
++        /**
++         * When redstone power triggered the TNT prime
++         */
++        REDSTONE
++    }
++}

patches/unapplied/api/Add-TameableDeathMessageEvent.patch

@@ -0,0 +1,81 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Fri, 19 Mar 2021 23:25:38 -0400
+Subject: [PATCH] Add TameableDeathMessageEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/TameableDeathMessageEvent.java b/src/main/java/io/papermc/paper/event/entity/TameableDeathMessageEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/TameableDeathMessageEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import net.kyori.adventure.text.Component;
++import org.bukkit.entity.Tameable;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a {@link Tameable} dies and sends a death message.
++ */
++public class TameableDeathMessageEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList handlers = new HandlerList();
++    private boolean cancelled;
++    private Component deathMessage;
++
++    public TameableDeathMessageEvent(@NotNull Tameable what, @NotNull Component deathMessage) {
++        super(what);
++        this.deathMessage = deathMessage;
++    }
++
++    /**
++     * Set the death message that appears to the owner of the tameable.
++     *
++     * @param deathMessage Death message to appear
++     */
++    public void deathMessage(@NotNull Component deathMessage) {
++        this.deathMessage = deathMessage;
++    }
++
++    /**
++     * Get the death message that appears to the owner of the tameable.
++     *
++     * @return Death message to appear
++     */
++    @NotNull
++    public Component deathMessage() {
++        return deathMessage;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @NotNull
++    @Override
++    public Tameable getEntity() {
++        return (Tameable) super.getEntity();
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-TargetHitEvent-API.patch

@@ -0,0 +1,81 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Wed, 25 Nov 2020 23:21:32 -0800
+Subject: [PATCH] Add TargetHitEvent API
+
+
+diff --git a/src/main/java/io/papermc/paper/event/block/TargetHitEvent.java b/src/main/java/io/papermc/paper/event/block/TargetHitEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/block/TargetHitEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.block;
++
++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.NotNull;
++
++/**
++ * Called when a Target Block is hit by a projectile.
++ * <p>
++ * Cancelling this event will stop the Target from emitting a redstone signal,
++ * 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;
++    private int signalStrength;
++
++    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;
++    }
++
++    /**
++     * Sets the strength of the redstone signal to be emitted by the Target block
++     *
++     * @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]");
++        }
++        this.signalStrength = signalStrength;
++    }
++}

patches/unapplied/api/Add-ThrownEggHatchEvent.patch

@@ -0,0 +1,129 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William Blake Galbreath <blake.galbreath@gmail.com>
+Date: Sun, 9 Feb 2020 00:19:08 -0600
+Subject: [PATCH] Add ThrownEggHatchEvent
+
+Adds a new event similar to PlayerEggThrowEvent, but without the Player requirement
+(dispensers can throw eggs to hatch them, too).
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/ThrownEggHatchEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/ThrownEggHatchEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/ThrownEggHatchEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.entity.Egg;
++import org.bukkit.entity.EntityType;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a thrown egg might hatch.
++ * <p>
++ * 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 final Egg egg;
++    private boolean hatching;
++    private EntityType hatchType;
++    private byte numHatches;
++
++    public ThrownEggHatchEvent(@NotNull final Egg egg, final boolean hatching, final byte numHatches, @NotNull final EntityType hatchingType) {
++        this.egg = egg;
++        this.hatching = hatching;
++        this.numHatches = numHatches;
++        this.hatchType = hatchingType;
++    }
++
++    /**
++     * Gets the egg involved in this event.
++     *
++     * @return the egg involved in this event
++     */
++    @NotNull
++    public Egg getEgg() {
++        return egg;
++    }
++
++    /**
++     * Gets whether the egg is hatching or not. Will be what the server
++     * would've done without interaction.
++     *
++     * @return boolean Whether the egg is going to hatch or not
++     */
++    public boolean isHatching() {
++        return hatching;
++    }
++
++    /**
++     * Sets whether the egg will hatch or not.
++     *
++     * @param hatching true if you want the egg to hatch, false if you want it
++     *     not to
++     */
++    public void setHatching(boolean hatching) {
++        this.hatching = hatching;
++    }
++
++    /**
++     * Get the type of the mob being hatched (EntityType.CHICKEN by default)
++     *
++     * @return The type of the mob being hatched by the egg
++     */
++    @NotNull
++    public EntityType getHatchingType() {
++        return hatchType;
++    }
++
++    /**
++     * Change the type of mob being hatched by the egg
++     *
++     * @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!");
++        this.hatchType = hatchType;
++    }
++
++    /**
++     * 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
++     * </ul>
++     *
++     * @return The number of mobs going to be hatched by the egg
++     */
++    public byte getNumHatches() {
++        return 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
++     *
++     * @param numHatches The number of mobs coming out of the egg
++     */
++    public void setNumHatches(byte numHatches) {
++        this.numHatches = numHatches;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-Tick-TemporalUnit.patch

@@ -0,0 +1,157 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kieran Wallbanks <kieran.wallbanks@gmail.com>
+Date: Fri, 2 Apr 2021 17:28:58 +0100
+Subject: [PATCH] Add Tick TemporalUnit
+
+
+diff --git a/src/main/java/io/papermc/paper/util/Tick.java b/src/main/java/io/papermc/paper/util/Tick.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/util/Tick.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.util;
++
++import net.kyori.adventure.util.Ticks;
++import org.jetbrains.annotations.NotNull;
++
++import java.time.Duration;
++import java.time.temporal.ChronoUnit;
++import java.time.temporal.Temporal;
++import java.time.temporal.TemporalUnit;
++import java.util.Objects;
++
++/**
++ * A TemporalUnit that represents the target length of one server tick. This is defined
++ * as 50 milliseconds. Note that this class is not for measuring the length that a tick
++ * took, rather it is used for simple conversion between times and ticks.
++ * @see #tick()
++ */
++public final class Tick implements TemporalUnit {
++    private static final Tick INSTANCE = new Tick(Ticks.SINGLE_TICK_DURATION_MS);
++
++    private final long milliseconds;
++
++    /**
++     * Gets the instance of the tick temporal unit.
++     * @return the tick instance
++     */
++    public static @NotNull Tick tick() {
++        return INSTANCE;
++    }
++
++    /**
++     * Creates a new tick.
++     * @param length the length of the tick in milliseconds
++     * @see #tick()
++     */
++    private Tick(long length) {
++        this.milliseconds = length;
++    }
++
++    /**
++     * Creates a duration from an amount of ticks. This is shorthand for
++     * {@link Duration#of(long, TemporalUnit)} called with the amount of ticks and
++     * {@link #tick()}.
++     * @param ticks the amount of ticks
++     * @return the duration
++     */
++    public static @NotNull Duration of(long ticks) {
++        return Duration.of(ticks, INSTANCE);
++    }
++
++    /**
++     * Gets the number of whole ticks that occur in the provided duration. Note that this
++     * method returns an {@code int} as this is the unit that Minecraft stores ticks in.
++     * @param duration the duration
++     * @return the number of whole ticks in this duration
++     * @throws ArithmeticException if the duration is zero or an overflow occurs
++     */
++    public int fromDuration(@NotNull Duration duration) {
++        Objects.requireNonNull(duration, "duration cannot be null");
++        return Math.toIntExact(Math.floorDiv(duration.toMillis(), this.milliseconds));
++    }
++
++    @Override
++    public @NotNull Duration getDuration() {
++        return Duration.ofMillis(this.milliseconds);
++    }
++
++    // Note: This is a workaround in order to allow calculations with this duration.
++    // See: Duration#add
++    @Override
++    public boolean isDurationEstimated() {
++        return false;
++    }
++
++    @Override
++    public boolean isDateBased() {
++        return false;
++    }
++
++    @Override
++    public boolean isTimeBased() {
++        return true;
++    }
++
++    @SuppressWarnings("unchecked") // following ChronoUnit#addTo
++    @Override
++    public <R extends Temporal> @NotNull R addTo(@NotNull R temporal, long amount) {
++        return (R) temporal.plus(getDuration().multipliedBy(amount));
++    }
++
++    @Override
++    public long between(@NotNull Temporal start, @NotNull Temporal end) {
++        return start.until(end, ChronoUnit.MILLIS) / this.milliseconds;
++    }
++}
+diff --git a/src/test/java/io/papermc/paper/util/TickTest.java b/src/test/java/io/papermc/paper/util/TickTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/test/java/io/papermc/paper/util/TickTest.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.util;
++
++import java.time.Duration;
++import java.time.Instant;
++import java.time.temporal.ChronoUnit;
++
++import org.junit.Test;
++
++import static org.junit.Assert.assertEquals;
++
++public class TickTest {
++
++    @Test
++    public void testTickLength() {
++        assertEquals(50, Duration.of(1, Tick.tick()).toMillis());
++        assertEquals(100, Duration.of(2, Tick.tick()).toMillis());
++    }
++
++    @Test
++    public void testTickFromDuration() {
++        assertEquals(0, Tick.tick().fromDuration(Duration.ofMillis(0)));
++        assertEquals(0, Tick.tick().fromDuration(Duration.ofMillis(10)));
++        assertEquals(1, Tick.tick().fromDuration(Duration.ofMillis(60)));
++        assertEquals(2, Tick.tick().fromDuration(Duration.ofMillis(100)));
++    }
++
++    @Test
++    public void testAddTickToInstant() {
++        Instant now = Instant.now();
++        assertEquals(now, now.plus(0, Tick.tick()));
++        assertEquals(now.plus(50, ChronoUnit.MILLIS), now.plus(1, Tick.tick()));
++        assertEquals(now.plus(100, ChronoUnit.MILLIS), now.plus(2, Tick.tick()));
++        assertEquals(now.plus(150, ChronoUnit.MILLIS), now.plus(3, Tick.tick()));
++    }
++
++    @Test
++    public void testTicksBetweenInstants() {
++        Instant now = Instant.now();
++        assertEquals(0, now.until(now.plus(20, ChronoUnit.MILLIS), Tick.tick()));
++        assertEquals(1, now.until(now.plus(50, ChronoUnit.MILLIS), Tick.tick()));
++        assertEquals(1, now.until(now.plus(60, ChronoUnit.MILLIS), Tick.tick()));
++        assertEquals(2, now.until(now.plus(100, ChronoUnit.MILLIS), Tick.tick()));
++    }
++}

patches/unapplied/api/Add-UnknownCommandEvent.patch

@@ -0,0 +1,122 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sweepyoface <github@sweepy.pw>
+Date: Sat, 17 Jun 2017 18:48:06 -0400
+Subject: [PATCH] Add UnknownCommandEvent
+
+
+diff --git a/src/main/java/org/bukkit/event/command/UnknownCommandEvent.java b/src/main/java/org/bukkit/event/command/UnknownCommandEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/org/bukkit/event/command/UnknownCommandEvent.java
+@@ -0,0 +0,0 @@
++package org.bukkit.event.command;
++
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
++import org.bukkit.command.CommandSender;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * 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;
++    @Nullable private Component message;
++
++    public UnknownCommandEvent(@NotNull final CommandSender sender, @NotNull final String commandLine, @Nullable final Component message) {
++        super(false);
++        this.sender = sender;
++        this.commandLine = commandLine;
++        this.message = message;
++    }
++
++    /**
++     * Gets the CommandSender or ConsoleCommandSender
++     * <p>
++     *
++     * @return Sender of the command
++     */
++    @NotNull
++    public CommandSender getSender() {
++        return sender;
++    }
++
++    /**
++     * Gets the command that was send
++     * <p>
++     *
++     * @return Command sent
++     */
++    @NotNull
++    public String getCommandLine() {
++        return commandLine;
++    }
++
++    /**
++     * Gets message that will be returned
++     * <p>
++     *
++     * @return Unknown command message
++     * @deprecated use {@link #message()}
++     */
++    @Nullable
++    @Deprecated
++    public String getMessage() {
++        return this.message == null ? null : LegacyComponentSerializer.legacySection().serialize(this.message);
++    }
++
++    /**
++     * Sets message that will be returned
++     * <p>
++     * Set to null to avoid any message being sent
++     *
++     * @param message the message to be returned, or null
++     * @deprecated use {@link #message(Component)}
++     */
++    @Deprecated
++    public void setMessage(@Nullable String message) {
++        this.message(message == null ? null : LegacyComponentSerializer.legacySection().deserialize(message));
++    }
++
++    /**
++     * Gets message that will be returned
++     * <p>
++     *
++     * @return Unknown command message
++     */
++    @Nullable
++    @Contract(pure = true)
++    public Component message() {
++        return this.message;
++    }
++
++    /**
++     * Sets message that will be returned
++     * <p>
++     * Set to null to avoid any message being sent
++     *
++     * @param message the message to be returned, or null
++     */
++    public void message(@Nullable Component message) {
++        this.message = message;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}
++

patches/unapplied/api/Add-WardenAngerChangeEvent.patch

@@ -0,0 +1,117 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: nopjar <code.nopjar@gmail.com>
+Date: Sun, 12 Jun 2022 00:56:45 +0200
+Subject: [PATCH] Add WardenAngerChangeEvent
+
+Adding a event which gets called when a warden is angered by
+another entity.
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/WardenAngerChangeEvent.java b/src/main/java/io/papermc/paper/event/entity/WardenAngerChangeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/WardenAngerChangeEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.Warden;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++/**
++ * Called when a Warden's anger level has changed due to another entity.
++ * <p>
++ * If the event is cancelled, the warden's anger level will not change.
++ */
++public class WardenAngerChangeEvent extends EntityEvent implements Cancellable {
++
++    private static final HandlerList handlers = new HandlerList();
++    private boolean cancelled;
++    private final Entity target;
++    private final int oldAnger;
++    private int newAnger;
++
++    public WardenAngerChangeEvent(@NotNull final Warden warden, @Nullable final Entity target, final int oldAnger, final int newAnger) {
++        super(warden);
++        this.target = target;
++        this.oldAnger = oldAnger;
++        this.newAnger = newAnger;
++    }
++
++    /**
++     * Gets the entity (if any) which triggered this anger update.
++     *
++     * @return triggering entity, or null
++     */
++    @Nullable
++    public Entity getTarget() {
++        return target;
++    }
++
++    /**
++     * Gets the old anger level.
++     *
++     * @return old anger level
++     * @see Warden#getAnger(Entity)
++     */
++    public int getOldAnger() {
++        return oldAnger;
++    }
++
++    /**
++     * Gets the new anger level resulting from this event.
++     *
++     * @return new anger level
++     * @see Warden#getAnger(Entity)
++     */
++    public int getNewAnger() {
++        return newAnger;
++    }
++
++    /**
++     * Sets the new anger level resulting from this event.
++     * <p>
++     * The anger of a warden is capped at 150.
++     *
++     * @param newAnger the new anger level, max 150
++     * @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");
++
++        this.newAnger = newAnger;
++    }
++
++    @NotNull
++    @Override
++    public Warden getEntity() {
++        return (Warden) entity;
++    }
++
++    @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;
++    }
++}

patches/unapplied/api/Add-WaterBottleSplashEvent.patch

@@ -0,0 +1,150 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Thu, 8 Dec 2022 10:12:23 -0700
+Subject: [PATCH] Add WaterBottleSplashEvent
+
+
+diff --git a/src/main/java/io/papermc/paper/event/entity/WaterBottleSplashEvent.java b/src/main/java/io/papermc/paper/event/entity/WaterBottleSplashEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/event/entity/WaterBottleSplashEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.event.entity;
++
++import java.util.Collection;
++import java.util.Map;
++import java.util.Set;
++import java.util.stream.Collectors;
++import org.bukkit.entity.LivingEntity;
++import org.bukkit.entity.ThrownPotion;
++import org.bukkit.event.entity.PotionSplashEvent;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * Called when a splash water potion "splashes" and affects
++ * different entities in different ways.
++ */
++public class WaterBottleSplashEvent extends PotionSplashEvent {
++    private final @NotNull Set<LivingEntity> rehydrate;
++    private final @NotNull Set<LivingEntity> extinguish;
++
++    public WaterBottleSplashEvent(
++        final @NotNull ThrownPotion potion,
++        final @NotNull Map<LivingEntity, Double> affectedEntities,
++        final @NotNull Set<LivingEntity> rehydrate,
++        final @NotNull Set<LivingEntity> extinguish
++    ) {
++        super(potion, affectedEntities);
++        this.rehydrate = rehydrate;
++        this.extinguish = extinguish;
++    }
++
++    /**
++     * Gets an immutable collection of entities that
++     * will take damage as a result of this event. Use
++     * other methods on this class to modify which entities
++     * take damage.
++     *
++     * @return an immutable collection of entities
++     * @see #doNotDamageAsWaterSensitive(LivingEntity)
++     * @see #damageAsWaterSensitive(LivingEntity)
++     */
++    @NotNull
++    public @Unmodifiable Collection<LivingEntity> getToDamage() {
++        return this.affectedEntities.entrySet().stream().filter(entry -> entry.getValue() > 0).map(Map.Entry::getKey).collect(Collectors.toUnmodifiableSet());
++    }
++
++    /**
++     * Removes this entity from the group that
++     * will be damaged.
++     *
++     * @param entity entity to remove
++     */
++    public void doNotDamageAsWaterSensitive(final @NotNull LivingEntity entity) {
++        this.affectedEntities.remove(entity);
++    }
++
++    /**
++     * Adds this entity to the group that
++     * will be damaged
++     *
++     * @param entity entity to add
++     */
++    public void damageAsWaterSensitive(final @NotNull LivingEntity entity) {
++        this.affectedEntities.put(entity, 1.0);
++    }
++
++    /**
++     * Get a mutable collection of entities
++     * that will be rehydrated by this.
++     * <p>
++     * As of 1.19.3 this only will contain Axolotls as they
++     * are the only entity type that can be rehydrated, but
++     * it may change in the future.
++     *
++     * @return the entities
++     */
++    @NotNull
++    public Collection<LivingEntity> getToRehydrate() {
++        return this.rehydrate;
++    }
++
++    /**
++     * Get a mutable collection of entities that will
++     * be extinguished as a result of this event.
++     *
++     * @return entities to be extinguished
++     */
++    @NotNull
++    public Collection<LivingEntity> getToExtinguish() {
++        return this.extinguish;
++    }
++
++    /**
++     * @return a confusing collection, don't use it
++     * @deprecated Use {@link #getToDamage()}
++     */
++    @Deprecated
++    @Override
++    public @NotNull Collection<LivingEntity> getAffectedEntities() {
++        return super.getAffectedEntities();
++    }
++
++    /**
++     * Doesn't make sense for this event as intensity doesn't vary.
++     * @return a confusing value
++     * @deprecated check if {@link #getToDamage()} contains an entity
++     */
++    @Deprecated
++    @Override
++    public double getIntensity(final @NotNull LivingEntity entity) {
++        return super.getIntensity(entity);
++    }
++
++    /**
++     * 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
++     */
++    @Deprecated
++    @Override
++    public void setIntensity(final @NotNull LivingEntity entity, final double intensity) {
++        super.setIntensity(entity, intensity);
++    }
++}
+diff --git a/src/main/java/org/bukkit/event/entity/PotionSplashEvent.java b/src/main/java/org/bukkit/event/entity/PotionSplashEvent.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/event/entity/PotionSplashEvent.java
++++ b/src/main/java/org/bukkit/event/entity/PotionSplashEvent.java
+@@ -0,0 +0,0 @@ import org.jetbrains.annotations.NotNull;
+ public class PotionSplashEvent extends ProjectileHitEvent implements Cancellable {
+     private static final HandlerList handlers = new HandlerList();
+     private boolean cancelled;
+-    private final Map<LivingEntity, Double> affectedEntities;
++    protected final Map<LivingEntity, Double> affectedEntities; // Paper
+ 
+     public PotionSplashEvent(@NotNull final ThrownPotion potion, @NotNull final Map<LivingEntity, Double> affectedEntities) {
+         super(potion);

patches/unapplied/api/Add-WhitelistToggleEvent.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Wed, 13 Mar 2019 20:04:43 +0200
+Subject: [PATCH] Add WhitelistToggleEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/server/WhitelistToggleEvent.java b/src/main/java/com/destroystokyo/paper/event/server/WhitelistToggleEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/server/WhitelistToggleEvent.java
+@@ -0,0 +0,0 @@
++package com.destroystokyo.paper.event.server;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * This event is fired when whitelist is toggled
++ *
++ * @author Mark Vainomaa
++ */
++public class WhitelistToggleEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++
++    private boolean enabled;
++
++    public WhitelistToggleEvent(boolean enabled) {
++        this.enabled = enabled;
++    }
++
++    /**
++     * Gets whether whitelist is going to be enabled or not
++     *
++     * @return Whether whitelist is going to be enabled or not
++     */
++    public boolean isEnabled() {
++        return enabled;
++    }
++
++    @NotNull
++    @Override
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++}

patches/unapplied/api/Add-World.getEntity-UUID-API.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Tue, 3 Jul 2018 16:07:16 +0200
+Subject: [PATCH] Add World.getEntity(UUID) API
+
+
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -0,0 +0,0 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     @NotNull
+     public Collection<Entity> getNearbyEntities(@NotNull Location location, double x, double y, double z);
+ 
++    // Paper start - getEntity by UUID API
++    /**
++     * Gets an entity in this world by its UUID
++     *
++     * @param uuid the UUID of the entity
++     * @return the entity with the given UUID, or null if it isn't found
++     */
++    @Nullable
++    public Entity getEntity(@NotNull java.util.UUID uuid);
++    // Paper end
++
+     /**
+      * Returns a list of entities within a bounding box centered around a
+      * Location.