### Full Example: Player Command Executor for Adding Points

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

This complete Java code integrates the command definition, method mapping, and parameter binding for adding a teleport point. It showcases a fully functional command executor class ready for registration with UltiTools-Command.

```java
import com.ultikits.lib.command.AbstractCommendExecutor;
import com.ultikits.lib.annotations.command.CmdExecutor;
import com.ultikits.lib.annotations.command.CmdTarget;
import com.ultikits.lib.annotations.command.CmdMapping;
import com.ultikits.lib.annotations.command.CmdParam;
import com.ultikits.lib.annotations.command.CmdSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

// Command limits executor
@CmdTarget(CmdTarget.CmdTargetType.PLAYER)
@CmdExecutor(
        // Command permission (optional)
        permission = "ultikits.example.all",
        // Command description (optional)
        description = "Test Command",
        // Command alias
        alias = {"point"},
        // Whether to register manually (optional)
        manualRegister = false,
        // Whether to require OP permission (optional)
        requireOp = false
)
public class PointCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "add <name>")
    public void addPoint(@CmdSender Player player, @CmdParam("name") String name) {
        // Your code
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        // Send help message to command sender
    }
}
```

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

### Send Help Messages in UltiKits Commands (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The sendHelpMessage method displays usage information to senders when '/command help' is invoked. It takes a CommandSender parameter and is available in command classes. Custom implementation handles message content.

```java
sendHelpMessage(CommandSender sender) {
    // send help message
}
```

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

### Basic Command Executor with Annotations in Java

Source: https://context7.com/ultikits/ultikits-command/llms.txt

This example defines a command class using @CmdExecutor and @CmdMapping annotations for teleport functions in a Minecraft plugin. It depends on UltiTools annotations and AbstractCommendExecutor; inputs include command sender and formats like 'home'; outputs are teleport actions or help messages. Limitations are command sender must be a player and respects permissions/OP requirements.

```Java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdTarget(CmdTarget.CmdTargetType.PLAYER)
@CmdExecutor(
    permission = "example.teleport",
    description = "Teleport commands",
    alias = {"tp", "teleport"},
    requireOp = false
)
public class TeleportCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "home")
    public void teleportHome(@CmdSender Player player) {
        player.teleport(player.getBedSpawnLocation());
        player.sendMessage("Teleported to home!");
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("=== Teleport Commands ===");
        sender.sendMessage("/tp home - Teleport to home");
        sender.sendMessage("/tp spawn - Teleport to spawn");
    }
}
```

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

### Handle Variable Parameters (Varargs) in Command Format

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

Use ... in the @CmdMapping format to capture the trailing segment as an array. The @CmdParam value must also use ... to bind the varargs to a String[] method parameter. Example shows parsing of a command like /somecmd add aa bb cc into String[{"aa","bb","cc"}].

```Java
@CmdMapping(format = "add <name...>")
public void addPoint(@CmdSender Player player, @CmdParam(value = "name...") String[] name) {
    // name contains ["aa", "bb", "cc"] when user enters: /somecmd add aa bb cc
}
```

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

### Map Command to Method with Parameters using UltiTools-Command

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

This Java code snippet demonstrates how to map a specific command format to a method using UltiTools-Command's annotations. It shows how to define the command format with a named parameter and bind that parameter to a method argument using @CmdParam.

```java
@CmdMapping(format = "add <name>")
public void addPoint(@CmdSender Player player, @CmdParam("name") String name) {
    // Your code
}
```

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

### Define Player Command Executor with UltiTools-Command

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

This Java code defines a command executor for player-specific commands using UltiTools-Command. It sets command permissions, descriptions, aliases, and target types. The executor inherits from AbstractCommandExecutor and includes a placeholder for handling help messages.

```java
import com.ultikits.lib.command.AbstractCommendExecutor;
import com.ultikits.lib.annotations.command.CmdExecutor;
import com.ultikits.lib.annotations.command.CmdTarget;
import org.bukkit.command.CommandSender;

// Command limits executor
@CmdTarget(CmdTarget.CmdTargetType.PLAYER)
@CmdExecutor(
        // Command permission (optional)
        permission = "ultikits.example.all",
        // Command description (optional)
        description = "Test Command",
        // Command alias
        alias = {"point"},
        // Whether to register manually (optional)
        manualRegister = false,
        // Whether to require OP permission (optional)
        requireOp = false
)
public class PointCommand extends AbstractCommendExecutor {

    @Override
    protected void handleHelp(CommandSender sender) {
        // Send help message to command sender
    }
}
```

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

### Implement Tab Completion with Suggestion Methods

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

Configure @CmdParam with suggest to reference a method that returns List<String> for tab completion. UltiTools will resolve and call the method with Player, Command, String[]. Also allows override of suggest() and direct literal strings including i18n keys.

```Java
@CmdMapping(format = "add <name>")
public void addPoint(@CmdSender Player player, @CmdParam(value = "name", suggest = "listName") String name) {
    // Your code
}

public List<String> listName(Player player, Command command, String[] args) {
    // Your code
    return List.of("alpha", "beta", "gamma");
}

// Literal prompt with i18n
// @CmdMapping(format = "add <name>")
// public void addPoint(@CmdSender Player player,
//                      @CmdParam(value = "name", suggest = "[name]") String name) {
//     // Your code
// }

// Override suggest for full control
// @Override
// protected List<String> suggest(Player player, Command command, String[] strings) {
//     return List.of("custom", "completion");
// }
```

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

### Specify Method Permissions with CmdMapping (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The @CmdMapping annotation sets permissions for individual command methods using the 'permission' attribute. Permissions in @CmdExecutor override those in @CmdMapping. This restricts execution to users with the specified permission node.

```java
@CmdMapping(..., permission = "point.set.add")
```

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

### Add Custom Type Parser and Share Suggestion Methods

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

Register a custom parser by putting a Function<String, ?> into the parsers map for your type and its array variant. Share suggestion methods across commands using @CmdSuggest to reference an external suggest class.

```Java
// Custom type and parser
public static class SomeType {
    private final String value;
    public SomeType(String value) { this.value = value; }
    public static SomeType toSomeType(String s) {
        return new SomeType(s);
    }
}

// Add parser in constructor
public class SomeCommand extends AbstractCommandExecutor {
    public SomeCommand() {
        super();
        getParsers().put(Arrays.asList(SomeType.class, SomeType[].class), SomeType::toSomeType);
    }
}

// Share suggestion methods across classes
@CmdSuggest({PointSuggest.class})
public class PointCommand extends AbstractCommandExecutor {
    @CmdMapping(format = "add <name>")
    public void addPoint(@CmdSender Player player, @CmdParam(value = "name", suggest = "listName") String name) {
        // Your code
    }
}

// External suggestion class
external class PointSuggest {
    public List<String> listName(Player player, Command command, String[] args) {
        // Your reusable completion logic
        return List.of("alice", "bob", "charlie");
    }
}
```

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

### Require OP for Individual Method with CmdMapping (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The 'requireOp = true' attribute in @CmdMapping limits a specific method to operators only. This provides granular control over individual commands. It overrides class-level settings if conflicting.

```java
@CmdMapping(..., requireOp = true)
```

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

### Require OP for Command Class with CmdExecutor (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

Setting 'requireOp = true' in @CmdExecutor ensures all methods in the class require operator status. This applies globally to the command executor class. Non-OP users will be denied access to all commands.

```java
@CmdExecutor(..., requireOp = true)
```

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

### Add Execution Lock with UsageLimit (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The @UsageLimit annotation enforces sequential execution limits, such as per-sender or server-wide. 'ContainConsole' toggles console inclusion, and 'value' selects limit type (SENDER, ALL, NONE). Violators receive wait messages; supports player and server resource protection.

```java
@UsageLimit(ContainConsole = false, value = LimitType.SENDER)
```

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

### Register Command Executor with UltiTools CommandManager

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

This Java code shows how to register a custom command executor using the CommandManager in UltiTools-Command. It's typically called within the onEnable method of a Bukkit plugin to make the defined commands active.

```java
import com.ultikits.lib.command.CommandManager;
import org.bukkit.plugin.java.JavaPlugin;

public class PluginMain extends JavaPlugin {

    @Override
    public void onEnable() {
        // Register command executor
        CommandManager.registerCommand(new PointCommand());
    }
}
```

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

### Implement Command Cooldown with CmdCD (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The @CmdCD annotation adds a cooldown period in seconds to prevent rapid executions and resource overuse. It only applies to players, sending a 'Frequent operations' message if triggered early. Integer parameter specifies duration.

```java
@CmdCD(60)
```

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

### Limit Command Sender Types with CmdTarget (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The @CmdTarget annotation specifies allowed senders (e.g., players, console, or both) for classes or methods. Class-level settings apply to all methods unless overridden. Both class and method targets must be satisfied for execution.

```java
@CmdTarget(CmdTarget.CmdTargetType.BOTH)
```

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

### Enable Asynchronous Command Execution (Java)

Source: https://github.com/ultikits/ultikits-command/blob/main/README.md

The @RunAsync annotation runs long-running tasks in a separate thread to avoid blocking the main Bukkit thread. For Bukkit API calls within async methods, use BukkitRunnable with runTask. This prevents server lag but requires careful handling of thread safety.

```java
@CmdMapping(format = "list")
@RunAsync
public void listPoint(@CmdSender Player player) {
    //do query
}
```

```java
@CmdMapping(format = "list")
@RunAsync
public void listPoint(@CmdSender Player player) {
    //do query
    new BukkitRunnable() {
        @Override
        public void run() {
            //call bukkit api
        }
    }.runTask(PluginMain.getInstance());
}
```

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

### Implement Tab Completion with @CmdParam suggest in Java

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Shows how to implement dynamic tab completion for command parameters using the @CmdParam suggest attribute in Java. This allows for context-aware suggestions based on method references, improving user experience for command execution.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@CmdTarget(CmdTarget.CmdTargetType.BOTH)
@CmdExecutor(
    permission = "example.gamemode",
    description = "Change gamemode",
    alias = {"gm", "gamemode"}
)
public class GamemodeCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "<mode> <player>")
    public void changeGamemode(
        @CmdSender CommandSender sender,
        @CmdParam(value = "mode", suggest = "listGamemodes") String mode,
        @CmdParam(value = "player", suggest = "listPlayers") Player target
    ) {
        GameMode gameMode = GameMode.valueOf(mode.toUpperCase());
        target.setGameMode(gameMode);
        sender.sendMessage(String.format("Set %s's gamemode to %s", target.getName(), gameMode));
    }

    public List<String> listGamemodes(Player player, Command command, String[] args) {
        return Arrays.stream(GameMode.values())
            .map(gm -> gm.name().toLowerCase())
            .collect(Collectors.toList());
    }

    public List<String> listPlayers() {
        return Bukkit.getOnlinePlayers().stream()
            .map(Player::getName)
            .collect(Collectors.toList());
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/gamemode <mode> <player> - Change player's gamemode");
    }
}

```

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

### Handle Variable Arguments with Varargs in Java

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Demonstrates how to handle commands with a variable number of arguments using the '...' varargs notation in Java with the Ultikits command library. This allows for flexible command structures where the number of arguments is not fixed.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdExecutor(
    description = "Broadcast messages",
    alias = {"broadcast", "bc"}
)
public class BroadcastCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "<message...>")
    public void broadcast(
        @CmdSender CommandSender sender,
        @CmdParam("message...") String[] messageWords
    ) {
        String message = String.join(" ", messageWords);
        String formattedMessage = String.format("[Broadcast] %s", message);

        Bukkit.broadcastMessage(formattedMessage);
        sender.sendMessage("Broadcast sent successfully!");
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/broadcast <message> - Send message to all players");
    }
}

```

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

### Execute Commands Asynchronously with @RunAsync

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Illustrates how to run potentially long-running commands asynchronously using the @RunAsync annotation. This prevents the main server thread from being blocked, ensuring smooth gameplay.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;

@CmdExecutor(
    permission = "example.database",
    description = "Database query commands",
    alias = {"dbquery"}
)
public class DatabaseCommand extends AbstractCommendExecutor {

    @RunAsync
    @CmdMapping(format = "stats <player>")
    public void queryPlayerStats(
        @CmdSender CommandSender sender,
        @CmdParam("player") String playerName
    ) {
        sender.sendMessage("Querying database for " + playerName + "...");

        // Simulate long database query
        try {
            Thread.sleep(2000);
            // Perform your database query here
            String stats = fetchPlayerStatsFromDatabase(playerName);

            // Schedule Bukkit API call back on main thread
            new BukkitRunnable() {
                @Override
                public void run() {
                    sender.sendMessage("Stats for " + playerName + ":");
                    sender.sendMessage(stats);
                }
            }.runTask(getPlugin());

        } catch (InterruptedException e) {
            sender.sendMessage("Query interrupted!");
        }
    }

    private String fetchPlayerStatsFromDatabase(String playerName) {
        // Database query implementation
        return "Kills: 100, Deaths: 50, Playtime: 20h";
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/dbquery stats <player> - Query player statistics");
    }
}
```

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

### Share Tab Completion Methods with @CmdSuggest in Java

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Illustrates how to share tab completion logic across multiple command classes using external suggestion classes annotated with @CmdSuggest in Java. This promotes code reuse and maintainability for common suggestion providers.

```java
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.List;
import java.util.stream.Collectors;

public class CommonSuggestions {
    public List<String> onlinePlayers() {
        return Bukkit.getOnlinePlayers().stream()
            .map(Player::getName)
            .collect(Collectors.toList());
    }

    public List<String> worldNames() {
        return Bukkit.getWorlds().stream()
            .map(world -> world.getName())
            .collect(Collectors.toList());
    }
}

@CmdSuggest({CommonSuggestions.class})
@CmdExecutor(
    description = "Teleport between worlds",
    alias = {"worldtp"}
)
public class WorldTeleportCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "<player> <world>")
    public void teleportWorld(
        @CmdSender Player sender,
        @CmdParam(value = "player", suggest = "onlinePlayers") Player target,
        @CmdParam(value = "world", suggest = "worldNames") String worldName
    ) {
        org.bukkit.World world = Bukkit.getWorld(worldName);
        if (world == null) {
            sender.sendMessage("World not found!");
            return;
        }
        target.teleport(world.getSpawnLocation());
        sender.sendMessage(String.format("Teleported %s to %s", target.getName(), worldName));
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/worldtp <player> <world>");
    }
}

```

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

### Command Mapping with Parameters in Java for Items

Source: https://context7.com/ultikits/ultikits-command/llms.txt

This snippet shows command mapping with @CmdParam for giving items using automatic type conversion in a Spigot plugin. It requires UltiTools annotations and handles player validation; inputs are player, material, and amount; outputs include inventory additions and messages. Limitations involve type conversion errors and player existence checks.

```Java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;

@CmdTarget(CmdTarget.CmdTargetType.PLAYER)
@CmdExecutor(
    permission = "example.give",
    description = "Give items to players",
    alias = {"give"}
)
public class GiveCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "<player> <material> <amount>")
    public void giveItem(
        @CmdSender Player sender,
        @CmdParam("player") Player target,
        @CmdParam("material") Material material,
        @CmdParam("amount") int amount
    ) {
        if (target == null) {
            sender.sendMessage("Player not found!");
            return;
        }

        ItemStack item = new ItemStack(material, amount);
        target.getInventory().addItem(item);
        sender.sendMessage(String.format("Gave %d %s to %s", amount, material.name(), target.getName()));
        target.sendMessage(String.format("You received %d %s", amount, material.name()));
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/give <player> <material> <amount>");
    }
}
```

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

### Register Custom Type Parsers with UltiKits

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Demonstrates how to register custom type parsers for enums like 'Currency' to extend parameter parsing capabilities. This allows the command system to automatically convert string inputs to custom types.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.util.Arrays;

enum Currency {
    GOLD, SILVER, COPPER;

    public static Currency fromString(String s) {
        return Currency.valueOf(s.toUpperCase());
    }
}

@CmdExecutor(
    description = "Economy commands",
    alias = {"economy", "eco"}
)
public class EconomyCommand extends AbstractCommendExecutor {

    public EconomyCommand() {
        super();
        // Register custom parser for Currency enum
        getParsers().put(
            Arrays.asList(Currency.class, Currency[].class),
            Currency::fromString
        );
    }

    @CmdMapping(format = "give <player> <amount> <currency>")
    public void giveMoney(
        @CmdSender Player sender,
        @CmdParam("player") Player target,
        @CmdParam("amount") int amount,
        @CmdParam("currency") Currency currency
    ) {
        // Your economy logic here
        target.sendMessage(String.format("You received %d %s", amount, currency.name()));
        sender.sendMessage(String.format("Gave %d %s to %s", amount, currency.name(), target.getName()));
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/economy give <player> <amount> <currency>");
    }
}
```

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

### Method-Level Permissions with @CmdMapping (Java)

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Demonstrates how to apply specific permissions to individual command methods using the @CmdMapping annotation, overriding class-level permissions. This allows for granular control over who can execute specific subcommands. It requires the UltiTools-Command library.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdExecutor(
    permission = "example.kit.basic",
    description = "Kit commands",
    alias = {"kit"}
)
public class KitCommand extends AbstractCommendExecutor {

    @CmdMapping(format = "starter")
    public void starterKit(@CmdSender Player player) {
        // Uses class-level permission: example.kit.basic
        giveStarterItems(player);
        player.sendMessage("Starter kit received!");
    }

    @CmdMapping(format = "vip", permission = "example.kit.vip")
    public void vipKit(@CmdSender Player player) {
        // Requires specific permission: example.kit.vip
        giveVIPItems(player);
        player.sendMessage("VIP kit received!");
    }

    @CmdMapping(format = "admin", permission = "example.kit.admin", requireOp = true)
    public void adminKit(@CmdSender Player player) {
        // Requires permission AND op status
        giveAdminItems(player);
        player.sendMessage("Admin kit received!");
    }

    private void giveStarterItems(Player player) { /* implementation */ }
    private void giveVIPItems(Player player) { /* implementation */ }
    private void giveAdminItems(Player player) { /* implementation */ }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/kit starter - Get starter kit");
        sender.sendMessage("/kit vip - Get VIP kit (requires permission)");
        sender.sendMessage("/kit admin - Get admin kit (requires OP)");
    }
}

```

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

### Register CommandManager in Java for Bukkit

Source: https://context7.com/ultikits/ultikits-command/llms.txt

This snippet demonstrates registering command executors with the CommandManager in a Bukkit JavaPlugin. It requires the UltiTools library dependency and is called during plugin enable/disable to manage command lifecycles. Outputs involve successful registration or unregistration; limitations include dependency on the library jar.

```Java
import com.ultikits.lib.command.CommandManager;
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;

public class ExamplePlugin extends JavaPlugin {
    private CommandManager commandManager;

    @Override
    public void onEnable() {
        commandManager = new CommandManager(this);
        commandManager.register(new TeleportCommand());
        commandManager.register(new EconomyCommand());
    }

    @Override
    public void onDisable() {
        // Unregister all commands when plugin disables
        commandManager.unregisterAll();
    }
}
```

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

### Command Execution Lock with @UsageLimit

Source: https://context7.com/ultikits/ultikits-command/llms.txt

The @UsageLimit annotation prevents concurrent execution of commands, thereby avoiding race conditions and resource conflicts. It supports different limit types like ALL (global) and SENDER (per-sender), and can optionally include the console sender.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdExecutor(
    description = "Server backup commands",
    alias = {"backup"},
    requireOp = true
)
public class BackupCommand extends AbstractCommendExecutor {

    @RunAsync
    @UsageLimit(value = UsageLimit.LimitType.ALL, ContainConsole = true)
    @CmdMapping(format = "create")
    public void createBackup(@CmdSender CommandSender sender) {
        sender.sendMessage("Starting server backup...");

        try {
            // Simulate long backup process
            Thread.sleep(5000);
            performBackup();
            sender.sendMessage("Backup completed successfully!");
        } catch (InterruptedException e) {
            sender.sendMessage("Backup interrupted!");
        }
    }

    @UsageLimit(value = UsageLimit.LimitType.SENDER, ContainConsole = false)
    @CmdMapping(format = "personal")
    public void createPersonalBackup(@CmdSender Player player) {
        player.sendMessage("Creating your personal backup...");
        // Each player can only have one personal backup running at a time
        createPlayerBackup(player);
        player.sendMessage("Personal backup complete!");
    }

    private void performBackup() {
        // Backup implementation
    }

    private void createPlayerBackup(Player player) {
        // Player-specific backup implementation
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/backup create - Create server backup (one at a time)");
        sender.sendMessage("/backup personal - Create personal backup");
    }
}

```

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

### Apply Command Cooldowns with @CmdCD Annotation

Source: https://context7.com/ultikits/ultikits-command/llms.txt

Shows how to implement command cooldowns using the @CmdCD annotation. This prevents command spam by enforcing a time delay between executions for a specific command or sender.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdTarget(CmdTarget.CmdTargetType.PLAYER)
@CmdExecutor(
    description = "Heal command with cooldown",
    alias = {"heal"}
)
public class HealCommand extends AbstractCommendExecutor {

    @CmdCD(60)  // 60 second cooldown
    @CmdMapping(format = "")
    public void heal(@CmdSender Player player) {
        player.setHealth(20.0);
        player.setFoodLevel(20);
        player.sendMessage("You have been healed! (Cooldown: 60 seconds)");
    }

    @CmdMapping(format = "<player>")
    @CmdMapping(permission = "example.heal.others")
    @CmdCD(30)  // 30 second cooldown for healing others
    public void healOther(
        @CmdSender Player sender,
        @CmdParam("player") Player target
    ) {
        target.setHealth(20.0);
        target.setFoodLevel(20);
        target.sendMessage("You have been healed by " + sender.getName());
        sender.sendMessage("Healed " + target.getName());
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/heal - Heal yourself (60s cooldown)");
        sender.sendMessage("/heal <player> - Heal another player (30s cooldown)");
    }
}
```

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

### Sender Type Restriction with @CmdTarget

Source: https://context7.com/ultikits/ultikits-command/llms.txt

The @CmdTarget annotation restricts command execution to specific sender types, such as PLAYER, CONSOLE, or BOTH. This ensures that commands are only invoked by the intended type of user or entity, enhancing security and usability.

```java
import com.ultikits.lib.command.abstracts.AbstractCommendExecutor;
import com.ultikits.lib.command.annotations.*;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

@CmdExecutor(
    description = "Administration commands",
    alias = {"admin"}
)
public class AdminCommand extends AbstractCommendExecutor {

    @CmdTarget(CmdTarget.CmdTargetType.PLAYER)
    @CmdMapping(format = "inventory")
    public void openInventory(@CmdSender Player player) {
        // Only players can open inventories
        player.openInventory(Bukkit.createInventory(null, 27, "Admin Panel"));
    }

    @CmdTarget(CmdTarget.CmdTargetType.CONSOLE)
    @CmdMapping(format = "shutdown")
    public void shutdownServer(@CmdSender CommandSender sender) {
        // Only console can shutdown server
        sender.sendMessage("Shutting down server in 10 seconds...");
        Bukkit.shutdown();
    }

    @CmdTarget(CmdTarget.CmdTargetType.BOTH)
    @CmdMapping(format = "status")
    public void serverStatus(@CmdSender CommandSender sender) {
        // Both players and console can check status
        sender.sendMessage("Server TPS: 20.0");
        sender.sendMessage("Online Players: " + Bukkit.getOnlinePlayers().size());
    }

    @Override
    protected void handleHelp(CommandSender sender) {
        sender.sendMessage("/admin inventory - Open admin panel (players only)");
        sender.sendMessage("/admin shutdown - Shutdown server (console only)");
        sender.sendMessage("/admin status - Check server status");
    }
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.