Paper

https://docs.papermc.io/paper/
Admin
Paper is a high-performance Minecraft: Java Edition game server that improves performance and...
Tokens:196,848
Snippets:1,867
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### YAML configuration example

Source: https://docs.papermc.io/paper/dev/plugin-configurations/

Example of a YAML configuration file with a root key and nested keys. Access nested values using dot notation, e.g., root.another-key.

```yaml
root:
  one-key: 10
  another-key: David

```

--------------------------------

### Example log output for discovered datapacks

Source: https://docs.papermc.io/paper/dev/lifecycle/datapacks/

Example log output showing the discovered datapacks, including experimental ones.

```text
[20:36:22 INFO]: [ExamplePlugin] The following datapacks were found: minecart_improvements, paper, redstone_experiments, trade_rebalance, vanilla
```

--------------------------------

### Start Paper server with --nogui flag

Source: https://docs.papermc.io/paper/reference/cli-arguments/

Example of passing the --nogui CLI argument after the server file name. This flag disables the graphical user interface.

```bash
java -jar server.jar --nogui
```

--------------------------------

### Example plugin.yml

Source: https://docs.papermc.io/paper/dev/plugin-yml/

A complete example of a plugin.yml file with required fields: name, version, main, and api-version. The main field must be the package path and class name of the class that extends JavaPlugin.

```yaml
name: Example-Plugin
version: 1.0.0
main: com.example.paperplugin.ExamplePlugin
description: An example plugin
author: PaperMC
website: https://papermc.io
api-version: '26.3'

```

--------------------------------

### Example log output after removing datapacks

Source: https://docs.papermc.io/paper/dev/lifecycle/datapacks/

Example log output showing the remaining datapacks after removal.

```text
[20:43:42 INFO]: [ExamplePlugin] The following datapacks were found: paper, vanilla
```

--------------------------------

### Generic Command Example

Source: https://docs.papermc.io/paper/dev/command-api/basics/command-tree/

Shows a generic command with three branches under the root '/customplugin'. This example is used to illustrate the tree structure where '/customplugin' is the root and each argument is a branch.

```plaintext
/customplugin reload
/customplugin tphere
/customplugin killall
```

--------------------------------

### Set system property in start command

Source: https://docs.papermc.io/paper/reference/system-properties/

Use the -D flag to set a system property when starting the server. The example sets com.mojang.eula.agree to true. In PowerShell, properties containing a dot must be wrapped in quotes, e.g., "-Dcom.mojang.eula.agree=true".

```bash
java -Dcom.mojang.eula.agree=true -jar paper.jar
```

--------------------------------

### paper-plugin.yml example configuration

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins/

Example configuration for a Paper plugin, including name, version, main class, description, api-version, bootstrapper, and loader. This file is placed in the JAR resources folder and can coexist with plugin.yml.

```yaml
name: Example-Plugin
version: '1.0'
main: com.example.paperplugin.ExamplePlugin
description: A Paper plugin showcase
api-version: '26.3'
bootstrapper: com.example.paperplugin.ExamplePluginBootstrap
loader: com.example.paperplugin.ExamplePluginLoader

```

--------------------------------

### Multiple dependency examples in paper-plugin.yml

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins/

Examples of declaring multiple dependencies in paper-plugin.yml, showing different load orders and classpath access. Includes ProtocolLib (BEFORE, required), SuperShopsXUnlimited (AFTER, not required), and SuperDuperTacoParty (required, join-classpath true).

```yaml
# Suppose we require ProtocolLib to be loaded for our plugin
ProtocolLib:
  load: BEFORE
  required: true

# Now, we are going to register some details for a shop plugin
# So the shop plugin should load after our plugin
SuperShopsXUnlimited:
  load: AFTER
  required: false

# Now, we are going to need to access a plugins classpath
# So that we can properly interact with it.
SuperDuperTacoParty:
  required: true
  join-classpath: true

```

--------------------------------

### Start spark profiler with timeout

Source: https://docs.papermc.io/paper/profiling/

Run this command in the server console to start profiling for 10 minutes. After the timeout, a URL to the profiler report is returned. This is the preferred way to profile Paper servers.

```text
/spark profiler start --timeout 600
```

--------------------------------

### ResourceBundle properties file example

Source: https://docs.papermc.io/paper/dev/component-api/i18n/

Example properties file for a ResourceBundle, located at src/main/resources/your/plugin/Bundle_en_US.properties. Defines a translation key with a placeholder {0}.

```properties
some.translation.key=Translated Message: {0}
```

--------------------------------

### Single dependency example in paper-plugin.yml

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins/

Example of a single dependency entry in paper-plugin.yml, showing the load, required, and join-classpath options with their defaults. The load option can be BEFORE, AFTER, or OMIT (default OMIT, undefined ordering).

```yaml
RegistryPlugin:
  load: BEFORE # Defaults to OMIT
  required: true # Defaults to true
  join-classpath: true # Defaults to true

```

--------------------------------

### Using ArgumentTypes.resource with RegistryKey.ITEM

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry/

Example command using the `resource` argument type to get an `ItemType` directly from the command context. The argument type provides client-side error checking, so the result is guaranteed to be non-null. Adds the item to the player's inventory.

```java
Commands.argument("item", ArgumentTypes.resource(RegistryKey.ITEM))
    .executes(context -> {
        final ItemType item = context.getArgument("item", ItemType.class);
        final Player player = context.getSource().getPlayerOrThrow();

        player.getInventory().addItem(item.createItemStack());

        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### JSON component format example

Source: https://docs.papermc.io/paper/dev/component-api/introduction/

A simple JSON component example showing a parent component with color and bold style, and extra children including a text child with overridden bold and a keybind component. This format is used in Vanilla commands like /tellraw.

```json
{
  "text": "This is the parent component; its style is applied to all children.\n",
  "color": "#438df2",
  "bold": true,
  "extra": [
    {
      "text": "This is this first child, which is rendered after the parent",
      "underlined": true,
      // This overrides the parent's "bold" value just for this component
      "bold": false
    },
    {
      // This is a keybind component which will display the client's keybind for that action
      "keybind": "key.inventory"
    }
  ]
}
```

--------------------------------

### Resource argument example - enchantment command

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry/

Example of using `ArgumentTypes.resource(RegistryKey.ENCHANTMENT)` to create an argument that returns an `Enchantment` value. It retrieves the player's held item, adds an unsafe enchantment at level 10, and sends a success message.

```java
Commands.argument("enchantment", ArgumentTypes.resource(RegistryKey.ENCHANTMENT))
    .executes(context -> {
        final Player player = context.getSource().getPlayerOrThrow();
        final ItemStack item = player.getInventory().getItemInMainHand();
        if (item.isEmpty()) {
            context.getSource().getSender().sendRichMessage("<red><player> is not holding any item",
                Placeholder.component("player", player.displayName())
            );
            return Command.SINGLE_SUCCESS;
        }

        final Enchantment enchantment = context.getArgument("enchantment", Enchantment.class);
        item.addUnsafeEnchantment(enchantment, 10);
        context.getSource().getSender().sendRichMessage("Enchanted <player>'s <item> with <enchantment>!",
            Placeholder.component("player", player.displayName()),
            Placeholder.component("item", Component.translatable(item).hoverEvent(item)),
            Placeholder.component("enchantment", enchantment.displayName(10))
        );
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### HeightMap argument example usage

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums/

Example command using ArgumentTypes.heightMap() to get a HeightMap enum value and send a message with the selected value.

```java
Commands.argument("height_map", ArgumentTypes.heightMap())
    .executes(context -> {
        final HeightMap heightMap = context.getArgument("height_map", HeightMap.class);

        context.getSource().getSender().sendRichMessage("You selected <gold><selection></gold>",
            Placeholder.unparsed("selection", heightMap.name())
        );
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Entity anchor argument example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums/

Example usage of ArgumentTypes.entityAnchor() to get a LookAnchor enum from the command context and send a message with the anchor name.

```java
Commands.argument("anchor", ArgumentTypes.entityAnchor())
    .executes(context -> {
        final LookAnchor anchor = context.getArgument("anchor", LookAnchor.class);

        context.getSource().getSender().sendRichMessage("You chose <aqua><anchor></aqua>!",
            Placeholder.unparsed("anchor", anchor.name())
        );
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Run Paper server with Java command

Source: https://docs.papermc.io/paper/getting-started/

Use this command in your terminal to start the Paper server. Ensure you are in the server directory and replace 'paper.jar' with your downloaded JAR name. Adjust RAM with the Xms and Xmx arguments; --nogui disables Vanilla's GUI.

```bash
java -Xms4G -Xmx4G -jar paper.jar --nogui
```

--------------------------------

### GameMode argument example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums/

Example usage of ArgumentTypes.gameMode() to get a GameMode enum, set the player's game mode, and send a confirmation message.

```java
Commands.argument("mode", ArgumentTypes.gameMode())
    .executes(context -> {
        final GameMode mode = context.getArgument("mode", GameMode.class);
        final Player player = context.getSource().getPlayerOrThrow();

        player.setGameMode(mode);
        player.sendRichMessage("Your gamemode has been set to <red><mode></red>!",
            Placeholder.component("mode", Component.translatable(mode))
        );
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Scoreboard display slot argument example usage

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums/

Example command using ArgumentTypes.scoreboardDisplaySlot() to get a DisplaySlot enum value and send a plain message with the selected slot.

```java
Commands.argument("slot", ArgumentTypes.scoreboardDisplaySlot())
    .executes(context -> {
        final DisplaySlot slot = context.getArgument("slot", DisplaySlot.class);

        context.getSource().getSender().sendPlainMessage("You selected: " + slot.toString());
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### UUID argument lookup command example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper/

Example of using the UUID argument in a Paper command. It retrieves the UUID argument, gets the offline player via Bukkit.getOfflinePlayer, and sends a rich message with placeholders and a boolean formatter. Returns Command.SINGLE_SUCCESS.

```java
Commands.argument("uuid", ArgumentTypes.uuid())
    .executes(context -> {
        final UUID uuid = context.getArgument("uuid", UUID.class);
        final OfflinePlayer result = Bukkit.getOfflinePlayer(uuid);

        context.getSource().getSender().sendRichMessage("Has <aqua><uuid></aqua> played before: <result:'<green>true</green>':'<red>false</red>'>",
            Placeholder.unparsed("uuid", uuid.toString()),
            Formatter.booleanChoice("result", result.hasPlayedBefore())
        );

        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Recommended JVM startup flags command

Source: https://docs.papermc.io/paper/aikars-flags/

Use this command to start a Paper server with Aikar's recommended JVM flags. The Xms and Xmx values are set to 10G, but you should adjust them based on your available memory, reducing by 1000-1500MB to avoid OOMKiller. The command includes the -jar paper.jar --nogui arguments.

```bash
java -Xms10G -Xmx10G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar paper.jar --nogui
```

--------------------------------

### Start server with remote debugger JVM arguments

Source: https://docs.papermc.io/paper/dev/debugging/

Command line arguments to enable remote debugging in the server startup script. Place these after the 'java' command and before '-jar'.

```bash
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar paper-26.3.jar --nogui
```

--------------------------------

### Named color argument example usage

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure/

Example command tree using ArgumentTypes.namedColor() to get a NamedTextColor and apply it to a message component. The argument is named "color" and is followed by a greedy string argument for the message. The sender receives a colored message.

```java
Commands.argument("color", ArgumentTypes.namedColor())
    .then(Commands.argument("message", StringArgumentType.greedyString())
        .executes(context -> {
            final NamedTextColor color = context.getArgument("color", NamedTextColor.class);
            final String msg = StringArgumentType.getString(context, "message");

            context.getSource().getSender().sendMessage(
                Component.text(msg).color(color)
            );
            return Command.SINGLE_SUCCESS;
        })
    )
```

--------------------------------

### Reflection utility to get CraftBukkit class names

Source: https://docs.papermc.io/paper/dev/internals/

Use this utility to construct the full class name for CraftBukkit classes when using reflection. It relies on the package name of the server's class, which includes the version for 1.20.4 and older. The example shows how to use it with Class.forName to get a CraftBee class.

```java
private static final String CRAFTBUKKIT_PACKAGE = Bukkit.getServer().getClass().getPackageName();

public static String cbClass(String className) {
    return CRAFTBUKKIT_PACKAGE + "." + className;
}

// You can then use this method to get the CraftBukkit class:
Class.forName(cbClass("entity.CraftBee"));
```

--------------------------------

### Define a command in plugin.yml

Source: https://docs.papermc.io/paper/dev/plugin-yml/

Example of a command definition in plugin.yml. The 'description' is shown in help, 'usage' is displayed with /help <command>, 'aliases' are alternative names, 'permission' is the required node (players only see commands they have permission for), and 'permission-message' is shown when lacking permission.

```yaml
commands:
  command:
    description: "This is a command"
    usage: "/command <arg>"
    aliases: [cmd, command]
    permission: permission.node
    permission-message: "You do not have permission to use this command"
```

--------------------------------

### Adventure style argument example usage

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure/

Example command tree using ArgumentTypes.style() to get a Style object and apply it to a message component. The argument is named "style" and is followed by a greedy string argument for the message. The sender receives a rich message with the styled input as a placeholder.

```java
Commands.argument("style", ArgumentTypes.style())
    .then(Commands.argument("message", StringArgumentType.greedyString())
        .executes(context -> {
            final Style style = context.getArgument("style", Style.class);
            final String msg = StringArgumentType.getString(context, "message");

            context.getSource().getSender().sendRichMessage("Your input: <input>",
                Placeholder.component("input", Component.text(msg).style(style))
            );
            return Command.SINGLE_SUCCESS;
        })
    )
```

--------------------------------

### Implement PluginBootstrap in ExamplePluginBootstrap.java

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins/

Defines a bootstrapper class implementing PluginBootstrap. The bootstrap method is empty, and createPlugin returns a new ExamplePlugin with a custom parameter. Bootstrappers are experimental and allow passing values to the plugin constructor.

```java
public final class ExamplePluginBootstrap implements PluginBootstrap {

    @Override
    public void bootstrap(final BootstrapContext context) {

    }

    @Override
    public JavaPlugin createPlugin(final PluginProviderContext context) {
        return new ExamplePlugin("My custom parameter");
    }

}
```

--------------------------------

### Modify prototype component values with Equippable.Builder

Source: https://docs.papermc.io/paper/dev/data-component-api/

Shows how to get an existing data component, convert it to a builder, modify its values, and set it back. Note that not all types have toBuilder() methods. The example makes a diamond helmet look like netherite and play a ghast sound when equipped.

```java
ItemStack helmet = ItemStack.of(Material.DIAMOND_HELMET);
// Get the equippable component for this item, and make it a builder.
// Note: Not all types have .toBuilder() methods
// This is the prototype value of the diamond helmet.
Equippable.Builder builder = helmet.getData(DataComponentTypes.EQUIPPABLE).toBuilder();

// Make the helmet look like netherite
// We get the prototype equippable value from NETHERITE_HELMET
builder.assetId(Material.NETHERITE_HELMET.getDefaultData(DataComponentTypes.EQUIPPABLE).assetId());
// And give it a spooky sound when putting it on
builder.equipSound(SoundEventKeys.ENTITY_GHAST_HURT.key());

// Set our new item
helmet.setData(DataComponentTypes.EQUIPPABLE, builder);
```

--------------------------------

### Connect to MySQL using HikariCP (DatabaseManager.java)

Source: https://docs.papermc.io/paper/dev/using-databases/

Example of creating a HikariDataSource with JDBC URL, credentials, and pool size. Uses try-with-resources to auto-close connections. Requires a running MySQL database.

```java
public class DatabaseManager {

    public void connect() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase"); // Address of your running MySQL database
        config.setUsername("username"); // Username
        config.setPassword("password"); // Password
        config.setMaximumPoolSize(10); // Pool size defaults to 10

        config.addDataSourceProperty("", ""); // MISC settings to add
        HikariDataSource dataSource = new HikariDataSource(config);

        try (Connection connection = dataSource.getConnection()) {
            // Use a try-with-resources here to autoclose the connection.
            PreparedStatement sql = connection.prepareStatement("SQL");
            // Execute statement
        } catch (Exception e) {
            // Handle any exceptions that arise from getting / handing the exception.
        }
    }
}
```

--------------------------------

### Player lookup command using playerProfiles argument

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player/

Example command that uses ArgumentTypes.playerProfiles() to get a PlayerProfileListResolver, resolves it to a collection of PlayerProfile objects, and sends a message for each profile. The resolver should be resolved asynchronously because it may call Mojang servers, which can take time and cause lag if done on the main thread.

```java
Commands.argument("profiles", ArgumentTypes.playerProfiles())
    .executes(context -> {
        final PlayerProfileListResolver resolver = context.getArgument("profiles", PlayerProfileListResolver.class);
        final Collection<PlayerProfile> profiles = resolver.resolve(context.getSource());

        for (final PlayerProfile profile : profiles) {
            context.getSource().getSender().sendPlainMessage("Found " + profile.getName());
        }

        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Creating a component with direct methods vs builder

Source: https://docs.papermc.io/paper/dev/component-api/introduction/

Shows two ways to create the same component: a sub-optimal direct method chain that creates new instances per change, and an optimal builder approach. The builder is recommended for complex components. The example also notes that Adventure Components are designed for static method imports.

```java
// This is a sub-optimal construction of the
// component as each change creates a new component
final Component component = Component.text("Hello")
    .color(TextColor.color(0x13f832))
    .append(Component.text(" world!", NamedTextColor.GREEN));

/* This is an optimal use of the builder to create
   the same component. Also note that Adventure
   Components are designed for use with static method imports
   to make code less verbose */
final Component component = text()
    .content("Hello").color(color(0x13f832))
    .append(text(" world!", GREEN))
    .build();
```

--------------------------------

### Teleport player using config location (ExamplePlugin.java)

Source: https://docs.papermc.io/paper/dev/plugin-configurations/

Fetches a Location from the plugin config using getLocation("target-location") and teleports the player. Requires the config to be saved first.

```java
public final class ExamplePlugin extends JavaPlugin {

    public void teleportPlayer(Player player) {
        Location to = this.getConfig().getLocation("target-location");
        player.teleport(to);
    }
}
```

--------------------------------

### Create a RegistryKeySet with Enchantment Keys

Source: https://docs.papermc.io/paper/dev/registries/

Creates a RegistryKeySet holding enchantment keys using RegistrySet.keySet. The example uses RegistryKey.ENCHANTMENT and includes both a predefined key (EnchantmentKeys.CHANNELING) and a custom key created via EnchantmentKeys.create.

```java
// Create a new registry key set that holds a collection enchantments
final RegistryKeySet<Enchantment> bestEnchantments = RegistrySet.keySet(
    RegistryKey.ENCHANTMENT,
    // Arbitrary keys of enchantments to store in the key set.
    EnchantmentKeys.CHANNELING,
    EnchantmentKeys.create(Key.key("papermc:softspoon"))
);
```

--------------------------------

### Signed Message Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure/

Example usage of the signed message argument in a Paper command. It resolves the signed message and sends it to the target player.

```APIDOC
## Signed Message Argument

### Description
The signed message argument allows a player to send an argument in the form of a signed message to the server. It returns a `SignedMessageResolver`.

### Usage
To resolve the signed message, call the `#resolve` method on the `SignedMessageResolver` with two parameters:
- The argument name (e.g., "message")
- The `CommandContext<CommandSourceStack>` object

The resolved value is a `CompletableFuture<SignedMessage>`. Use `thenAccept(Consumer<T>)` to handle the result.

### Example
```java
Commands.argument("target", ArgumentTypes.player())
    .then(Commands.argument("message", ArgumentTypes.signedMessage())
        .executes(context -> {
            final Player target = context.getArgument("target", PlayerSelectorArgumentResolver.class).resolve(context.getSource()).getFirst();
            final SignedMessageResolver resolver = context.getArgument("message", SignedMessageResolver.class);

            resolver.resolveSignedMessage("message", context).thenAccept(msg -> {
                target.sendMessage(msg, ChatType.CHAT.bind(context.getSource().getSender().name()));
            });

            return Command.SINGLE_SUCCESS;
        })
    )
```

### Notes
- The consumer passed to `thenAccept` is not executed on the main thread by default. Use the main thread executor to schedule tasks if needed.
- Non-player senders cannot send signed messages; the `CompletableFuture` will never complete. Use `.requires(source -> source.getSender() instanceof Player)` to restrict to players.
```

--------------------------------

### Implement PluginLoader with ExamplePluginLoader.java

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins/

Example implementation of PluginLoader that adds a jar library and a Maven library resolver to the plugin classpath. The resolver adds a dependency and a repository from Paper's Maven repository. Use this as a template for custom plugin loaders.

```java
public final class ExamplePluginLoader implements PluginLoader {

    @Override
    public void classloader(final PluginClasspathBuilder classpathBuilder) {
        classpathBuilder.addLibrary(new JarLibrary(Path.of("dependency.jar")));

        final MavenLibraryResolver resolver = new MavenLibraryResolver();
        resolver.addDependency(new Dependency(new DefaultArtifact("com.example:example:version"), null));
        resolver.addRepository(new RemoteRepository.Builder("paper", "default", "https://repo.papermc.io/repository/maven-public/").build());

        classpathBuilder.addLibrary(resolver);
    }
}
```

--------------------------------

### ExampleListener class implementing Listener

Source: https://docs.papermc.io/paper/dev/event-listeners/

Create a class that implements the Listener interface to listen for events. The class name is arbitrary but recommended to be related to the events.

```java
public class ExampleListener implements Listener {
    // ...
}
```

--------------------------------

### Key argument example usage

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure/

Uses ArgumentTypes.key() to accept and validate a namespaced key, returning a Key object. The example sends a rich message with the key as an unparsed placeholder.

```java
Commands.argument("key", ArgumentTypes.key())
    .executes(context -> {
        final Key key = context.getArgument("key", Key.class);

        context.getSource().getSender().sendRichMessage("You put in <aqua><key></aqua>!",
            Placeholder.unparsed("key", key.asString())
        );

        return Command.SINGLE_SUCCESS;
    })
```
Tokens:
Raw