Add hyperlinks

Author: Strokkur424

docs/paper/dev/api/command-api/arguments/adventure-arguments.mdx

@@ -148,7 +148,7 @@ on that resulting completable future. Inside of that, you can send the signed me
 :::warning
 
 The use of thread unsafe Bukkit API inside the `.thenAccept` method is not supported, as this is an asynchronous method, which does not run on the main thread.
-If you need to use Bukkit API, you can schedule a task to be run on the next available tick. You can read up on that **here** (WIP).
+If you need to use Bukkit API, you can schedule a task to be run on the next available tick. You can read up on that [here](../../scheduler.mdx).
 
 :::
 

docs/paper/dev/api/command-api/arguments/bukkit-arguments.mdx

@@ -39,7 +39,7 @@ public static LiteralCommandNode<CommandSourceStack> blockStateArgument() {
 
 ## ItemStack Argument
 The item stack argument is a way to retrieve an `ItemStack` following the same argument format as the vanilla `/give <player> <item> [<amount>]` command as its second argument.
-The user may also define components to further customize the `ItemStack`. If you only require a material, you should instead check out the **Registry Arguments** (WIP).
+The user may also define components to further customize the `ItemStack`. If you only require a material, you should instead check out the [registry arguments](./registry-arguments.mdx).
 
 ### Example usage
 ```java
@@ -139,7 +139,7 @@ public static LiteralCommandNode<CommandSourceStack> timeArgument() {
 ## UUID Argument
 The uuid argument allows the user to input a valid uuid. You can retrieve that value as a `UUID` object, which is used in various places, like `Bukkit.getOfflinePlayer(UUID)`.
 This argument is not very user-friendly, which is why it is suggested to only use this as a moderation or debug argument. For user input regarding offline player
-retrieval, the **player profiles argument** (WIP) is preferred, as it allows by-name lookup.
+retrieval, the [player profiles argument](./entity-player-arguments#player-profiles-argument) is preferred, as it allows by-name lookup.
 
 ### Example usage - Lookup command
 ```java

docs/paper/dev/api/command-api/basics/command-registration.mdx

@@ -117,7 +117,8 @@ this.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, comman
 
 ### Registering a BasicCommand
 A `BasicCommand` is a bukkit-like way of defining commands. Instead of building up a command tree, we allow all user input and retrieve the arguments as a simple array of Strings.
-This type of commands is particularly useful for very simple, text based commands, like a `/broadcast` command. You can read up on more details **here** (WIP).
+This type of commands is particularly useful for very simple, text based commands, like a `/broadcast` command. You can read up on more details about basic commands 
+[here](../misc/basic-command.mdx).
 
 Assuming you already have your `BasicCommand` object, we can register it like this:
 

docs/paper/dev/api/command-api/misc/basic-command.mdx

@@ -61,6 +61,7 @@ With the permission method you can, similar to the `canUse` method, set the perm
 
 ## Example: Broadcast command
 As an example, we can create a simple broadcast command. We start by declaring creating a class which implements BasicCommand and overrides `execute` and `permission`:
+
 ```java
 package your.package.name;
 
@@ -86,6 +87,7 @@ Our permission is set to `example.broadcast.use`. In order to give yourself that
 operator permissions. You can also set this permission to be `true` by default. For this, please check out the [plugin.yml documentation](../../../getting-started/plugin-yml.mdx).
 
 Now, in our `execute` method, we can retrieve the name of the executor of that command. If we do not find one, we can just get the name of the command sender, like this:
+
 ```java
 final Component name;
 if (commandSourceStack.getExecutor() != null) {
@@ -99,6 +101,7 @@ else {
 This makes sure that we cover all cases and even allow the command to work correctly with `/execute as`.
 
 Next, we retrieve all arguments and join them to a String or tell the sender that at least one argument is required in order to send a broadcast
+
 if they defined no arguments (meaning that `args` has a length of 0):
 ```java
 if (args.length == 0) {
@@ -110,6 +113,7 @@ final String message = String.join(" ", args);
 ```
 
 Finally, we can build our broadcast message and send it via `Bukkit.broadcast(Component)`:
+
 ```java
 final Component broadcastMessage = MiniMessage.miniMessage().deserialize(
     "<red><bold>BROADCAST</red> <name> <dark_gray>»</dark_gray> <message>",
@@ -121,6 +125,7 @@ Bukkit.broadcast(broadcastMessage);
 ```
 
 And we are done! As you can see, this is a very simple way to define commands. Here is the final result of our class:
+
 ```java title="BroadcastCommand.java"
 package your.package.name;
 
@@ -167,6 +172,7 @@ public class BroadcastCommand implements BasicCommand {
 ```
 
 Registering our command looks like this:
+
 ```java title="PluginMainClass.java"
 @Override
 public void onEnable() {
@@ -183,6 +189,7 @@ And this is how it looks like in-game:
 ## Example: Adding suggestions
 Our broadcast command works pretty well, but it is lacking on suggestions. A very common kind of suggestion for text based commands are player names.
 In order to suggest player names, we can just map all online players to their name, like this:
+
 ```java
 @Override
 public Collection<String> suggest(CommandSourceStack commandSourceStack, String[] args) {
@@ -196,13 +203,15 @@ This works great, but as you can see here, it will always suggest all players, r
 In order to fix this, we have to do some changes:
 
 First, we early return what we already have in case there is no arguments, as we cannot filter by input then:
+
 ```java
 if (args.length == 0) {
     return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
 }
 ```
 
 After this, we can add a `filter` clause to our stream, where we filter all names by whether they start with our current input, which is `args[args.length - 1]`:
+
 ```java
 return Bukkit.getOnlinePlayers().stream()
     .map(Player::getName)
@@ -218,6 +227,7 @@ But when there is no player who starts with an input, it just suggests nothing:
 
 ### Final code
 Here is the final code for our whole `BroadcastCommand` class, including the suggestions:
+
 ```java
 package your.package.name;
 

docs/paper/dev/api/command-api/misc/comparison-bukkit-brigadier.mdx

@@ -47,7 +47,9 @@ public class BukkitPartyCommand extends BukkitCommand {
     }
 }
 ```
+
 After that, you can define your command like this:
+
 ```java title="PluginClass.java"
 this.getServer().getCommandMap().register(
     this.getName().toLowerCase(),
@@ -64,6 +66,7 @@ In our case, it is the root of our command. We can do that by running `Commands.
 `LiteralArgumentBuilder<CommandSourceStack>`, where we can define some arguments and executors. Once we are done, we can call
 `LiteralArgumentBuilder#build()` to retrieve our build `LiteralCommandNode`, which we can then register. That sounds complicated at first,
 but once you see it in action, it looks less terrifying:
+
 ```java title="PaperPartyCommand.java"
 public static LiteralCommandNode<CommandSourceStack> createCommand(final String commandName) {
     return Commands.literal(commandName)