diff --git a/README.md b/README.md
index e8e74a8..5949126 100644
--- a/README.md
+++ b/README.md
@@ -14,18 +14,16 @@ _The `EasyLibrary` is a powerful plugin for PocketMine-MP that serves as a colle
 
 To use EasyLibrary's features you can do it in 2 ways, use the one you find most interesting, I recommend using it as a plug for greater ease!
 - **As a plugin:** Being the simplest way where you just need to add EasyLibrary.phar to your server and it will start all the library components, you can modify which components you want to keep active in the plugin's `config.yml` if you want!
-- **As a inyernal library:** You must add it inside the plugin's src, keeping it in the root src folder for everything to work normally. Using this method, you will have to start the components yourself in your main.
+- **As a internal library:** You must add it inside the plugin's src, keeping it in the root src folder for everything to work normally. Using this method, you will have to start the components yourself in your main.
 
 ### Examples 
 
-Example PocketMine-MP plugin with EasyLibrary, showing some basic features of the Library: [PluginExample](https://github.com/ImperaZim/EasyLibrary-Plugin-Example).
+Example PocketMine-MP plugin with EasyLibrary, showing some basic features of the Library: [LibForm Docs](https://github.com/ImperaZim/LibForm), [LibCommand Docs](https://github.com/ImperaZim/LibCommand).
 
 ## Licensing information
 This project is licensed under MIT. Please see the [LICENSE](/LICENSE) file for details.
 
 ## Credits
 Public libraries integrated into the source code to facilitate the use of EasyLibrary. I do not have any rights to the libraries below!
-- [CortexPE/Commando](https://github.com/CortexPE/Commando)
 - [Muqsit/InvMenu](https://github.com/Muqsit/InvMenu)
-- [Muqsit/SimplePacketHandler](https://github.com/Muqsit/SimplePacketHandler)
 - [CustomiesDevs/Customies](https://github.com/CustomiesDevs/Customies)
diff --git a/changelogs/1.3.md b/changelogs/1.3.md
index ec697e3..cd02b5c 100644
--- a/changelogs/1.3.md
+++ b/changelogs/1.3.md
@@ -1,12 +1,14 @@
-# 1.3.0
+**Versions:** [1.3.0](https://github.com/ImperaZim/EasyLibrary/blob/development/changelogs/1.3.md#13) | [1.3.1](https://github.com/ImperaZim/EasyLibrary/blob/development/changelogs/1.3.md#131) | [1.3.2](https://github.com/ImperaZim/EasyLibrary/blob/development/changelogs/1.3.md#132) 
+
+# 1.3
 
 Released February 14, 2025
 
-**For PocketMine-MP 5.24.0**
+**For PocketMine-MP 5.24.X**
 
-1.3.0 is a major feature update to EasyLibrary, including support for PocketMine-MP 5.24.0 plugins, bringing a large list of features and improvements over the previous version.
+1.3.0 is a major feature update to EasyLibrary, including support for PocketMine-MP 5.24.X plugins, bringing a large list of features and improvements over the previous version.
 
-It is **not** compatible with plugins written for version 1.2.0 or lower, and plugins may require code changes to work with it.
+It is **not** compatible with plugins written for version 1.2.X or lower, and plugins may require code changes to work with it.
 
 **As this changelog is quite large, its accuracy and completeness cannot be guaranteed. Make sure you're looking at the [latest revision](https://github.com/ImperaZim/EasyLibrary/blob/development/changelogs/1.3.md), as it may be amended after relatest**
 
@@ -912,8 +914,148 @@ echo "Current time: " . TimeUtils::GetCurrentTime();
 ---
 # 1.3.1
 
-**For PocketMine-MP 5.25.0**
+**For PocketMine-MP 5.25.X**
 
 This is an update to fix changes made and bugs caused by PocketMine-MP 5.25x.
 
 It is not compatible with plugins written for version 1.3.0 or lower, and plugins may require code changes to work with it.
+
+
+# 1.3.2  
+**For PocketMine-MP 5.25.X**  
+
+## Components
+
+### General
+
+### `imperazim\components\trigger`
+
+- **`ItemTrigger:`** Creates a trigger that executes an action for players who have a specific item in their inventory.  
+  Example usage:
+  ```php
+  use imperazim\components\trigger\ItemTrigger;
+  use pocketmine\item\GoldenApple;
+
+  // Automatically checks if the player has the item and executes the action
+  $itemTrigger = new ItemTrigger(
+    GoldenApple::class,
+    function(Player $player, PlayerInventory $inventory): void {
+      $player->sendMessage("You have a golden apple in your inventory!");
+      // Optional: Interact with the inventory
+      $inventory->removeItem($inventory->getItem(0)); // Removes first slot item
+    }
+  );
+  ```
+  No need to manually write item-checking conditions - simply provide the item class and callback.
+
+
+## Vendor 
+
+### `imperazim\vendor\customies\item`
+
+### Core Mechanics
+- **`StackedByDataComponent`**: Controls item stacking behavior for variants with different aux values.  
+  **Example:**
+  ```php
+  $item->addComponent(new StackedByDataComponent(true)); // Allows stacking of items with different aux values
+  ```
+
+- **`ShouldDespawnComponent`**: Toggles item despawn mechanics for floating entities.  
+  **Example:**
+  ```php
+  $item->addComponent(new ShouldDespawnComponent(false)); // Prevents the item from despawning
+  ```
+
+- **`ShooterComponent`**: Enables projectile launching (requires `UseModifiersComponent`).  
+  **Example:**
+  ```php
+  $item->addComponent(new ShooterComponent("arrow", ...view component)); // Shoots arrows with a speed of 1.5
+  ```
+
+- **`RecordComponent`**: Adds music playback functionality to items.  
+  **Example:**
+  ```php
+  $item->addComponent(new RecordComponent(1, 60, "record.song")); // Plays a specific music record
+  ```
+
+- **`ItemTaskComponent`**: Creates a new ItemTaskComponent to define a task that checks for specific items in a player's inventory.  
+  **Example:**
+  ```php
+  $item->addComponent(new ItemTaskComponent(
+    self::class,
+    function(Player $player, Item $item): void {
+      $player->sendMessage("You are holding a Diamond Sword!");
+    },
+    ItemTaskComponent::FILTER_HAND
+  ));
+  ```
+
+### Visual & Interaction
+- **`HoverTextColorComponent`**: Sets custom color for item name hover text.  
+  **Example:**
+  ```php
+  $item->addComponent(new HoverTextColorComponent("color")); // Sets hover text color to red. See: https://minecraft.wiki/w/Formatting_codes#Color_codes
+  ```
+
+- **`GlintComponent`**: Toggles enchantment glow effect.  
+  **Example:**
+  ```php
+  $item->addComponent(new GlintComponent(true)); // Adds an enchantment glow to the item
+  ```
+
+- **`InteractButtonComponent`**: Configures touch control interaction button (supports custom text).  
+  **Example:**
+  ```php
+  $item->addComponent(new InteractButtonComponent("Use Item")); // Displays "Use Item" on the interact button
+  ```
+
+- **`LiquidClippedComponent`**: Defines liquid block interaction behavior.  
+  **Example:**
+  ```php
+  $item->addComponent(new LiquidClippedComponent(true)); // Allows interaction with liquid blocks
+  ```
+
+### Item Customization
+- **`DyeableComponent`**: Enables cauldron-based dyeing (requires `dyed` texture definition).  
+  **Example:**
+  ```php
+  $item->addComponent(new DyeableComponent("#hex")); // Allows the item to be dyed in a cauldron
+  ```
+
+- **`EnchantableSlotComponent`**: Restricts applicable enchantment types (e.g., bow-only enchants).  
+  **Example:**
+  ```php
+  $item->addComponent(new EnchantableSlotComponent(self::SLOT_NAME)); // Allows only slot_name enchantments
+  ```
+
+- **`EnchantableValueComponent`**: Sets base enchantment strength.  
+  **Example:**
+  ```php
+  $item->addComponent(new EnchantableValueComponent(10)); // Sets base enchantment strength to 10
+  ```
+
+### Combat & Durability
+- **`DamageComponent`**: Increases attack damage (positive values only).  
+  **Example:**
+  ```php
+  $item->addComponent(new DamageComponent(5)); // Adds 5 extra damage to the item
+  ```
+
+- **`DamageAbsorptionComponent`**: Reduces incoming damage when equipped as armor (requires durability).  
+  **Example:**
+  ```php
+  $item->addComponent(new DamageAbsorptionComponent(3)); // Absorbs 3 points of damage
+  ```
+
+### Specialized Systems
+- **`BundleInteractionComponent`**: Enables bundle storage mechanics (requires `storage_item` component).  
+  **Example:**
+  ```php
+  $item->addComponent(new BundleInteractionComponent(4)); // Enables Bundle Interactions with 4 slots
+  ```
+
+- **`UseModifiersComponent`**: Configures item usage timing for food/throwable/shooter items.  
+  **Example:**
+  ```php
+  $item->addComponent(new UseModifiersComponent(1.0, 1.5)); // Sets item usage modifiers +1.0 with duration to 1.5 seconds
+  ```
\ No newline at end of file
diff --git a/src/Library.php b/src/Library.php
index b73088f..9d2fae8 100644
--- a/src/Library.php
+++ b/src/Library.php
@@ -5,28 +5,38 @@
 use imperazim\components\plugin\PluginToolkit;
 use imperazim\components\plugin\traits\PluginToolkitTrait;
 
+use imperazim\components\commands\PluginsCommand;
+use imperazim\components\commands\VersionCommand;
+
 /**
 * Class Library
 * TODO: This class should not be called in other plugins!
 */
 final class Library extends PluginToolkit {
-  use PluginToolkitTrait;
-
-  public LibraryComponents $componentsManager;
-
-  /**
-  * This method is called when the plugin is enabled.
-  */
-  protected function onEnable(): void {
-    self::setInstance($this);
-    $this->componentsManager = new LibraryComponents($this);
-    $this->componentsManager->enableComponents();
-  }
-
-  /**
-  * This method is called when the plugin is disabled.
-  */
-  protected function onDisable(): void {
-    $this->componentsManager->disableComponents();
-  }
+    use PluginToolkitTrait;
+
+    public LibraryComponents $componentsManager;
+
+    /**
+    * This method is called when the plugin is enabled.
+    */
+    protected function onEnable(): void {
+        self::setInstance($this);
+        LibraryModules::loadModules($this);
+
+        $this->componentsManager = new LibraryComponents($this);
+        $this->componentsManager->enableComponents();
+
+        $this->overwriteCommands($this, [
+            'plugins' => PluginsCommand::class,
+            'version' => VersionCommand::class,
+        ]);
+    }
+
+    /**
+    * This method is called when the plugin is disabled.
+    */
+    protected function onDisable(): void {
+        $this->componentsManager->disableComponents();
+    }
 }
\ No newline at end of file
diff --git a/src/LibraryComponents.php b/src/LibraryComponents.php
index 7eae745..602a733 100644
--- a/src/LibraryComponents.php
+++ b/src/LibraryComponents.php
@@ -2,17 +2,15 @@
 
 declare(strict_types = 1);
 
-use imperazim\bugfixes\BugFixesManager;
+use imperazim\vendor\fix\BugFixesManager;
 
 use imperazim\components\filesystem\File;
 use imperazim\components\world\WorldManager;
 use imperazim\components\plugin\PluginToolkit;
 use imperazim\components\trigger\TriggerManager;
-use imperazim\components\command\CommandManager;
 use imperazim\components\hud\bossbar\BossBarManager;
 
 use imperazim\vendor\invmenu\InvMenuManager;
-use imperazim\vendor\commando\CommandoManager;
 use imperazim\vendor\customies\CustomiesManager;
 use imperazim\vendor\customies\enchantment\CustomiesEchantmentManager;
 
@@ -30,10 +28,8 @@ final class LibraryComponents {
     'World' => WorldManager::class,
     'BossBar' => BossBarManager::class,
     'InvMenu' => InvMenuManager::class,
-    'Command' => CommandManager::class,
     'Triggers' => TriggerManager::class,
     'BugFixes' => BugFixesManager::class,
-    'Commando' => CommandoManager::class,
     'Customies' => CustomiesManager::class,
     'CustomiesEnchantment' => CustomiesEchantmentManager::class,
   ];
diff --git a/src/LibraryModules.php b/src/LibraryModules.php
new file mode 100644
index 0000000..caf006e
--- /dev/null
+++ b/src/LibraryModules.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types = 1);
+
+use pocketmine\plugin\PluginBase;
+use imperazim\command\LibCommandHooker;
+
+/**
+* Class LibraryModules
+* TODO: This class should not be called in other plugins!
+*/
+final class LibraryModules {
+
+    /**
+    * Load all modules.
+    */
+    public static function loadModules(PluginBase $plugin): void {
+        $pluginManager = $plugin->getServer()->getPluginManager();
+        if ($pluginManager->getPlugin('LibCommand') !== null) {
+            LibCommandHooker::registerInterceptor($plugin);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/imperazim/command/Command.php b/src/imperazim/command/Command.php
new file mode 100644
index 0000000..45b3eb3
--- /dev/null
+++ b/src/imperazim/command/Command.php
@@ -0,0 +1,178 @@
+<?php
+
+declare(strict_types=1);
+
+namespace imperazim\command;
+
+use pocketmine\plugin\Plugin;
+use pocketmine\command\Command as PMMPCommand;
+use pocketmine\command\CommandSender;
+use pocketmine\permission\DefaultPermissions;
+use imperazim\command\traits\SubCommandTrait;
+use imperazim\command\traits\ArgumentableTrait;
+use imperazim\command\traits\ConstraintableTrait;
+use imperazim\command\argument\Argument;
+use imperazim\command\constraint\Constraint;
+use imperazim\command\constraint\PermissionConstraint;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+
+/**
+ * Abstract base class for custom commands.
+ * Extends PocketMine's base command with advanced features like constraints,
+ * subcommands, and argument parsing.
+ */
+abstract class Command extends PMMPCommand {
+  use SubCommandTrait;
+  use ArgumentableTrait;
+  use ConstraintableTrait;
+
+  /** @var Plugin The plugin that owns this command */
+  private readonly Plugin $plugin;
+
+  /**
+   * Constructor.
+   *
+   * @param Plugin $plugin The plugin that owns this command
+   */
+  public function __construct(Plugin $plugin) {
+    $this->plugin = $plugin;
+    $config = $this->onBuild();
+
+    $name = $config["name"] ?? "command";
+    $description = $config["description"] ?? "";
+    $aliases = $config["aliases"] ?? [];
+    $permission = $config["permission"] ?? DefaultPermissions::ROOT_USER;
+
+    parent::__construct(
+      $name,
+      $description,
+      $this->buildUsage($config),
+      $aliases
+    );
+
+    // Add permission constraint if none provided
+    $config["constraints"][] = new PermissionConstraint($permission);
+
+    // Register constraints
+    foreach ($config["constraints"] ?? [] as $constraint) {
+      $this->addConstraint($constraint);
+    }
+
+    // Register subcommands
+    foreach ($config["subcommands"] ?? [] as $subcommand) {
+      $this->addSubCommand($subcommand);
+    }
+
+    // Register arguments
+    foreach ($config["arguments"] ?? [] as $argument) {
+      $this->addArgument($argument);
+    }
+
+    $this->setPermission($permission);
+  }
+
+  /**
+   * Gets the plugin that owns this command.
+   *
+   * @return Plugin The owning plugin
+   */
+  public function getPlugin(): Plugin {
+    return $this->plugin;
+  }
+
+  /**
+   * Executes the command.
+   *
+   * @param CommandSender $sender The command sender
+   * @param string $label The command label used
+   * @param array $rawArgs Raw arguments passed to the command
+   */
+  public function execute(
+    CommandSender $sender,
+    string $label,
+    array $rawArgs
+  ): void {
+    // Handle subcommands first (before checking parent constraints)
+    if (!empty($rawArgs)) {
+      $key = strtolower(array_shift($rawArgs));
+      foreach ($this->getSubCommands() as $sub) {
+        $name = $sub->getName();
+        $aliases = $sub->getAliases();
+        if ($key === $name || in_array($key, $aliases, true)) {
+          $sub->execute($sender, $label . " " . $name, $rawArgs);
+          return;
+        }
+      }
+    }
+
+    // Check constraints only for the main command (not subcommands)
+    $constraintResult = $this->testConstraints($sender);
+    if (!$constraintResult["success"]) {
+      $this->onFailure(
+        new CommandFailure($sender, CommandFailure::CONSTRAINT_FAILED, [
+          "failed_constraints" => $constraintResult["failed_constraints"],
+        ])
+      );
+      return;
+    }
+
+    // Parse and validate arguments
+    $processedArgs = $this->parseRawArgs($rawArgs);
+    $validation = $this->validateArguments($sender, $processedArgs);
+    if (!$validation["valid"]) {
+      $this->onFailure(
+        new CommandFailure($sender, $validation["type"], [
+          "message" => $validation["message"],
+          "argument_errors" => $validation["argument_errors"] ?? [],
+        ])
+      );
+      return;
+    }
+
+    $parsedArgs = $this->parseArguments($sender, $rawArgs);
+
+    try {
+      // Execute command logic
+      $this->onExecute(new CommandResult($sender, $parsedArgs, $label));
+    } catch (\Throwable $e) {
+      try {
+        $this->onFailure(
+          new CommandFailure($sender, CommandFailure::EXECUTION_ERROR, [
+            "message" => $e->getMessage(),
+            "file" => $e->getFile(),
+            "line" => $e->getLine(),
+            "trace" => $e->getTraceAsString(),
+          ])
+        );
+      } catch (\Throwable $e) {
+        $this->plugin->getLogger()->warning("Fatal error: " . $e->getMessage());
+        $this->plugin
+          ->getLogger()
+          ->warning("Location: {$e->getFile()}:{$e->getLine()}");
+      }
+    }
+  }
+
+  /**
+   * Builds the command configuration.
+   * Must return an array with command settings.
+   *
+   * @return array Command configuration
+   */
+  abstract public function onBuild(): array;
+
+  /**
+   * Executes the command logic.
+   *
+   * @param CommandResult $result The command execution result
+   */
+  abstract public function onExecute(CommandResult $result): void;
+
+  /**
+   * Handles command execution failures.
+   *
+   * @param CommandFailure $failure The failure details
+   */
+  abstract public function onFailure(CommandFailure $failure): void;
+}
diff --git a/src/imperazim/command/CommandArguments.php b/src/imperazim/command/CommandArguments.php
new file mode 100644
index 0000000..64fc7af
--- /dev/null
+++ b/src/imperazim/command/CommandArguments.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace imperazim\command;
+
+use ArrayAccess;
+use IteratorAggregate;
+use Countable;
+use ArrayIterator;
+use Traversable;
+use InvalidArgumentException;
+use pocketmine\command\CommandSender;
+
+/**
+ * Represents parsed command arguments with array-like access.
+ * Implements ArrayAccess, IteratorAggregate, and Countable for easy manipulation.
+ */
+final class CommandArguments implements ArrayAccess, IteratorAggregate, Countable {
+    
+  /** @var CommandSender The command sender */
+  private readonly CommandSender $sender;
+
+  /** @var array The parsed arguments */
+  private array $arguments = [];
+
+  /**
+   * Constructor.
+   *
+   * @param CommandSender $sender The command sender
+   * @param array $arguments The parsed arguments
+   */
+  public function __construct(CommandSender $sender, array $arguments = []) {
+    $this->sender = $sender;
+    $this->arguments = $arguments;
+  }
+
+  /**
+   * Checks if an argument exists.
+   *
+   * @param mixed $offset Argument name
+   * @return bool True if exists, false otherwise
+   */
+  public function offsetExists(mixed $offset): bool {
+    return isset($this->arguments[$offset]);
+  }
+
+  /**
+   * Gets an argument value.
+   *
+   * @param mixed $offset Argument name
+   * @return mixed Argument value or null
+   */
+  public function offsetGet(mixed $offset): mixed {
+    return $this->arguments[$offset] ?? null;
+  }
+
+  /**
+   * Sets an argument value.
+   *
+   * @param mixed $offset Argument name
+   * @param mixed $value Argument value
+   *
+   * @throws InvalidArgumentException If offset is null
+   */
+  public function offsetSet(mixed $offset, mixed $value): void {
+    if ($offset === null) {
+      throw new InvalidArgumentException("Argument must have a name");
+    }
+    $this->arguments[$offset] = $value;
+  }
+
+  /**
+   * Removes an argument.
+   *
+   * @param mixed $offset Argument name
+   */
+  public function offsetUnset(mixed $offset): void {
+    unset($this->arguments[$offset]);
+  }
+
+  /**
+   * Gets an iterator for the arguments.
+   *
+   * @return Traversable Argument iterator
+   */
+  public function getIterator(): Traversable {
+    return new ArrayIterator($this->arguments);
+  }
+
+  /**
+   * Counts the number of arguments.
+   *
+   * @return int Number of arguments
+   */
+  public function count(): int {
+    return count($this->arguments);
+  }
+
+  /**
+   * Converts arguments to an array.
+   *
+   * @return array Arguments as array
+   */
+  public function toArray(): array {
+    return $this->arguments;
+  }
+
+  /**
+   * Gets an argument value with default fallback.
+   *
+   * @param string $key Argument name
+   * @param mixed $default Default value if not found
+   * @return mixed Argument value or default
+   */
+  public function get(string $key, mixed $default = null): mixed {
+    return $this->arguments[$key] ?? $default;
+  }
+}
diff --git a/src/imperazim/command/LibCommand.php b/src/imperazim/command/LibCommand.php
new file mode 100644
index 0000000..f84a264
--- /dev/null
+++ b/src/imperazim/command/LibCommand.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command;
+
+use pocketmine\plugin\PluginBase;
+
+/**
+* Main library for advanced command system.
+* Handles command registration and packet interception for dynamic command UI.
+*/
+class LibCommand extends PluginBase {
+
+    /**
+    * Called when the plugin enables.
+    * Registers the interceptor and test commands.
+    */
+    protected function onEnable(): void {
+        LibCommandHooker::registerInterceptor($this);
+    }
+
+}
\ No newline at end of file
diff --git a/src/imperazim/command/LibCommandHooker.php b/src/imperazim/command/LibCommandHooker.php
new file mode 100644
index 0000000..56ce54c
--- /dev/null
+++ b/src/imperazim/command/LibCommandHooker.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command;
+
+use imperazim\packet\LibPacket;
+use pocketmine\event\EventPriority;
+use pocketmine\plugin\PluginBase;
+
+/**
+* Load and start libcommand hooks
+*/
+final class LibCommandHooker {
+
+    /** @var bool Flag indicating if interceptor is registered */
+    protected static bool $registered = false;
+
+    /**
+    * Registers the packet interceptor for dynamic command UI.
+    *
+    * @param PluginBase $plugin The plugin instance
+    *
+    * @throws \Exception If interceptor is already registered
+    */
+    public static function registerInterceptor(PluginBase $plugin): void {
+        if (self::$registered) {
+            throw new \Exception("Command interceptor already registered.");
+        }
+
+        $priority = EventPriority::HIGHEST;
+        $interceptor = LibPacket::createInterceptor($plugin, $priority);
+        $interceptor->registerOutgoing(new LibCommandInterceptor());
+
+        self::$registered = true;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/LibCommandInterceptor.php b/src/imperazim/command/LibCommandInterceptor.php
new file mode 100644
index 0000000..ae93515
--- /dev/null
+++ b/src/imperazim/command/LibCommandInterceptor.php
@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command;
+
+use pocketmine\Server;
+use pocketmine\player\Player;
+use pocketmine\event\EventPriority;
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
+use pocketmine\network\mcpe\protocol\types\command\CommandOverload;
+use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
+use imperazim\packet\handler\PacketHandlerInterface;
+use imperazim\command\enum\CommandEnumManager;
+
+/**
+* Intercepts AvailableCommandsPacket to dynamically modify command UI.
+* Applies constraints and rebuilds command overloads based on player permissions.
+*/
+final class LibCommandInterceptor implements PacketHandlerInterface {
+
+    /**
+    * Gets the packet IDs this handler manages.
+    *
+    * @return array Packet network IDs
+    */
+    public function getPacketIds(): array {
+        return [AvailableCommandsPacket::NETWORK_ID];
+    }
+
+    /**
+    * Handles the AvailableCommandsPacket.
+    *
+    * @param mixed $packet The packet to handle
+    * @param mixed $session The network session
+    *
+    * @return bool Whether to allow the packet to continue
+    */
+    public function handle($packet, $session): bool {
+        if (!$packet instanceof AvailableCommandsPacket) {
+            return true;
+        }
+
+        $player = $session->getPlayer();
+        if (!($player instanceof Player)) {
+            return true;
+        }
+
+        $server = Server::getInstance();
+        foreach ($packet->commandData as $name => $data) {
+            $cmd = $server->getCommandMap()->getCommand($name);
+
+            // Skip non-custom commands
+            if (!($cmd instanceof Command)) {
+                continue;
+            }
+
+            // Apply constraints
+            foreach ($cmd->getConstraints() as $constraint) {
+                if (!$constraint->isSatisfiedBy($player)) {
+                    unset($packet->commandData[$name]);
+                    continue 2;
+                }
+            }
+
+            // Rebuild command UI
+            $packet->commandData[$name]->overloads = $this->getOverloads($player, $cmd);
+        }
+
+        // Update dynamic enums
+        $packet->softEnums = CommandEnumManager::getEnums();
+        return true;
+    }
+
+    /**
+    * Generates command overloads for the command UI.
+    *
+    * @param CommandSender $sender The command sender
+    * @param Command|SubCommand $command The command or subcommand
+    *
+    * @return array Generated command overloads
+    */
+    private function getOverloads(CommandSender $sender, Command|SubCommand $command): array {
+        $overloads = [];
+
+        // Process subcommands
+        foreach ($command->getSubCommands() as $sub) {
+            // Check subcommand constraints
+            foreach ($sub->getConstraints() as $c) {
+                if (!$c->isSatisfiedBy($sender)) {
+                    continue 2;
+                }
+            }
+
+            // Create subcommand parameter
+            $param = new CommandParameter();
+            $param->paramName = $sub->getName();
+            $param->paramType = AvailableCommandsPacket::ARG_FLAG_ENUM | AvailableCommandsPacket::ARG_FLAG_VALID;
+            $param->isOptional = false;
+            $param->enum = new CommandEnum($sub->getName(), [$sub->getName()]);
+
+            // Recursively process child subcommands
+            $child = $this->getOverloads($sender, $sub);
+            if (!empty($child)) {
+                foreach ($child as $ov) {
+                    $overloads[] = new CommandOverload(false, [$param, ...$ov->getParameters()]);
+                }
+            } else {
+                $overloads[] = new CommandOverload(false, [$param]);
+            }
+        }
+
+        // Process arguments
+        $args = $command->getArguments();
+        $sets = [];
+
+        // Normalize arguments to sets
+        foreach ($args as $arg) {
+            $sets[] = is_array($arg) ? $arg : [$arg];
+        }
+
+        // Generate argument combinations
+        $indexes = array_fill(0, count($sets), 0);
+        $total = array_product(array_map(fn($s) => count($s), $sets));
+
+        for ($i = 0; $i < $total; ++$i) {
+            $params = [];
+            foreach ($indexes as $k => $idx) {
+                $argument = $sets[$k][$idx];
+                $param = clone $argument->getParameterData();
+
+                // Handle enums
+                if (isset($param->enum) && $param->enum instanceof CommandEnum) {
+                    $ref = new \ReflectionProperty(CommandEnum::class, 'enumName');
+                    $ref->setAccessible(true);
+                    $ref->setValue($param->enum, 'enum#' . spl_object_id($param->enum));
+                }
+                $params[] = $param;
+            }
+            $overloads[] = new CommandOverload(false, $params);
+
+            // Increment indexes
+            for ($j = count($indexes) - 1; $j >= 0; --$j) {
+                $indexes[$j]++;
+                if ($indexes[$j] < count($sets[$j])) break;
+                $indexes[$j] = 0;
+            }
+        }
+
+        return $overloads;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/SubCommand.php b/src/imperazim/command/SubCommand.php
new file mode 100644
index 0000000..bbd9062
--- /dev/null
+++ b/src/imperazim/command/SubCommand.php
@@ -0,0 +1,176 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command;
+
+use pocketmine\command\CommandSender;
+use pocketmine\permission\DefaultPermissions;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+use imperazim\command\traits\ArgumentableTrait;
+use imperazim\command\traits\ConstraintableTrait;
+use imperazim\command\constraint\PermissionConstraint;
+
+/**
+* Represents a subcommand within a main command.
+* Supports nested subcommands, constraints, and argument parsing.
+*/
+abstract class SubCommand {
+    use ArgumentableTrait;
+    use ConstraintableTrait;
+
+    /** @var array Subcommand configuration */
+    protected array $config;
+
+    /** @var Command|SubCommand The parent command or subcommand */
+    protected Command|SubCommand $parent;
+
+    /**
+    * Constructor.
+    *
+    * @param Command|SubCommand $parent The parent command or subcommand
+    */
+    public function __construct(Command|SubCommand $parent) {
+        $this->parent = $parent;
+        $this->config = $this->onBuild();
+
+        $permission = $this->config['permission'] ?? DefaultPermissions::ROOT_USER;
+        $this->config['constraints'][] = new PermissionConstraint($permission);
+
+        // Register constraints
+        foreach ($this->config['constraints'] ?? [] as $constraint) {
+            $this->addConstraint($constraint);
+        }
+
+        // Register arguments
+        foreach ($this->config['arguments'] ?? [] as $argument) {
+            $this->addArgument($argument);
+        }
+    }
+
+    /**
+    * Gets the owning plugin.
+    *
+    * @return Plugin The plugin instance
+    */
+    public function getPlugin(): Plugin {
+        return $this->parent->getPlugin();
+    }
+
+    /**
+    * Gets the subcommand name.
+    *
+    * @return string The subcommand name
+    */
+    public function getName(): string {
+        return $this->config['name'] ?? 'subcommand';
+    }
+
+    /**
+    * Gets the subcommand description.
+    *
+    * @return string The subcommand description
+    */
+    public function getDescription(): string {
+        return $this->config['description'] ?? '...';
+    }
+
+    /**
+    * Gets the subcommand aliases.
+    *
+    * @return array Subcommand aliases
+    */
+    public function getAliases(): array {
+        return $this->config['aliases'] ?? [];
+    }
+
+    /**
+    * Gets child subcommands.
+    *
+    * @return array Child subcommands
+    */
+    public function getSubCommands(): array {
+        return $this->config['subcommands'] ?? [];
+    }
+
+    /**
+    * Executes the subcommand.
+    *
+    * @param CommandSender $sender The command sender
+    * @param string $label The command label used
+    * @param array $rawArgs Raw arguments passed to the subcommand
+    */
+    public function execute(CommandSender $sender, string $label, array $rawArgs): void {
+        // Check constraints
+        $res = $this->testConstraints($sender);
+        if (!$res['success']) {
+            $this->onFailure(new CommandFailure(
+                $sender,
+                CommandFailure::CONSTRAINT_FAILED,
+                ['failed_constraints' => $res['failed_constraints']]
+            ));
+            return;
+        }
+
+        // Handle child subcommands
+        if (!empty($this->getSubCommands()) && !empty($rawArgs)) {
+            $key = strtolower(array_shift($rawArgs));
+            foreach ($this->getSubCommands() as $sub) {
+                $name = $sub->getName();
+                $aliases = $sub->getAliases();
+                if ($key === $name || in_array($key, $aliases, true)) {
+                    $sub->execute($sender, $label . ' ' . $name, $rawArgs);
+                    return;
+                }
+            }
+        }
+
+        // Parse and validate arguments
+        $processed = $this->parseRawArgs($rawArgs);
+        $valid = $this->validateArguments($sender, $processed);
+        if (!$valid['valid']) {
+            $this->onFailure(new CommandFailure(
+                $sender,
+                $valid['type'],
+                ['message' => $valid['message']]
+            ));
+            return;
+        }
+
+        $parsed = $this->parseArguments($sender, $rawArgs);
+
+        try {
+            // Execute subcommand logic
+            $this->onExecute(new CommandResult($sender, $parsed, $label));
+        } catch (\Throwable $e) {
+            $this->onFailure(new CommandFailure(
+                $sender,
+                CommandFailure::EXECUTION_ERROR,
+                ['error' => $e->getMessage()]
+            ));
+        }
+    }
+
+    /**
+    * Builds the subcommand configuration.
+    * Must return an array with subcommand settings.
+    *
+    * @return array Subcommand configuration
+    */
+    abstract public function onBuild(): array;
+
+    /**
+    * Executes the subcommand logic.
+    *
+    * @param CommandResult $result The command execution result
+    */
+    abstract public function onExecute(CommandResult $result): void;
+
+    /**
+    * Handles subcommand execution failures.
+    *
+    * @param CommandFailure $failure The failure details
+    */
+    abstract public function onFailure(CommandFailure $failure): void;
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/Argument.php b/src/imperazim/command/argument/Argument.php
new file mode 100644
index 0000000..12651d5
--- /dev/null
+++ b/src/imperazim/command/argument/Argument.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Abstract base class for command arguments
+*
+* Provides the foundation for defining command arguments with automatic generation
+* of network-compatible parameter data when not explicitly provided
+*/
+abstract class Argument {
+    /**
+    * Constructs a new command argument
+    *
+    * @param string $name Argument name (must be unique per command)
+    * @param bool $optional Whether the argument is optional
+    * @param CommandParameter|null $parameterData Pre-configured network parameter data
+    *
+    * @throws ArgumentException If argument name contains spaces
+    */
+    public function __construct(
+        private string $name,
+        private bool $optional = false,
+        private ?CommandParameter $parameterData = null
+    ) {
+        if (str_contains($name, ' ')) {
+            throw new ArgumentException("Argument name cannot contain spaces: '{$name}'");
+        }
+
+        if ($this->parameterData === null) {
+            $param = new CommandParameter();
+            $param->paramName = $this->name;
+            $param->paramType = AvailableCommandsPacket::ARG_FLAG_VALID | $this->getNetworkType();
+            $param->isOptional = $this->optional;
+            $this->parameterData = $param;
+        }
+    }
+
+    /**
+    * Gets the argument name
+    *
+    * @return string Argument name
+    */
+    public function getName(): string {
+        return $this->name;
+    }
+
+    /**
+    * Checks if the argument is optional
+    *
+    * @return bool True if optional, false if required
+    */
+    public function isOptional(): bool {
+        return $this->optional;
+    }
+
+    /**
+    * Gets the network-ready parameter data
+    *
+    * @return CommandParameter Network command parameter data
+    */
+    public function getParameterData(): CommandParameter {
+        return $this->parameterData;
+    }
+
+    /**
+    * Returns the formatted representation for usage strings
+    *
+    * @return string Formatted usage representation
+    */
+    public function getUsageFormatted(): string {
+        $name = $this->getName();
+        $type = $this->getTypeName();
+        return $this->optional ? "[{$name}: $type]" : "<{$name}: $type>";
+    }
+
+    /**
+    * Gets the human-readable type name for documentation
+    *
+    * @return string Type name (e.g., "int", "string")
+    */
+    abstract public function getTypeName(): string;
+
+    /**
+    * Gets the network type flag for command registration
+    *
+    * @return int Network type constant from AvailableCommandsPacket
+    */
+    abstract public function getNetworkType(): int;
+
+    /**
+    * Validates if the argument can be parsed from input
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if parsable, false otherwise
+    */
+    abstract public function canParse(string $testString, CommandSender $sender): bool;
+
+    /**
+    * Parses the input string into the appropriate value type
+    *
+    * @param string $argument Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return mixed Parsed value (type depends on implementation)
+    *
+    * @throws ArgumentException If parsing fails
+    */
+    abstract public function parse(string $argument, CommandSender $sender): mixed;
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/BooleanArgument.php b/src/imperazim/command/argument/BooleanArgument.php
new file mode 100644
index 0000000..f8f0c00
--- /dev/null
+++ b/src/imperazim/command/argument/BooleanArgument.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for boolean values
+*
+* Accepts various truthy/falsy representations:
+* - true: 'true', 'yes', '1'
+* - false: 'false', 'no', '0'
+*/
+final class BooleanArgument extends Argument {
+    /** @var string[] Valid truthy/falsy representations */
+    private const VALID_VALUES = [
+        'true',
+        'false',
+        'yes',
+        'no',
+        '1',
+        '0'
+    ];
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "bool"
+    */
+    public function getTypeName(): string {
+        return "bool";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_VALUE constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_VALUE;
+    }
+
+    /**
+    * Checks if input is a valid boolean representation
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if valid boolean string
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        return in_array(strtolower($testString), self::VALID_VALUES, true);
+    }
+
+    /**
+    * Parses input into boolean value
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return bool Parsed boolean value
+    *
+    * @throws ArgumentException If input is not a valid boolean representation
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $normalized = strtolower($value);
+        if (!in_array($normalized, self::VALID_VALUES)) {
+            throw new ArgumentException("Invalid boolean value");
+        }
+        return in_array($normalized, ['true', 'yes', '1']);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/EnumArgument.php b/src/imperazim/command/argument/EnumArgument.php
new file mode 100644
index 0000000..484fad5
--- /dev/null
+++ b/src/imperazim/command/argument/EnumArgument.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
+use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for fixed set of string choices
+*
+* Represents an enumeration of predefined string values
+*/
+class EnumArgument extends Argument {
+
+    /** @var string[] Available choices */
+    protected array $choices = [];
+
+    /**
+    * Constructs an enum argument
+    *
+    * @param string $name Argument name
+    * @param bool $optional Whether argument is optional
+    * @param string[] $choices Available enum choices
+    */
+    public function __construct(
+        string $name,
+        bool $optional = false,
+        array $choices = []
+    ) {
+        $this->choices = $choices;
+        parent::__construct($name, $optional);
+    }
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "enum"
+    */
+    public function getTypeName(): string {
+        return "enum";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int Combination of ARG_FLAG_ENUM and ARG_TYPE_STRING
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_FLAG_ENUM | AvailableCommandsPacket::ARG_TYPE_STRING;
+    }
+
+    /**
+    * Gets the network parameter data with enum definition
+    *
+    * @return CommandParameter Network parameter data with enum
+    */
+    public function getParameterData(): CommandParameter {
+        $param = parent::getParameterData();
+        $param->enum = new CommandEnum($this->getName() . "Enum", $this->choices);
+        return $param;
+    }
+
+    /**
+    * Checks if input is in the predefined choices
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if input matches an enum choice
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        return in_array($testString, $this->choices, true);
+    }
+
+    /**
+    * Returns the input string if valid
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return string The input value
+    *
+    * @throws ArgumentException If input is not a valid choice
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        if (!in_array($value, $this->choices, true)) {
+            throw new ArgumentException("Invalid choice. Valid options: " . implode(", ", $this->choices));
+        }
+        return $value;
+    }
+
+    /**
+    * Gets available enum choices
+    *
+    * @return string[] Array of valid choices
+    */
+    public function getChoices(): array {
+        return $this->choices;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/FloatArgument.php b/src/imperazim/command/argument/FloatArgument.php
new file mode 100644
index 0000000..b62b5e4
--- /dev/null
+++ b/src/imperazim/command/argument/FloatArgument.php
@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for floating-point numbers
+*
+* Supports optional min/max value constraints
+*/
+final class FloatArgument extends Argument {
+
+    /**
+    * Constructs a float argument
+    *
+    * @param string $name Argument name
+    * @param bool $optional Whether argument is optional
+    * @param float|null $min Minimum allowed value (inclusive)
+    * @param float|null $max Maximum allowed value (inclusive)
+    */
+    public function __construct(
+        string $name,
+        bool $optional = false,
+        private ?float $min = null,
+        private ?float $max = null
+    ) {
+        parent::__construct($name, $optional);
+    }
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "float"
+    */
+    public function getTypeName(): string {
+        return "float";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_FLOAT constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_FLOAT;
+    }
+
+    /**
+    * Checks if input is a valid float within constraints
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if valid float within range
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        if (!is_numeric($testString)) {
+            return false;
+        }
+
+        $value = (float)$testString;
+        return ($this->min === null || $value >= $this->min) &&
+        ($this->max === null || $value <= $this->max);
+    }
+
+    /**
+    * Parses input into float value
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return float Parsed float value
+    *
+    * @throws ArgumentException If value is out of range
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $floatValue = (float)$value;
+
+        if ($this->min !== null && $floatValue < $this->min) {
+            throw new ArgumentException("Value must be at least {$this->min}");
+        }
+
+        if ($this->max !== null && $floatValue > $this->max) {
+            throw new ArgumentException("Value must be at most {$this->max}");
+        }
+
+        return $floatValue;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/IntegerArgument.php b/src/imperazim/command/argument/IntegerArgument.php
new file mode 100644
index 0000000..9150f7d
--- /dev/null
+++ b/src/imperazim/command/argument/IntegerArgument.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for integer values
+*
+* Supports optional min/max value constraints
+*/
+final class IntegerArgument extends Argument {
+    /**
+    * Constructs an integer argument
+    *
+    * @param string $name Argument name
+    * @param bool $optional Whether argument is optional
+    * @param int|null $min Minimum allowed value (inclusive)
+    * @param int|null $max Maximum allowed value (inclusive)
+    */
+    public function __construct(
+        string $name,
+        bool $optional = false,
+        private ?int $min = null,
+        private ?int $max = null
+    ) {
+        parent::__construct($name, $optional);
+    }
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "int"
+    */
+    public function getTypeName(): string {
+        return "int";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_INT constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_INT;
+    }
+
+    /**
+    * Checks if input is a valid integer within constraints
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if valid integer within range
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        if (!is_numeric($testString) || !ctype_digit($testString)) {
+            return false;
+        }
+
+        $value = (int)$testString;
+        return ($this->min === null || $value >= $this->min) &&
+        ($this->max === null || $value <= $this->max);
+    }
+
+    /**
+    * Parses input into integer value
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return int Parsed integer value
+    *
+    * @throws ArgumentException If value is out of range
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $intValue = (int)$value;
+
+        if ($this->min !== null && $intValue < $this->min) {
+            throw new ArgumentException("Value must be at least {$this->min}");
+        }
+
+        if ($this->max !== null && $intValue > $this->max) {
+            throw new ArgumentException("Value must be at most {$this->max}");
+        }
+
+        return $intValue;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/ItemArgument.php b/src/imperazim/command/argument/ItemArgument.php
new file mode 100644
index 0000000..2cd40cb
--- /dev/null
+++ b/src/imperazim/command/argument/ItemArgument.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\item\Item;
+use pocketmine\item\StringToItemParser;
+use pocketmine\item\LegacyStringToItemParser;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for item identifiers
+*
+* Supports both modern and legacy item identifiers
+*/
+final class ItemArgument extends Argument {
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "item"
+    */
+    public function getTypeName(): string {
+        return "item";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_STRING constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_STRING;
+    }
+
+    /**
+    * Checks if input matches a known item identifier
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if valid item identifier
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        $item = StringToItemParser::getInstance()->parse($testString) ?? LegacyStringToItemParser::getInstance()->parse($testString);
+        return $item !== null;
+    }
+
+    /**
+    * Parses input into Item object
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return Item Parsed item instance
+    *
+    * @throws ArgumentException If item identifier is unknown
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $item = StringToItemParser::getInstance()->parse($value) ?? LegacyStringToItemParser::getInstance()->parse($value);
+
+        if ($item === null) {
+            throw new ArgumentException("Unknown item '{$value}'");
+        }
+
+        return $item;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/PlayerArgument.php b/src/imperazim/command/argument/PlayerArgument.php
new file mode 100644
index 0000000..47d5644
--- /dev/null
+++ b/src/imperazim/command/argument/PlayerArgument.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\player\Player;
+use pocketmine\Server;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for online player names
+*
+* Matches players by name prefix (case-insensitive)
+*/
+final class PlayerArgument extends Argument {
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "player"
+    */
+    public function getTypeName(): string {
+        return "player";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_TARGET constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_TARGET;
+    }
+
+    /**
+    * Checks if input matches an online player's name (prefix)
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if matches an online player
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        return Server::getInstance()->getPlayerByPrefix($testString) !== null;
+    }
+
+    /**
+    * Parses input into Player object
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return Player Parsed player instance
+    *
+    * @throws ArgumentException If player not found
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $player = Server::getInstance()->getPlayerByPrefix($value);
+        if ($player === null) {
+            throw new ArgumentException("Player '{$value}' not found");
+        }
+
+        return $player;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/StringArgument.php b/src/imperazim/command/argument/StringArgument.php
new file mode 100644
index 0000000..95efde3
--- /dev/null
+++ b/src/imperazim/command/argument/StringArgument.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+
+/**
+* Argument type for string values
+*
+* Accepts any string input without validation
+*/
+final class StringArgument extends Argument {
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "string"
+    */
+    public function getTypeName(): string {
+        return "string";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_STRING constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_STRING;
+    }
+
+    /**
+    * Always returns true since any string is valid
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool Always true
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        return true;
+    }
+
+    /**
+    * Returns the input string unchanged
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return string The input value
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        return $value;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/TargetArgument.php b/src/imperazim/command/argument/TargetArgument.php
new file mode 100644
index 0000000..6b69ae5
--- /dev/null
+++ b/src/imperazim/command/argument/TargetArgument.php
@@ -0,0 +1,280 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\player\Player;
+use pocketmine\Server;
+use pocketmine\entity\Entity;
+use pocketmine\world\World;
+use pocketmine\math\Vector3;
+use imperazim\command\exception\ArgumentException;
+
+/**
+ * Argument type for entity/player targets
+ * 
+ * Supports:
+ * - Player names (exact or prefix)
+ * - Entity selectors (@p, @a, @e, etc.)
+ * - Entity IDs
+ * - Entity name tags
+ */
+final class TargetArgument extends Argument {
+
+  /**
+   * Gets the human-readable type name
+   * 
+   * @return string "target"
+   */
+  public function getTypeName(): string {
+    return "target";
+  }
+
+  /**
+   * Gets the network type flag
+   * 
+   * @return int ARG_TYPE_TARGET constant
+   */
+  public function getNetworkType(): int {
+    return AvailableCommandsPacket::ARG_TYPE_TARGET;
+  }
+
+  /**
+   * Checks if input is a valid target selector
+   * 
+   * @param string $testString Input string to test
+   * @param CommandSender $sender Command executor
+   * @return bool True if valid selector or entity identifier
+   */
+  public function canParse(string $testString, CommandSender $sender): bool {
+    return preg_match('/^@[aeprs]($|\[)/', $testString) ||
+    $this->isValidEntityIdentifier($testString);
+  }
+
+  /**
+   * Parses input into Entity or array of entities
+   * 
+   * @param string $value Input string to parse
+   * @param CommandSender $sender Command executor
+   * @return Entity|Entity[]|null Parsed entity/entities
+   * 
+   * @throws ArgumentException If target not found
+   */
+  public function parse(string $value, CommandSender $sender): mixed {
+    if (preg_match('/^@[aeprs]($|\[)/', $value)) {
+      return $this->parseSelector($value, $sender);
+    }
+
+    $entity = $this->findEntity($value, $sender);
+    if ($entity === null) {
+      throw new ArgumentException("Target '{$value}' not found");
+    }
+
+    return $entity;
+  }
+
+  /**
+   * Checks if input is a valid entity identifier
+   * 
+   * @param string $testString Input string to test
+   * @return bool True if valid identifier (1-16 word characters)
+   */
+  private function isValidEntityIdentifier(string $testString): bool {
+    return preg_match('/^\w{1,16}$/', $testString);
+  }
+
+  /**
+   * Parses entity selector into entity/entities
+   * 
+   * @param string $selector Selector string (@p, @a, etc.)
+   * @param CommandSender $sender Command executor
+   * @return Entity|Entity[]|null Parsed entity/entities
+   * 
+   * @throws ArgumentException For unknown selector types
+   */
+  private function parseSelector(string $selector, CommandSender $sender): mixed {
+    $type = $selector[1];
+    $args = [];
+
+    // Extract arguments if present [arg=value]
+    if (strpos($selector, '[') !== false) {
+      preg_match('/\[(.*?)\]/', $selector, $matches);
+      if (isset($matches[1])) {
+        parse_str(str_replace(',', '&', $matches[1]), $args);
+      }
+    }
+
+    switch ($type) {
+      case 'a': // @a - All players
+        return $this->getAllPlayers($args);
+
+      case 'e': // @e - All entities
+        return $this->getAllEntities($args);
+
+      case 'p': // @p - Nearest player
+        return $this->getNearestPlayer($sender, $args);
+
+      case 'r': // @r - Random player
+        return $this->getRandomPlayer($args);
+
+      case 's': // @s - The sender
+        return $sender instanceof Entity ? $sender : null;
+
+      default:
+        throw new ArgumentException("Unknown selector type: @{$type}");
+    }
+  }
+
+  /**
+   * Gets all players matching filter criteria
+   * 
+   * @param array $args Selector arguments (e.g., ['world' => 'world_name'])
+   * @return Player[] Filtered players
+   */
+  private function getAllPlayers(array $args): array {
+    $players = Server::getInstance()->getOnlinePlayers();
+
+    // Filter by world if specified
+    if (isset($args['world'])) {
+      $worldName = $args['world'];
+      $players = array_filter($players, fn(Player $p) =>
+        $p->getWorld()->getFolderName() === $worldName
+      );
+    }
+
+    return array_values($players);
+  }
+
+  /**
+   * Gets all entities matching filter criteria
+   * 
+   * @param array $args Selector arguments
+   * @return Entity[] Filtered entities
+   */
+  private function getAllEntities(array $args): array {
+    $entities = [];
+
+    foreach (Server::getInstance()->getWorldManager()->getWorlds() as $world) {
+      // Filter by world if specified
+      if (isset($args['world']) && $world->getFolderName() !== $args['world']) {
+        continue;
+      }
+
+      foreach ($world->getEntities() as $entity) {
+        // Filter by type if specified
+        if (isset($args['type']) && get_class($entity) !== $args['type']) {
+          continue;
+        }
+
+        $entities[] = $entity;
+      }
+    }
+
+    return $entities;
+  }
+
+  /**
+   * Gets nearest player to sender
+   * 
+   * @param CommandSender $sender Command executor
+   * @param array $args Selector arguments
+   * @return Player|null Nearest player or sender if none found
+   */
+  private function getNearestPlayer(CommandSender $sender, array $args): ?Player {
+    if (!$sender instanceof Player) {
+      return null;
+    }
+
+    $nearest = null;
+    $minDistance = PHP_INT_MAX;
+    $senderPos = $sender->getPosition();
+
+    foreach (Server::getInstance()->getOnlinePlayers() as $player) {
+      // Filter by world
+      if (isset($args['world']) &&
+        $player->getWorld()->getFolderName() !== $args['world']) {
+        continue;
+      }
+
+      $distance = $player->getPosition()->distance($senderPos);
+      if ($distance < $minDistance && $player !== $sender) {
+        $minDistance = $distance;
+        $nearest = $player;
+      }
+    }
+
+    return $nearest ?? $sender;
+  }
+
+  /**
+   * Gets random player
+   * 
+   * @param array $args Selector arguments
+   * @return Player|null Random player or null if none available
+   */
+  private function getRandomPlayer(array $args): ?Player {
+    $players = Server::getInstance()->getOnlinePlayers();
+
+    // Filter by world if specified
+    if (isset($args['world'])) {
+      $players = array_filter($players, fn(Player $p) =>
+        $p->getWorld()->getFolderName() === $args['world']
+      );
+    }
+
+    return count($players) > 0 ? $players[array_rand($players)] : null;
+  }
+
+  /**
+   * Finds entity by identifier
+   * 
+   * @param string $identifier Entity identifier (name or ID)
+   * @param CommandSender $sender Command executor
+   * @return Entity|null Found entity or null
+   */
+  private function findEntity(string $identifier, CommandSender $sender): ?Entity {
+    $server = Server::getInstance();
+
+    // 1. Try to find player by exact name
+    $player = $server->getPlayerExact($identifier);
+    if ($player !== null) {
+      return $player;
+    }
+
+    // 2. Try to find player by prefix
+    $player = $server->getPlayerByPrefix($identifier);
+    if ($player !== null) {
+      return $player;
+    }
+
+    // 3. Search all entities in the same world as sender
+    if ($sender instanceof Player) {
+      $world = $sender->getWorld();
+      foreach ($world->getEntities() as $entity) {
+        if ($entity instanceof Player) continue;
+
+        if (strtolower($entity->getNameTag()) === strtolower($identifier) ||
+          $entity->getId() === (int)$identifier) {
+          return $entity;
+        }
+      }
+    }
+
+    // 4. Search all entities globally
+    foreach ($server->getWorldManager()->getWorlds() as $world) {
+      foreach ($world->getEntities() as $entity) {
+        if ($entity instanceof Player) continue;
+
+        if (strtolower($entity->getNameTag()) === strtolower($identifier) ||
+          $entity->getId() === (int)$identifier) {
+          return $entity;
+        }
+      }
+    }
+
+    return null;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/argument/WorldArgument.php b/src/imperazim/command/argument/WorldArgument.php
new file mode 100644
index 0000000..7ffdfde
--- /dev/null
+++ b/src/imperazim/command/argument/WorldArgument.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\argument;
+
+use pocketmine\Server;
+use pocketmine\command\CommandSender;
+use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
+use pocketmine\world\WorldManager;
+use imperazim\command\exception\ArgumentException;
+
+/**
+* Argument type for world names
+*
+* Matches loaded worlds by exact name
+*/
+final class WorldArgument extends Argument {
+
+    /**
+    * Gets the human-readable type name
+    *
+    * @return string "world"
+    */
+    public function getTypeName(): string {
+        return "world";
+    }
+
+    /**
+    * Gets the network type flag
+    *
+    * @return int ARG_TYPE_STRING constant
+    */
+    public function getNetworkType(): int {
+        return AvailableCommandsPacket::ARG_TYPE_STRING;
+    }
+
+    /**
+    * Checks if input matches a loaded world name
+    *
+    * @param string $testString Input string to test
+    * @param CommandSender $sender Command executor
+    * @return bool True if world exists
+    */
+    public function canParse(string $testString, CommandSender $sender): bool {
+        return $this->getWorldManager()->getWorldByName($testString) !== null;
+    }
+
+    /**
+    * Parses input into World object
+    *
+    * @param string $value Input string to parse
+    * @param CommandSender $sender Command executor
+    * @return World Parsed world instance
+    *
+    * @throws ArgumentException If world not found
+    */
+    public function parse(string $value, CommandSender $sender): mixed {
+        $world = $this->getWorldManager()->getWorldByName($value);
+
+        if ($world === null) {
+            $worlds = implode(', ', array_keys($this->getWorldManager()->getWorlds()));
+            throw new ArgumentException("World '{$value}' not found. Available worlds: {$worlds}");
+        }
+
+        return $world;
+    }
+
+    /**
+    * Gets WorldManager instance
+    *
+    * @return WorldManager Server world manager
+    */
+    private function getWorldManager(): WorldManager {
+        return Server::getInstance()->getWorldManager();
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/Constraint.php b/src/imperazim/command/constraint/Constraint.php
new file mode 100644
index 0000000..b196ffb
--- /dev/null
+++ b/src/imperazim/command/constraint/Constraint.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\command\CommandSender;
+
+/**
+* Abstract base class for command execution constraints
+*
+* Defines the contract for command constraints that can validate execution context
+*/
+abstract class Constraint {
+    /**
+    * Called when constraint is successfully satisfied
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onSuccess(CommandSender $sender): void {}
+
+    /**
+    * Called when constraint fails validation
+    *
+    * @param CommandSender $sender Command executor
+    */
+    abstract public function onFailure(CommandSender $sender): void;
+
+    /**
+    * Determines if the constraint is satisfied by the sender
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if satisfied, false otherwise
+    */
+    abstract public function isSatisfiedBy(CommandSender $sender): bool;
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/CooldownConstraint.php b/src/imperazim/command/constraint/CooldownConstraint.php
new file mode 100644
index 0000000..fcdcaea
--- /dev/null
+++ b/src/imperazim/command/constraint/CooldownConstraint.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that enforces a cooldown period between command uses
+*
+* Tracks last usage time per sender and prevents reuse until cooldown expires
+*/
+class CooldownConstraint extends Constraint {
+    /**
+    * @var float[] Last usage timestamps indexed by sender key
+    */
+    private static array $lastUsed = [];
+
+    /**
+    * @param float $cooldownSeconds Cooldown duration in seconds
+    */
+    public function __construct(private float $cooldownSeconds) {}
+
+    /**
+    * Records successful command execution time
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onSuccess(CommandSender $sender): void {
+        self::$lastUsed[$this->getSenderKey($sender)] = microtime(true);
+    }
+
+    /**
+    * Notifies sender about remaining cooldown time
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $remaining = $this->getRemainingCooldown($sender);
+        $sender->sendMessage(TextFormat::RED . "Please wait {$remaining} seconds before using this command again");
+    }
+
+    /**
+    * Checks if cooldown period has expired
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if cooldown expired, false otherwise
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        $key = $this->getSenderKey($sender);
+        $currentTime = microtime(true);
+        if (!isset(self::$lastUsed[$key])) {
+            return true;
+        }
+        return ($currentTime - self::$lastUsed[$key]) >= $this->cooldownSeconds;
+    }
+
+    /**
+    * Generates unique key for sender
+    *
+    * @param CommandSender $sender Command executor
+    * @return string Unique identifier (UUID for players, 'console' otherwise)
+    */
+    private function getSenderKey(CommandSender $sender): string {
+        return $sender instanceof Player ? $sender->getUniqueId()->toString() : 'console';
+    }
+
+    /**
+    * Calculates remaining cooldown time
+    *
+    * @param CommandSender $sender Command executor
+    * @return float Remaining cooldown in seconds (formatted to 1 decimal)
+    */
+    private function getRemainingCooldown(CommandSender $sender): float {
+        $key = $this->getSenderKey($sender);
+        $lastTime = self::$lastUsed[$key] ?? 0;
+        $elapsed = microtime(true) - $lastTime;
+        return max(0, number_format($this->cooldownSeconds - $elapsed, 1));
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/GameModeConstraint.php b/src/imperazim/command/constraint/GameModeConstraint.php
new file mode 100644
index 0000000..1cdf76f
--- /dev/null
+++ b/src/imperazim/command/constraint/GameModeConstraint.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\player\Player;
+use pocketmine\player\GameMode;
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that requires sender to be in a specific game mode
+*/
+class GameModeConstraint extends Constraint {
+    /**
+    * @param GameMode $gameMode Required game mode
+    */
+    public function __construct(private GameMode $gameMode) {}
+
+    /**
+    * Notifies sender about incorrect game mode
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $modeName = $this->getModeName();
+        $sender->sendMessage(TextFormat::RED . "You must be in {$modeName} mode to use this command");
+    }
+
+    /**
+    * Checks if sender is in required game mode
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if game mode matches, false otherwise
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        return ($sender instanceof Player) &&
+        ($sender->getGamemode() === $this->gameMode);
+    }
+
+    /**
+    * Gets human-readable game mode name
+    *
+    * @return string Mode name (Survival, Creative, etc.)
+    */
+    private function getModeName(): string {
+        return match($this->gameMode->id()) {
+            GameMode::SURVIVAL()->id() => "Survival",
+            GameMode::CREATIVE()->id() => "Creative",
+            GameMode::ADVENTURE()->id() => "Adventure",
+            GameMode::SPECTATOR()->id() => "Spectator",
+            default => "Unknown"
+            };
+        }
+    }
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/InGameConstraint.php b/src/imperazim/command/constraint/InGameConstraint.php
new file mode 100644
index 0000000..a6874bd
--- /dev/null
+++ b/src/imperazim/command/constraint/InGameConstraint.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that requires command sender to be an in-game player
+*/
+class InGameConstraint extends Constraint {
+    /**
+    * Notifies sender about console usage restriction
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $sender->sendMessage(TextFormat::RED . 'This command can only be used in-game');
+    }
+
+    /**
+    * Checks if sender is an in-game player
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if player, false if console
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        return $sender instanceof Player;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/PermissionConstraint.php b/src/imperazim/command/constraint/PermissionConstraint.php
new file mode 100644
index 0000000..ccac2f5
--- /dev/null
+++ b/src/imperazim/command/constraint/PermissionConstraint.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that enforces permission requirements
+*/
+class PermissionConstraint extends Constraint {
+    /**
+    * @param string $permission Required permission node
+    */
+    public function __construct(private string $permission) {}
+
+    /**
+    * Notifies sender about missing permission
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $sender->sendMessage(TextFormat::RED . "You don't have permission to use this command!");
+    }
+
+    /**
+    * Checks if sender has required permission
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if permission granted, false otherwise
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        return $sender->hasPermission($this->permission);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/RequireConsoleConstraint.php b/src/imperazim/command/constraint/RequireConsoleConstraint.php
new file mode 100644
index 0000000..8c46969
--- /dev/null
+++ b/src/imperazim/command/constraint/RequireConsoleConstraint.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that restricts command usage to console only
+*/
+class RequireConsoleConstraint implements Constraint {
+    /**
+    * Notifies player about console-only restriction
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $sender->sendMessage(TextFormat::RED . 'You need to be in the console to use this command.');
+    }
+
+    /**
+    * Checks if sender is console (not player)
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if console, false if player
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        return (!$sender instanceof Player);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/constraint/WorldConstraint.php b/src/imperazim/command/constraint/WorldConstraint.php
new file mode 100644
index 0000000..ba80999
--- /dev/null
+++ b/src/imperazim/command/constraint/WorldConstraint.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\constraint;
+
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\command\CommandSender;
+
+/**
+* Constraint that restricts command usage to specific worlds
+*/
+class WorldConstraint extends Constraint {
+    /**
+    * @var string[] Allowed world names
+    */
+    private array $allowedWorlds;
+
+    /**
+    * @param string|string[] $worldNames Single world name or array of allowed worlds
+    */
+    public function __construct(string|array $worldNames) {
+        $this->allowedWorlds = (array) $worldNames;
+    }
+
+    /**
+    * Notifies sender about invalid world
+    *
+    * @param CommandSender $sender Command executor
+    */
+    public function onFailure(CommandSender $sender): void {
+        $worlds = implode(', ', $this->allowedWorlds);
+        $sender->sendMessage(TextFormat::RED . "You must be in one of these worlds: $worlds");
+    }
+
+    /**
+    * Checks if sender is in allowed world
+    *
+    * @param CommandSender $sender Command executor
+    * @return bool True if in allowed world, false otherwise
+    */
+    public function isSatisfiedBy(CommandSender $sender): bool {
+        return ($sender instanceof Player) &&
+        in_array($sender->getWorld()->getFolderName(), $this->allowedWorlds, true);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/dynamic/DynamicCommand.php b/src/imperazim/command/dynamic/DynamicCommand.php
new file mode 100644
index 0000000..989b553
--- /dev/null
+++ b/src/imperazim/command/dynamic/DynamicCommand.php
@@ -0,0 +1,201 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\dynamic;
+
+use Closure;
+use pocketmine\plugin\Plugin;
+use pocketmine\permission\DefaultPermissions;
+use imperazim\comman\Command;
+use imperazim\comman\SubCommand;
+use imperazim\command\argument\Argument;
+use imperazim\command\constraint\Constraint;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+
+/**
+* Builder class for creating dynamic commands programmatically
+*
+* Allows fluent configuration of command properties, arguments, subcommands, and callbacks
+*/
+class DynamicCommand extends Command {
+    
+    /**
+    * @var array Command configuration structure
+    *
+    * Structure:
+    * - 'name': string Command name
+    * - 'description': string Command description
+    * - 'aliases': string[] Command aliases
+    * - 'permission': string Required permission
+    * - 'constraints': Constraint[] Validation constraints
+    * - 'arguments': Argument[] Command arguments
+    * - 'subcommands': SubCommand[] Child subcommands
+    */
+    private array $config = [
+        'name' => '',
+        'description' => '',
+        'aliases' => [],
+        'permission' => DefaultPermissions::ROOT_USER,
+        'constraints' => [],
+        'arguments' => [],
+        'subcommands' => [],
+    ];
+
+    /** @var Closure|null Success execution callback */
+    private ?Closure $executeCallback = null;
+
+    /** @var Closure|null Failure handling callback */
+    private ?Closure $failureCallback = null;
+
+    /**
+    * Constructs a dynamic command
+    *
+    * @param Plugin $plugin Owning plugin instance
+    * @param string $name Command name
+    */
+    public function __construct(Plugin $plugin, string $name) {
+        $this->config['name'] = $name;
+        parent::__construct($plugin);
+    }
+
+    /**
+    * Factory method for command creation
+    *
+    * @param Plugin $plugin Owning plugin instance
+    * @param string $name Command name
+    * @return self New command instance
+    */
+    public static function create(Plugin $plugin, string $name): self {
+        return new self($plugin, $name);
+    }
+
+    /**
+    * Sets the command description
+    *
+    * @param string $description Command description
+    * @return $this
+    */
+    public function setDescription(string $description): self {
+        $this->config['description'] = $description;
+        return $this;
+    }
+
+    /**
+    * Sets command aliases
+    *
+    * @param string[] $aliases Alternative command names
+    * @return $this
+    */
+    public function setAliases(array $aliases): self {
+        $this->config['aliases'] = $aliases;
+        return $this;
+    }
+
+    /**
+    * Sets required permission
+    *
+    * @param string $permission Permission node
+    * @return $this
+    */
+    public function setPermission(string $permission): self {
+        $this->config['permission'] = $permission;
+        return $this;
+    }
+
+    /**
+    * Adds a validation constraint
+    *
+    * @param Constraint $constraint Constraint instance
+    * @return $this
+    */
+    public function addConstraint(Constraint $constraint): self {
+        $this->config['constraints'][] = $constraint;
+        return $this;
+    }
+
+    /**
+    * Adds a command argument
+    *
+    * @param Argument $argument Argument instance
+    * @return $this
+    */
+    public function addArgument(Argument $argument): self {
+        $this->config['arguments'][] = $argument;
+        return $this;
+    }
+
+    /**
+    * Adds a subcommand
+    *
+    * @param SubCommand $subCommand Subcommand instance
+    * @return $this
+    */
+    public function addSubCommand(SubCommand $subCommand): self {
+        $this->config['subcommands'][] = $subCommand;
+        return $this;
+    }
+
+    /**
+    * Sets the success execution handler
+    *
+    * @param Closure $callback Callback with signature `function(CommandResult $result): void`
+    * @return $this
+    */
+    public function setOnExecute(Closure $callback): self {
+        $this->executeCallback = $callback;
+        return $this;
+    }
+
+    /**
+    * Sets the failure handler
+    *
+    * @param Closure $callback Callback with signature `function(CommandFailure $failure): void`
+    * @return $this
+    */
+    public function setOnFailure(Closure $callback): self {
+        $this->failureCallback = $callback;
+        return $this;
+    }
+
+    /**
+    * Builds the final command configuration
+    *
+    * @return array Command configuration structure
+    */
+    public function onBuild(): array {
+        return $this->config;
+    }
+
+    /**
+    * Executes the command success handler
+    *
+    * @param CommandResult $result Command execution result
+    */
+    public function onExecute(CommandResult $result): void {
+        if ($this->executeCallback !== null) {
+            ($this->executeCallback)($result);
+        }
+    }
+
+    /**
+    * Executes the command failure handler
+    *
+    * @param CommandFailure $failure Command failure details
+    */
+    public function onFailure(CommandFailure $failure): void {
+        if ($this->failureCallback !== null) {
+            ($this->failureCallback)($failure);
+        }
+    }
+
+    /**
+    * Registers the command with PocketMine's command map
+    */
+    public function register(): void {
+        $cmdMap = $this->plugin->getServer()->getCommandMap();
+        $namespace = $this->plugin->getDescription()->getName();
+        $cmdMap->register($namespace, $this->plugin);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/dynamic/DynamicSubCommand.php b/src/imperazim/command/dynamic/DynamicSubCommand.php
new file mode 100644
index 0000000..0957fe4
--- /dev/null
+++ b/src/imperazim/command/dynamic/DynamicSubCommand.php
@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\dynamic;
+
+use Closure;
+use pocketmine\permission\DefaultPermissions;
+use imperazim\comman\Command;
+use imperazim\comman\SubCommand;
+use imperazim\command\argument\Argument;
+use imperazim\command\constraint\Constraint;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+
+/**
+* Builder class for creating dynamic subcommands programmatically
+*
+* Allows fluent configuration of subcommand properties, arguments, and callbacks
+*/
+class DynamicSubCommand extends SubCommand {
+    
+    /**
+    * @var array Subcommand configuration structure
+    *
+    * Structure:
+    * - 'name': string Subcommand name
+    * - 'description': string Subcommand description
+    * - 'aliases': string[] Subcommand aliases
+    * - 'permission': string Required permission
+    * - 'constraints': Constraint[] Validation constraints
+    * - 'arguments': Argument[] Subcommand arguments
+    * - 'subcommands': SubCommand[] Child subcommands
+    */
+    private array $config = [
+        'name' => '',
+        'description' => '',
+        'aliases' => [],
+        'permission' => DefaultPermissions::ROOT_USER,
+        'constraints' => [],
+        'arguments' => [],
+        'subcommands' => [],
+    ];
+
+    /** @var Closure|null Success execution callback */
+    private ?Closure $executeCallback = null;
+
+    /** @var Closure|null Failure handling callback */
+    private ?Closure $failureCallback = null;
+
+    /**
+    * Constructs a dynamic subcommand
+    *
+    * @param Command|SubCommand $parent Parent command or subcommand
+    * @param string $name Subcommand name
+    */
+    public function __construct(Command|SubCommand $parent, string $name) {
+        $this->config['name'] = $name;
+        parent::__construct($parent);
+    }
+
+    /**
+    * Factory method for subcommand creation
+    *
+    * @param Command|SubCommand $parent Parent command instance
+    * @param string $name Subcommand name
+    * @return self New subcommand instance
+    */
+    public static function create(Command|SubCommand $parent, string $name): self {
+        return new self($parent, $name);
+    }
+
+    /**
+    * Sets the subcommand description
+    *
+    * @param string $description Subcommand description
+    * @return $this
+    */
+    public function setDescription(string $description): self {
+        $this->config['description'] = $description;
+        return $this;
+    }
+
+    /**
+    * Sets subcommand aliases
+    *
+    * @param string[] $aliases Alternative subcommand names
+    * @return $this
+    */
+    public function setAliases(array $aliases): self {
+        $this->config['aliases'] = $aliases;
+        return $this;
+    }
+
+    /**
+    * Sets required permission
+    *
+    * @param string $permission Permission node
+    * @return $this
+    */
+    public function setPermission(string $permission): self {
+        $this->config['permission'] = $permission;
+        return $this;
+    }
+
+    /**
+    * Adds a validation constraint
+    *
+    * @param Constraint $constraint Constraint instance
+    * @return $this
+    */
+    public function addConstraint(Constraint $constraint): self {
+        $this->config['constraints'][] = $constraint;
+        return $this;
+    }
+
+    /**
+    * Adds a subcommand argument
+    *
+    * @param Argument $argument Argument instance
+    * @return $this
+    */
+    public function addArgument(Argument $argument): self {
+        $this->config['arguments'][] = $argument;
+        return $this;
+    }
+
+    /**
+    * Adds a child subcommand
+    *
+    * @param SubCommand $subCommand Subcommand instance
+    * @return $this
+    */
+    public function addSubCommand(SubCommand $subCommand): self {
+        $this->config['subcommands'][] = $subCommand;
+        return $this;
+    }
+
+    /**
+    * Sets the success execution handler
+    *
+    * @param Closure $callback Callback with signature `function(CommandResult $result): void`
+    * @return $this
+    */
+    public function setOnExecute(Closure $callback): self {
+        $this->executeCallback = $callback;
+        return $this;
+    }
+
+    /**
+    * Sets the failure handler
+    *
+    * @param Closure $callback Callback with signature `function(CommandFailure $failure): void`
+    * @return $this
+    */
+    public function setOnFailure(Closure $callback): self {
+        $this->failureCallback = $callback;
+        return $this;
+    }
+
+    /**
+    * Builds the final subcommand configuration
+    *
+    * @return array Subcommand configuration structure
+    */
+    public function onBuild(): array {
+        return $this->config;
+    }
+
+    /**
+    * Executes the subcommand success handler
+    *
+    * @param CommandResult $result Command execution result
+    */
+    public function onExecute(CommandResult $result): void {
+        if ($this->executeCallback !== null) {
+            ($this->executeCallback)($result);
+        }
+    }
+
+    /**
+    * Executes the subcommand failure handler
+    *
+    * @param CommandFailure $failure Command failure details
+    */
+    public function onFailure(CommandFailure $failure): void {
+        if ($this->failureCallback !== null) {
+            ($this->failureCallback)($failure);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/enum/CommandEnumManager.php b/src/imperazim/command/enum/CommandEnumManager.php
new file mode 100644
index 0000000..0f0d7ba
--- /dev/null
+++ b/src/imperazim/command/enum/CommandEnumManager.php
@@ -0,0 +1,116 @@
+<?php
+
+namespace imperazim\command\enum;
+
+use pocketmine\Server;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
+use pocketmine\network\mcpe\protocol\ClientboundPacket;
+use pocketmine\network\mcpe\protocol\UpdateSoftEnumPacket;
+use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
+
+/**
+* Manages soft command enums for dynamic command suggestions
+*
+* Handles registration, updating, and synchronization of enums across players
+*/
+class CommandEnumManager {
+    
+    /**
+    * @var CommandEnum[] Registered soft enums indexed by name
+    */
+    private static array $enums = [];
+
+    /**
+    * Retrieves a soft enum by its name
+    *
+    * @param string $name Enum identifier
+    * @return CommandEnum|null Enum instance or null if not found
+    */
+    public static function getEnumByName(string $name): ?CommandEnum {
+        return self::$enums[$name] ?? null;
+    }
+
+    /**
+    * Gets all registered soft enums
+    *
+    * @return CommandEnum[] Array of enum instances
+    */
+    public static function getEnums(): array {
+        return self::$enums;
+    }
+
+    /**
+    * Registers a new soft enum
+    *
+    * @param CommandEnum $enum Enum instance to register
+    * @throws CommandException If enum with same name already exists
+    */
+    public static function addEnum(CommandEnum $enum): void {
+        $name = $enum->getName();
+
+        if (isset(self::$enums[$name])) {
+            throw new CommandException("Soft enum '{$name}' already exists");
+        }
+
+        self::$enums[$name] = $enum;
+        self::broadcastUpdate($enum, UpdateSoftEnumPacket::TYPE_ADD);
+    }
+
+    /**
+    * Updates an existing soft enum with new values
+    *
+    * @param string $enumName Name of enum to update
+    * @param string[] $values New enum values
+    * @throws CommandException If specified enum doesn't exist
+    */
+    public static function updateEnum(string $enumName, array $values): void {
+        if (!isset(self::$enums[$enumName])) {
+            throw new CommandException("Unknown enum '{$enumName}'");
+        }
+
+        $enum = new CommandEnum($enumName, $values);
+        self::$enums[$enumName] = $enum;
+        self::broadcastUpdate($enum, UpdateSoftEnumPacket::TYPE_SET);
+    }
+
+    /**
+    * Removes a soft enum
+    *
+    * @param string $enumName Name of enum to remove
+    * @throws CommandException If specified enum doesn't exist
+    */
+    public static function removeEnum(string $enumName): void {
+        if (!isset(self::$enums[$enumName])) {
+            throw new CommandException("Unknown enum '{$enumName}'");
+        }
+
+        $enum = self::$enums[$enumName];
+        unset(self::$enums[$enumName]);
+        self::broadcastUpdate($enum, UpdateSoftEnumPacket::TYPE_REMOVE);
+    }
+
+    /**
+    * Broadcasts enum changes to all online players
+    *
+    * @param CommandEnum $enum Enum instance to broadcast
+    * @param int $updateType Update type (add/set/remove)
+    */
+    private static function broadcastUpdate(CommandEnum $enum, int $updateType): void {
+        $packet = new UpdateSoftEnumPacket();
+        $packet->enumName = $enum->getName();
+        $packet->values = $enum->getValues();
+        $packet->type = $updateType;
+
+        self::broadcastToPlayers($packet);
+    }
+
+    /**
+    * Broadcasts a packet to all online players
+    *
+    * @param ClientboundPacket $packet Packet to broadcast
+    */
+    private static function broadcastToPlayers(ClientboundPacket $packet): void {
+        $players = Server::getInstance()->getOnlinePlayers();
+        NetworkBroadcastUtils::broadcastPackets($players, [$packet]);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/exception/ArgumentException.php b/src/imperazim/command/exception/ArgumentException.php
new file mode 100644
index 0000000..78b0f04
--- /dev/null
+++ b/src/imperazim/command/exception/ArgumentException.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\exception;
+
+/**
+* Exception thrown for argument-related errors in command processing
+*
+* This exception type is typically thrown when:
+* - Argument parsing fails
+* - Invalid argument values are detected
+* - Argument validation constraints are violated
+*
+* @package imperazim\command\exception
+*/
+class ArgumentException extends \RuntimeException {}
\ No newline at end of file
diff --git a/src/imperazim/command/exception/ConstraintException.php b/src/imperazim/command/exception/ConstraintException.php
new file mode 100644
index 0000000..d25d97f
--- /dev/null
+++ b/src/imperazim/command/exception/ConstraintException.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\exception;
+
+/**
+* Exception thrown when command constraints are not satisfied
+*
+* This exception is typically thrown when:
+* - Permission checks fail
+* - Execution environment requirements aren't met
+* - Custom constraint validations fail
+*
+* @package imperazim\command\exception
+*/
+class ConstraintException extends \RuntimeException {}
\ No newline at end of file
diff --git a/src/imperazim/command/result/CommandFailure.php b/src/imperazim/command/result/CommandFailure.php
new file mode 100644
index 0000000..1a30bb0
--- /dev/null
+++ b/src/imperazim/command/result/CommandFailure.php
@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\result;
+
+use pocketmine\command\CommandSender;
+use imperazim\command\constraint\Constraint;
+use imperazim\command\argument\Argument;
+
+/**
+* Represents a command execution failure with detailed error information
+*
+* Contains failure reason, contextual data, and formatted messages
+*/
+final class CommandFailure {
+
+    /** Failure type: Invalid argument provided */
+    public const INVALID_ARGUMENT = 0;
+
+    /** Failure type: Required argument missing */
+    public const MISSING_ARGUMENT = 1;
+
+    /** Failure type: Constraint check failed */
+    public const CONSTRAINT_FAILED = 2;
+
+    /** Failure type: Runtime execution error */
+    public const EXECUTION_ERROR = 3;
+
+    /**
+    * @var int[] Valid failure type identifiers
+    */
+    public const ERROR_TYPES = [
+        self::INVALID_ARGUMENT,
+        self::MISSING_ARGUMENT,
+        self::CONSTRAINT_FAILED,
+        self::EXECUTION_ERROR
+    ];
+
+    /**
+    * Constructs a command failure result
+    *
+    * @param CommandSender $sender Command executor
+    * @param int $reasonId Failure type identifier (use class constants)
+    * @param array $data Contextual error data (structure depends on failure type)
+    *
+    * @throws \InvalidArgumentException When invalid reason ID is provided
+    */
+    public function __construct(
+        private CommandSender $sender,
+        private int $reasonId,
+        private array $data = []
+    ) {
+        if (!in_array($reasonId, self::ERROR_TYPES, true)) {
+            throw new \InvalidArgumentException("Invalid failure reason ID: $reasonId");
+        }
+    }
+
+    /**
+    * Gets the command sender that triggered the failure
+    *
+    * @return CommandSender Command executor
+    */
+    public function getSender(): CommandSender {
+        return $this->sender;
+    }
+
+    /**
+    * Gets the failure reason identifier
+    *
+    * @return int One of the class failure constants
+    */
+    public function getReason(): int {
+        return $this->reasonId;
+    }
+
+    /**
+    * Gets the failure reason as a human-readable name
+    *
+    * @return string Failure type name
+    */
+    public function getReasonName(): string {
+        return match($this->reasonId) {
+            self::INVALID_ARGUMENT => 'INVALID_ARGUMENT',
+            self::MISSING_ARGUMENT => 'MISSING_ARGUMENT',
+            self::CONSTRAINT_FAILED => 'CONSTRAINT_FAILED',
+            self::EXECUTION_ERROR => 'EXECUTION_ERROR',
+            default => 'UNKNOWN_ERROR'
+            };
+        }
+
+        /**
+        * Gets contextual failure data
+        *
+        * Structure varies by failure type:
+        * - INVALID_ARGUMENT: May contain 'argument_errors'
+        * - MISSING_ARGUMENT: May contain 'missing_arguments'
+        * - CONSTRAINT_FAILED: May contain 'failed_constraints'
+        * - EXECUTION_ERROR: May contain exception or error details
+        *
+        * @return array Failure-specific contextual data
+        */
+        public function getData(): array {
+            return $this->data;
+        }
+
+        /**
+        * Gets failed constraints (for CONSTRAINT_FAILED errors)
+        *
+        * @return Constraint[] Array of failed constraint objects
+        */
+        public function getFailedConstraints(): array {
+            return $this->data['failed_constraints'] ?? [];
+        }
+
+        /**
+        * Gets the failure message
+        *
+        * Returns custom message if provided in data, otherwise default message
+        *
+        * @return string Human-readable error message
+        */
+        public function getMessage(): string {
+            return $this->data['message'] ?? $this->getDefaultMessage();
+        }
+
+        /**
+        * Generates a default message based on failure type
+        *
+        * @return string Default error message for the failure type
+        */
+        private function getDefaultMessage(): string {
+            return match($this->reasonId) {
+                self::INVALID_ARGUMENT => 'Invalid argument provided',
+                self::MISSING_ARGUMENT => 'Missing required arguments',
+                self::CONSTRAINT_FAILED => 'Command constraints not satisfied',
+                self::EXECUTION_ERROR => 'An error occurred during command execution',
+            default => 'Unknown command error'
+            };
+        }
+    }
\ No newline at end of file
diff --git a/src/imperazim/command/result/CommandResult.php b/src/imperazim/command/result/CommandResult.php
new file mode 100644
index 0000000..812e3f2
--- /dev/null
+++ b/src/imperazim/command/result/CommandResult.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\result;
+
+use pocketmine\command\CommandSender;
+use imperazim\command\CommandArguments;
+
+/**
+* Represents a successful command execution result
+*
+* Contains execution context including sender, arguments, and command label
+*/
+final class CommandResult {
+    
+    /**
+    * Constructs a command result
+    *
+    * @param CommandSender $sender Command executor
+    * @param CommandArguments $arguments Parsed command arguments
+    * @param string $label Actual command label used
+    */
+    public function __construct(
+        private CommandSender $sender,
+        private CommandArguments $arguments,
+        private string $label
+    ) {}
+
+    /**
+    * Gets the command sender that executed the command
+    *
+    * @return CommandSender Command executor
+    */
+    public function getSender(): CommandSender {
+        return $this->sender;
+    }
+
+    /**
+    * Gets the parsed command arguments
+    *
+    * @return CommandArguments Structured argument container
+    */
+    public function getArgumentsList(): CommandArguments {
+        return $this->arguments;
+    }
+
+    /**
+    * Gets the actual command label used
+    *
+    * @return string Command label (e.g., "help" in "/help")
+    */
+    public function getLabel(): string {
+        return $this->label;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/traits/ArgumentableTrait.php b/src/imperazim/command/traits/ArgumentableTrait.php
new file mode 100644
index 0000000..481af6e
--- /dev/null
+++ b/src/imperazim/command/traits/ArgumentableTrait.php
@@ -0,0 +1,233 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\traits;
+
+use imperazim\command\CommandArguments;
+use imperazim\command\argument\Argument;
+use imperazim\command\argument\StringArgument;
+use imperazim\command\result\CommandFailure;
+use pocketmine\command\CommandSender;
+
+trait ArgumentableTrait {
+    
+    /**
+    * @var Argument[] Array of command arguments
+    */
+    private array $arguments = [];
+
+    /**
+    * Adds an argument to the command
+    *
+    * @param Argument $argument Argument instance to add
+    * @return $this
+    */
+    public function addArgument(Argument $argument): self {
+        $this->arguments[] = $argument;
+        return $this;
+    }
+
+    /**
+    * Gets all registered arguments
+    *
+    * @return Argument[]
+    */
+    public function getArguments(): array {
+        return $this->arguments;
+    }
+
+    /**
+    * Retrieves an argument by its name
+    *
+    * @param string $name Name of the argument to find
+    * @return Argument|null Argument instance or null if not found
+    */
+    public function getArgument(string $name): ?Argument {
+        foreach ($this->arguments as $argument) {
+            if ($argument->getName() === $name) {
+                return $argument;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * Builds the command usage string from configuration
+    *
+    * @param array $config Command configuration array
+    * @return string Formatted usage string
+    */
+    private function buildUsage(array $config): string {
+        $parts = ['/' . ($config['name'] ?? 'command')];
+
+        foreach ($config['arguments'] ?? [] as $argument) {
+            $parts[] = $argument->getUsageFormatted();
+        }
+
+        return implode(' ', $parts);
+    }
+
+    /**
+    * Parses raw command arguments according to defined argument types
+    *
+    * Handles special cases like StringArgument consuming multiple tokens
+    *
+    * @param string[] $rawArgs Raw arguments from command input
+    * @return array Processed arguments with correct grouping
+    */
+    private function parseRawArgs(array $rawArgs): array {
+        $processed = [];
+        $argDefs = $this->arguments;
+        $rawCount = count($rawArgs);
+        $argCount = count($argDefs);
+        $i = 0;
+        $j = 0;
+
+        while ($i < $argCount && $j < $rawCount) {
+            $argDef = $argDefs[$i];
+            $remainingRaw = $rawCount - $j;
+            $remainingArgs = $argCount - $i;
+
+            if ($argDef instanceof StringArgument && $remainingRaw > $remainingArgs) {
+                $toConsume = $remainingRaw - ($remainingArgs - 1);
+                $value = implode(' ', array_slice($rawArgs, $j, $toConsume));
+                $processed[] = $value;
+                $j += $toConsume;
+                $i++;
+                continue;
+            }
+
+            $processed[] = $rawArgs[$j];
+            $j++;
+            $i++;
+        }
+
+        return $processed;
+    }
+
+    /**
+    * Validates command arguments against defined requirements
+    *
+    * @param CommandSender $sender Command executor
+    * @param string[] $rawArgs Raw arguments from command input
+    * @return array Validation result with status and potential errors
+    */
+    private function validateArguments(CommandSender $sender, array $rawArgs): array {
+        $providedCount = count($rawArgs);
+        $requiredCount = count($this->getRequiredArguments());
+
+        if ($providedCount < $requiredCount) {
+            return $this->getMissingArgsErr($requiredCount, $providedCount);
+        }
+
+        if ($providedCount > count($this->arguments)) {
+            return $this->getExcessArgsErr();
+        }
+
+        return $this->validateArgumentTypes($sender, $rawArgs);
+    }
+
+    /**
+    * Gets all required (non-optional) arguments
+    *
+    * @return Argument[] Required arguments
+    */
+    private function getRequiredArguments(): array {
+        $arguments = [];
+        foreach ($this->arguments as $argument) {
+            if (!$argument->isOptional()) {
+                $arguments[] = $argument;
+            }
+        }
+        return $arguments;
+    }
+
+    /**
+    * Generates missing arguments error structure
+    *
+    * @param int $required Number of required arguments
+    * @param int $provided Number of provided arguments
+    * @return array Error details including missing argument names
+    */
+    private function getMissingArgsErr(int $required, int $provided): array {
+        $missing = [];
+        for ($i = $provided; $i < $required; $i++) {
+            $missing[] = $this->arguments[$i]->getName();
+        }
+        return [
+            'valid' => false,
+            'type' => CommandFailure::MISSING_ARGUMENT,
+            'message' => 'Missing required arguments: ' . implode(', ', $missing),
+            'missing_arguments' => $missing
+        ];
+    }
+
+    /**
+    * Generates excess arguments error structure
+    *
+    * @return array Error details including maximum allowed arguments
+    */
+    private function getExcessArgsErr(): array {
+        return [
+            'valid' => false,
+            'type' => CommandFailure::INVALID_ARGUMENT,
+            'message' => 'Too many arguments (max: ' . count($this->arguments) . ')',
+            'max_arguments' => count($this->arguments)
+        ];
+    }
+
+    /**
+    * Validates argument values against their defined types
+    *
+    * @param CommandSender $sender Command executor
+    * @param string[] $rawArgs Processed raw arguments
+    * @return array Validation result with potential argument errors
+    */
+    private function validateArgumentTypes(CommandSender $sender, array $rawArgs): array {
+        $errors = [];
+
+        foreach ($rawArgs as $index => $value) {
+            if (!isset($this->arguments[$index])) continue;
+            $argument = $this->arguments[$index];
+
+            if (!$argument->canParse($value, $sender)) {
+                $errors[] = [
+                    'argument' => $argument->getName(),
+                    'value' => $value,
+                    'message' => "Invalid value for argument '{$argument->getName()}'"
+                ];
+            }
+        }
+
+        if (!empty($errors)) {
+            return [
+                'valid' => false,
+                'type' => CommandFailure::INVALID_ARGUMENT,
+                'message' => 'Invalid arguments provided',
+                'argument_errors' => $errors
+            ];
+        }
+
+        return ['valid' => true];
+    }
+
+    /**
+    * Parses and packages arguments into a CommandArguments object
+    *
+    * @param CommandSender $sender Command executor
+    * @param string[] $rawArgs Raw arguments from command input
+    * @return CommandArguments Structured argument container
+    */
+    private function parseArguments(CommandSender $sender, array $rawArgs): CommandArguments {
+        $processedArgs = $this->parseRawArgs($rawArgs);
+
+        $parsed = [];
+        foreach ($this->arguments as $index => $argDef) {
+            $rawValue = $processedArgs[$index] ?? null;
+            $parsed[$argDef->getName()] = $rawValue === null ? null : $argDef->parse($rawValue, $sender);
+        }
+
+        return new CommandArguments($sender, $parsed);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/traits/ConstraintableTrait.php b/src/imperazim/command/traits/ConstraintableTrait.php
new file mode 100644
index 0000000..ecbbb8b
--- /dev/null
+++ b/src/imperazim/command/traits/ConstraintableTrait.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\traits;
+
+use pocketmine\command\CommandSender;
+use imperazim\command\constraint\Constraint;
+
+/**
+* Provides constraint management functionality for commands and subcommands.
+* Allows adding constraints, retrieving them, and testing against a command sender.
+*/
+trait ConstraintableTrait {
+    
+    /** @var Constraint[] Constraints applied to the command */
+    private array $constraints = [];
+
+    /**
+    * Adds a constraint to the command.
+    *
+    * @param Constraint $constraint The constraint to add
+    * @return self Returns the instance for method chaining
+    */
+    public function addConstraint(Constraint $constraint): self {
+        $this->constraints[] = $constraint;
+        return $this;
+    }
+
+    /**
+    * Gets all constraints applied to the command.
+    *
+    * @return Constraint[] Array of constraints
+    */
+    public function getConstraints(): array {
+        return $this->constraints;
+    }
+
+    /**
+    * Gets constraints of a specific type.
+    *
+    * @param string $type The class name of the constraint type
+    * @return Constraint[] Constraints of the specified type
+    */
+    public function getConstraintsByType(string $type): array {
+        return array_filter($this->constraints, fn($c) => $c instanceof $type);
+    }
+
+    /**
+    * Tests all constraints against a command sender.
+    *
+    * @param CommandSender $sender The command sender to test
+    * @return array Test results with keys:
+    *               - 'success': Whether all constraints were satisfied
+    *               - 'failed_constraints': Array of failed constraints
+    */
+    private function testConstraints(CommandSender $sender): array {
+        $failed = [];
+
+        foreach ($this->constraints as $constraint) {
+            if (!$constraint->isSatisfiedBy($sender)) {
+                $constraint->onFailure($sender);
+                $failed[] = $constraint;
+            } else {
+                $constraint->onSuccess($sender);
+            }
+        }
+
+        return [
+            'success' => empty($failed),
+            'failed_constraints' => $failed
+        ];
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/command/traits/SubCommandTrait.php b/src/imperazim/command/traits/SubCommandTrait.php
new file mode 100644
index 0000000..bbf996c
--- /dev/null
+++ b/src/imperazim/command/traits/SubCommandTrait.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\command\traits;
+
+use imperazim\command\SubCommand;
+
+trait SubCommandTrait {
+
+    /**
+    * @var SubCommand[] Array of registered subcommands
+    */
+    private array $subcommands = [];
+
+    /**
+    * Registers a new subcommand
+    *
+    * @param SubCommand $subcommand The subcommand instance to register
+    * @return $this
+    */
+    public function addSubCommand(SubCommand $subcommand): self {
+        $this->subcommands[] = $subcommand;
+        return $this;
+    }
+
+    /**
+    * Gets all registered subcommands
+    *
+    * @return SubCommand[] Array of subcommand instances
+    */
+    public function getSubCommands(): array {
+        return $this->subcommands;
+    }
+
+    /**
+    * Retrieves a subcommand by its name
+    *
+    * @param string $name Name of the subcommand to search for
+    * @return SubCommand|null Subcommand instance if found, null otherwise
+    */
+    public function getSubCommand(string $name): ?SubCommand {
+        foreach ($this->subcommands as $subcommand) {
+            if ($subcommand->getName() === $name) {
+                return $subcommand;
+            }
+        }
+        return null;
+    }
+
+}
\ No newline at end of file
diff --git a/src/imperazim/components/command/Command.php b/src/imperazim/components/command/Command.php
deleted file mode 100644
index d849c53..0000000
--- a/src/imperazim/components/command/Command.php
+++ /dev/null
@@ -1,78 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command;
-
-use imperazim\vendor\commando\BaseCommand;
-use imperazim\vendor\commando\BaseSubCommand;
-use imperazim\components\plugin\PluginToolkit;
-use imperazim\components\command\subcommmand\Subcommand;
-
-/**
-* Class Command
-* @package imperazim\components\command
-*/
-abstract class Command extends BaseCommand {
-
-  /** @var CommandBuilder|null */
-  private $build = null;
-
-  /**
-  * Command constructor.
-  */
-  public function __construct(PluginToolkit $plugin) {
-    $this->build = $this->build($plugin);
-    parent::__construct(
-      plugin: $plugin,
-      names: $this->build->getNames(),
-      description: $this->build->getDescription()
-    );
-  }
-
-  /**
-  * Set up the command.
-  * @return CommandBuilder
-  */
-  protected abstract function build(PluginToolkit $plugin): CommandBuilder;
-
-  /**
-  * Executes the command logic when triggered.
-  * @param PluginToolkit $plugin The plugin toolkit instance.
-  * @param mixed $sender The sender of the command (could be a player, console, etc.).
-  * @param string $aliasUsed The alias of the command that was used.
-  * @param array $args The arguments passed with the command.
-  */
-  protected abstract function run(PluginToolkit $plugin, mixed $sender, string $aliasUsed, array $args): void;
-
-  /**
-  * Prepares the command for execution.
-  */
-  protected function prepare(): void {
-    if ($this->build instanceof CommandBuilder) {
-      $builder = $this->build;
-      if ($builder->getPermission()) {
-        $this->setPermission($builder->getPermission());
-      }
-      $this->registerArguments($builder->getArguments());
-      $this->addConstraints($builder->getConstraints());
-      if ($builder->getSubcommands()) {
-        $subcommands = [];
-        foreach ($builder->getSubcommands() as $subcommand) {
-          $subcommands[] = new $subcommand($this->getOwningPlugin());
-        }
-        $this->registerSubcommands($subcommands);
-      }
-    }
-  }
-
-  /**
-  * Executes the command.
-  * @param mixed $sender
-  * @param string $aliasUsed
-  * @param array $args
-  */
-  public function onRun(mixed $sender, string $aliasUsed, array $args): void {
-    $this->run($this->getOwningPlugin(), $sender, $aliasUsed, $args);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/CommandBuilder.php b/src/imperazim/components/command/CommandBuilder.php
deleted file mode 100644
index 190d8cd..0000000
--- a/src/imperazim/components/command/CommandBuilder.php
+++ /dev/null
@@ -1,80 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command;
-
-/**
-* Class CommandBuilder
-* @package imperazim\components\command
-*/
-final class CommandBuilder {
-
-  /**
-  * CommandBuilder constructor.
-  *
-  * @param array $commandData The array containing command configuration.
-  */
-  public function __construct(
-    private array $names = [],
-    private string $description = '',
-    private array $subcommands = [],
-    private ?string $permission = null,
-    private array $arguments = [],
-    private array $constraints = []
-  ) {}
-
-  /**
-  * Get command names.
-  *
-  * @return array
-  */
-  public function getNames(): array {
-    return $this->names;
-  }
-
-  /**
-  * Get command description.
-  *
-  * @return string
-  */
-  public function getDescription(): string {
-    return $this->description;
-  }
-
-  /**
-  * Get subcommands directory.
-  *
-  * @return array
-  */
-  public function getSubcommands(): array {
-    return $this->subcommands;
-  }
-
-  /**
-  * Get command permission.
-  *
-  * @return string|null
-  */
-  public function getPermission(): ?string {
-    return $this->permission;
-  }
-
-  /**
-  * Get command arguments.
-  *
-  * @return array
-  */
-  public function getArguments(): array {
-    return $this->arguments;
-  }
-
-  /**
-  * Get command constraints.
-  *
-  * @return array
-  */
-  public function getConstraints(): array {
-    return $this->constraints;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/CommandManager.php b/src/imperazim/components/command/CommandManager.php
deleted file mode 100644
index 55aa1a8..0000000
--- a/src/imperazim/components/command/CommandManager.php
+++ /dev/null
@@ -1,34 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command;
-
-use imperazim\components\plugin\PluginToolkit;
-use imperazim\components\plugin\PluginComponent;
-use imperazim\components\plugin\traits\PluginComponentsTrait;
-
-use imperazim\components\command\defaults\VersionCommand;
-use imperazim\components\command\defaults\GeneratePluginCommand;
-
-/**
-* Class CommandManager
-* @package imperazim\components\command
-*/
-final class CommandManager extends PluginComponent {
-  use PluginComponentsTrait;
-
-  /**
-  * Initializes the command component.
-  * @param PluginToolkit $plugin The Plugin.
-  */
-  public static function init(PluginToolkit $plugin): array {
-    self::setPlugin(plugin: $plugin);
-    $plugin->overwriteCommands($plugin, [
-      'version' => VersionCommand::class,
-      'genplugin' => GeneratePluginCommand::class,
-    ]);
-    return [];
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/defaults/GeneratePluginCommand.php b/src/imperazim/components/command/defaults/GeneratePluginCommand.php
deleted file mode 100644
index 32dab02..0000000
--- a/src/imperazim/components/command/defaults/GeneratePluginCommand.php
+++ /dev/null
@@ -1,97 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command\defaults;
-
-use imperazim\components\command\Command;
-use imperazim\components\command\CommandBuilder;
-use imperazim\components\plugin\PluginToolkit;
-
-use imperazim\vendor\commando\args\RawStringArgument;
-
-/**
-* Class GeneratePluginCommand
-* @package imperazim\components\command\defaults
-*/
-final class GeneratePluginCommand extends Command {
-
-  /**
-  * Builds the command with the given parameters.
-  * @param PluginToolkit $plugin The plugin toolkit instance used to register the command.
-  * @return CommandBuilder
-  */
-  public function build(PluginToolkit $plugin): CommandBuilder {
-    return new CommandBuilder(
-      names: ['genplugin'],
-      description: 'Generate a new plugin base with EasyLibrary.',
-      permission: 'easylibrary.command.genplugin',
-      arguments: [
-        0 => new RawStringArgument('PluginName', true),
-        1 => new RawStringArgument('PluginVersion', true),
-        2 => new RawStringArgument('PluginApiVersion', true),
-        3 => new RawStringArgument('PluginAuthor', true),
-        4 => new RawStringArgument('AuthorInDir_Y/N', true)
-      ]
-    );
-  }
-
-  /**
-  * Executes the command.
-  * @param PluginToolkit $plugin
-  * @param mixed $sender
-  * @param string $aliasUsed
-  * @param array $args
-  */
-  public function run(PluginToolkit $plugin, mixed $sender, string $aliasUsed, array $args): void {
-    $pluginName = $args['PluginName'] ?? "Plugin";
-    $pluginVersion = $args['PluginVersion'] ?? "1.0.0";
-    $pluginApiVersion = $args['PluginApiVersion'] ?? "5.0.0";
-    $pluginAuthor = $args['PluginAuthor'] ?? "Unknown";
-    $authorInDir = strtolower($args['AuthorInDir_Y/N'] ?? "n") === "y" ? "y" : "n";
-    $useEasyLibrary = "y";
-
-    $currentDir = $plugin->getServer()->getDataPath() . "plugins";
-    $dirPath = $currentDir . "/" . $pluginName;
-
-    if (is_dir($dirPath)) {
-      $sender->sendMessage("§cError: The directory '$pluginName' already exists.");
-      return;
-    }
-
-    mkdir($dirPath, 0777, true);
-
-    $pluginNamespace = ($authorInDir === "y") ? "$pluginAuthor\\$pluginName" : $pluginName;
-
-    $pluginYmlContent = "name: $pluginName\nversion: $pluginVersion\napi: $pluginApiVersion\nmain: $pluginNamespace\n";
-    if ($pluginAuthor !== "Unknown") {
-      $pluginYmlContent .= "author: $pluginAuthor\n";
-    }
-    $pluginYmlContent .= "depend:\n  - EasyLibrary\n";
-
-    file_put_contents($dirPath . "/plugin.yml", $pluginYmlContent);
-
-    $srcDir = ($authorInDir === "y") ? "$dirPath/src/$pluginAuthor" : "$dirPath/src";
-    mkdir($srcDir, 0777, true);
-
-    $classContent = "<?php\n\ndeclare(strict_types=1);\n\n";
-    if ($authorInDir === "y") {
-      $classContent .= "namespace $pluginAuthor;\n\n";
-    }
-
-    $classContent .= "use imperazim\\components\\plugin\\PluginToolkit;\nuse imperazim\\components\\plugin\\traits\\PluginToolkitTrait;\n\n";
-    $classContent .= "class $pluginName extends PluginToolkit {\n";
-    $classContent .= "    use PluginToolkitTrait;\n\n";
-    $classContent .= "    protected function onEnable(): void {\n";
-    $classContent .= "        \$this->saveRecursiveResources();\n";
-    $classContent .= "        \$this->getLogger()->info(\"$pluginName with EasyLibrary enabled!\");\n";
-    $classContent .= "    }\n";
-    $classContent .= "}\n";
-
-    file_put_contents("$srcDir/$pluginName.php", $classContent);
-
-    $sender->sendMessage("§aPlugin $pluginName successfully created!");
-
-    return;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/defaults/VersionCommand.php b/src/imperazim/components/command/defaults/VersionCommand.php
deleted file mode 100644
index 3321a3f..0000000
--- a/src/imperazim/components/command/defaults/VersionCommand.php
+++ /dev/null
@@ -1,130 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command\defaults;
-
-use pocketmine\lang\KnownTranslationFactory;
-use pocketmine\network\mcpe\protocol\ProtocolInfo;
-use pocketmine\permission\DefaultPermissionNames;
-use pocketmine\plugin\Plugin;
-use pocketmine\utils\TextFormat;
-use pocketmine\utils\Utils;
-use pocketmine\VersionInfo;
-use function count;
-use function implode;
-use function sprintf;
-use function stripos;
-use function strtolower;
-use const PHP_VERSION;
-
-use imperazim\components\command\Command;
-use imperazim\components\command\CommandBuilder;
-use imperazim\components\plugin\PluginToolkit;
-
-
-/**
-* Class VersionCommand
-* @package imperazim\components\command\defaults
-*/
-final class VersionCommand extends Command {
-
-  /**
-  * Builds the command with the given parameters.
-  * @param PluginToolkit $plugin The plugin toolkit instance used to register the command.
-  * @return CommandBuilder
-  */
-  public function build(PluginToolkit $plugin): CommandBuilder {
-    return new CommandBuilder(
-      names: ['version', 'ver', 'about'],
-      description: 'See data about the server.',
-      permission: DefaultPermissionNames::COMMAND_VERSION
-    );
-  }
-
-  /**
-  * Executes the command.
-  * @param PluginToolkit $plugin
-  * @param mixed $sender
-  * @param string $aliasUsed
-  * @param array $args
-  */
-  public function run(PluginToolkit $plugin, mixed $sender, string $aliasUsed, array $args): void {
-    try {
-      if (count($args) === 0) {
-        $sender->sendMessage(TextFormat::BOLD . TextFormat::GOLD . "===== SERVER INFORMATION =====");
-        $sender->sendMessage(TextFormat::YELLOW . "Server Software: " . TextFormat::GREEN . VersionInfo::NAME);
-        $sender->sendMessage(TextFormat::YELLOW . "Library: " . TextFormat::GREEN . $plugin->getName() . TextFormat::GRAY . " (v" . $plugin->getDescription()->getVersion() . ")");
-        $sender->sendMessage(TextFormat::YELLOW . "Enabled Components: " . TextFormat::GREEN . count($plugin->componentsManager->enabledComponents));
-        $sender->sendMessage(TextFormat::YELLOW . "Third-party Components: " . TextFormat::GREEN . count(\LibraryComponents::$customComponents));
-
-        $versionColor = VersionInfo::IS_DEVELOPMENT_BUILD ? TextFormat::RED : TextFormat::GREEN;
-        $sender->sendMessage(TextFormat::YELLOW . "Server Version: " . $versionColor . VersionInfo::VERSION()->getFullVersion());
-        $sender->sendMessage(TextFormat::YELLOW . "Git Hash: " . TextFormat::AQUA . VersionInfo::GIT_HASH());
-
-        $sender->sendMessage(TextFormat::YELLOW . "Minecraft Version: " . TextFormat::GREEN . ProtocolInfo::MINECRAFT_VERSION_NETWORK);
-        $sender->sendMessage(TextFormat::YELLOW . "Network Protocol: " . TextFormat::GREEN . ProtocolInfo::CURRENT_PROTOCOL);
-        $sender->sendMessage(TextFormat::YELLOW . "PHP Version: " . TextFormat::GREEN . PHP_VERSION);
-
-        $jitMode = Utils::getOpcacheJitMode();
-        if ($jitMode !== null) {
-          $jitStatus = $jitMode !== 0
-          ? "Enabled (Mode: " . $jitMode . ")"
-          : "Disabled";
-        } else {
-          $jitStatus = "Not Supported";
-        }
-        $sender->sendMessage(TextFormat::YELLOW . "PHP JIT: " . TextFormat::GREEN . $jitStatus);
-
-        $sender->sendMessage(TextFormat::YELLOW . "Operating System: " . TextFormat::GREEN . Utils::getOS());
-        $sender->sendMessage(TextFormat::BOLD . TextFormat::GOLD . "===============================");
-      } else {
-        $pluginName = implode(" ", $args);
-        $exactPlugin = $sender->getServer()->getPluginManager()->getPlugin($pluginName);
-
-        if ($exactPlugin instanceof Plugin) {
-          $this->describeToSender($exactPlugin, $sender);
-
-          return;
-        }
-
-        $found = false;
-        $pluginName = strtolower($pluginName);
-        foreach ($sender->getServer()->getPluginManager()->getPlugins() as $plugin) {
-          if (stripos($plugin->getName(), $pluginName) !== false) {
-            $this->describeToSender($plugin, $sender);
-            $found = true;
-          }
-        }
-
-        if (!$found) {
-          $sender->sendMessage(KnownTranslationFactory::pocketmine_command_version_noSuchPlugin());
-        }
-      }
-    } catch (\Throwable $e) {
-      new \crashdump($e);
-    }
-  }
-
-  private function describeToSender(Plugin $plugin, mixed $sender) : void {
-    $desc = $plugin->getDescription();
-    $sender->sendMessage(TextFormat::DARK_GREEN . $desc->getName() . TextFormat::RESET . " version " . TextFormat::DARK_GREEN . $desc->getVersion());
-
-    if ($desc->getDescription() !== "") {
-      $sender->sendMessage($desc->getDescription());
-    }
-
-    if ($desc->getWebsite() !== "") {
-      $sender->sendMessage("Website: " . $desc->getWebsite());
-    }
-
-    if (count($authors = $desc->getAuthors()) > 0) {
-      if (count($authors) === 1) {
-        $sender->sendMessage("Author: " . implode(", ", $authors));
-      } else {
-        $sender->sendMessage("Authors: " . implode(", ", $authors));
-      }
-    }
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/subcommand/Subcommand.php b/src/imperazim/components/command/subcommand/Subcommand.php
deleted file mode 100644
index 22b17e5..0000000
--- a/src/imperazim/components/command/subcommand/Subcommand.php
+++ /dev/null
@@ -1,69 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command\subcommand;
-
-use imperazim\vendor\commando\BaseSubCommand;
-use imperazim\components\plugin\PluginToolkit;
-
-/**
-* Class Command
-* @package imperazim\components\command\subcommand
-*/
-abstract class Subcommand extends BaseSubCommand {
-
-  /** @var SubcommandBuilder|null */
-  private $build = null;
-
-  /**
-  * Command constructor.
-  */
-  public function __construct(PluginToolkit $plugin) {
-    $this->build = $this->build($plugin);
-    parent::__construct(
-      plugin: $plugin,
-      names: $this->build->getNames(),
-      description: $this->build->getDescription()
-    );
-  }
-
-  /**
-  * Set up the command.
-  * @return SubcommandBuilder
-  */
-  protected abstract function build(PluginToolkit $plugin): SubcommandBuilder;
-
-  /**
-  * Executes the command logic when triggered.
-  * @param PluginToolkit $plugin The plugin toolkit instance.
-  * @param mixed $sender The sender of the command (could be a player, console, etc.).
-  * @param string $aliasUsed The alias of the command that was used.
-  * @param array $args The arguments passed with the command.
-  */
-  protected abstract function run(PluginToolkit $plugin, mixed $sender, string $aliasUsed, array $args): void;
-
-  /**
-  * Prepares the command for execution.
-  */
-  protected function prepare(): void {
-    if ($this->build instanceof SubcommandBuilder) {
-      $builder = $this->build;
-      if ($builder->getPermission()) {
-        $this->setPermission($builder->getPermission());
-      }
-      $this->registerArguments($builder->getArguments());
-      $this->addConstraints($builder->getConstraints());
-    }
-  }
-
-  /**
-  * Executes the command.
-  * @param mixed $sender
-  * @param string $aliasUsed
-  * @param array $args
-  */
-  public function onRun(mixed $sender, string $aliasUsed, array $args): void {
-    $this->run($this->getOwningPlugin(), $sender, $aliasUsed, $args);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/components/command/subcommand/SubcommandBuilder.php b/src/imperazim/components/command/subcommand/SubcommandBuilder.php
deleted file mode 100644
index 0e153b9..0000000
--- a/src/imperazim/components/command/subcommand/SubcommandBuilder.php
+++ /dev/null
@@ -1,70 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\command\subcommand;
-
-/**
-* Class SubcommandBuilder
-* @package imperazim\components\command\subcommand
-*/
-final class SubcommandBuilder {
-
-  /**
-  * SubcommandBuilder constructor.
-  *
-  * @param array $commandData The array containing command configuration.
-  */
-  public function __construct(
-    private array $names = [],
-    private string $description = '',
-    private ?string $permission = null,
-    private array $arguments = [],
-    private array $constraints = []
-  ) {}
-
-  /**
-  * Get command names.
-  *
-  * @return array
-  */
-  public function getNames(): array {
-    return $this->names;
-  }
-
-  /**
-  * Get command description.
-  *
-  * @return string
-  */
-  public function getDescription(): string {
-    return $this->description;
-  }
-
-  /**
-  * Get command permission.
-  *
-  * @return string|null
-  */
-  public function getPermission(): ?string {
-    return $this->permission;
-  }
-
-  /**
-  * Get command arguments.
-  *
-  * @return array
-  */
-  public function getArguments(): array {
-    return $this->arguments;
-  }
-
-  /**
-  * Get command constraints.
-  *
-  * @return array
-  */
-  public function getConstraints(): array {
-    return $this->constraints;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/components/commands/PluginsCommand.php b/src/imperazim/components/commands/PluginsCommand.php
new file mode 100644
index 0000000..cd6f313
--- /dev/null
+++ b/src/imperazim/components/commands/PluginsCommand.php
@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\components\commands;
+
+use imperazim\command\Command;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+use pocketmine\plugin\Plugin;
+use pocketmine\utils\TextFormat;
+use pocketmine\lang\KnownTranslationFactory;
+use pocketmine\permission\DefaultPermissionNames;
+use function array_map;
+use function count;
+use function implode;
+use function stripos;
+use function strtolower;
+use function sort;
+use function strlen;
+use function str_repeat;
+use const SORT_STRING;
+
+/**
+* Final class PluginsCommand
+*
+* @package imperazim\components\commands
+*/
+final class PluginsCommand extends Command {
+
+    /**
+    * Builds the command configuration.
+    * Must return an array with command settings.
+    *
+    * @return array Command configuration
+    */
+    public function onBuild(): array {
+        return [
+            'name' => 'plugins',
+            'aliases' => ['pl'],
+            'description' => 'List all server plugins.',
+            'permission' => DefaultPermissionNames::COMMAND_PLUGINS
+        ];
+    }
+
+    /**
+    * Executes the command logic.
+    *
+    * @param CommandResult $result The command execution result
+    */
+    public function onExecute(CommandResult $result): void {
+        $sender = $result->getSender();
+        $args = $result->getArgumentsList();
+        $pluginManager = $sender->getServer()->getPluginManager();
+        if (count($args) === 0) {
+            $plugins = $pluginManager->getPlugins();
+            $enabled = count(array_filter($plugins, fn(Plugin $p) => $p->isEnabled()));
+
+            // Cabeçalho dinâmico
+            $header = "===== PLUGINS (" . count($plugins) . ") =====";
+            $footer = str_repeat("=", strlen($header));
+
+            $sender->sendMessage(TextFormat::BOLD . TextFormat::GOLD . $header);
+            $sender->sendMessage(TextFormat::GRAY . "Enabled: " . TextFormat::GREEN . $enabled . TextFormat::GRAY . " | Disabled: " . TextFormat::RED . (count($plugins) - $enabled));
+
+            $list = array_map(function(Plugin $plugin): string {
+                return ($plugin->isEnabled() ? TextFormat::GREEN : TextFormat::RED) . $plugin->getDescription()->getFullName();
+            }, $plugins);
+            sort($list, SORT_STRING);
+
+            $sender->sendMessage(TextFormat::RESET . implode("\n", $list));
+            $sender->sendMessage(TextFormat::BOLD . TextFormat::GOLD . $footer);
+        } else {
+            $pluginName = implode(" ", $args->toArray());
+            $exactPlugin = $pluginManager->getPlugin($pluginName);
+
+            if ($exactPlugin instanceof Plugin) {
+                $this->describePlugin($exactPlugin, $sender);
+                return;
+            }
+
+            $found = false;
+            $lowerName = strtolower($pluginName);
+            foreach ($pluginManager->getPlugins() as $p) {
+                if (stripos($p->getName(), $lowerName) !== false) {
+                    $this->describePlugin($p, $sender);
+                    $found = true;
+                }
+            }
+
+            if (!$found) {
+                $sender->sendMessage(TextFormat::RED . "No plugin found matching '" . $pluginName . "'.");
+            }
+        }
+    }
+
+    /**
+    * Handles command execution failures.
+    *
+    * @param CommandFailure $failure The failure details
+    */
+    public function onFailure(CommandFailure $failure): void {
+        $sender = $failure->getSender();
+        if ($failure->getReason() === CommandFailure::EXECUTION_ERROR) {
+            $data = $failure->getData();
+            $sender->sendMessage("Fatal error: " . $failure->getMessage());
+            $sender->sendMessage("Location: " . $data['file'] . ": " . $data['line']);
+            return;
+        }
+        $sender->sendMessage($failure->getMessage());
+    }
+
+    /**
+    * Describes the description of a plugin
+    *
+    * @param Plugin $plugin The plugin.
+    * @param mixed $sender The sender.
+    */
+    private function describePlugin(Plugin $plugin, mixed $sender): void {
+        $desc = $plugin->getDescription();
+        $status = $plugin->isEnabled() ? TextFormat::GREEN . "Enabled" : TextFormat::RED . "Disabled";
+
+        // Cabeçalho dinâmico para plugin individual
+        $header = "===== " . $desc->getName() . " =====";
+        $footer = "======================" . str_repeat("=", strlen($desc->getName()));
+
+        $sender->sendMessage(TextFormat::BOLD . TextFormat::DARK_AQUA . $header);
+        $sender->sendMessage(TextFormat::YELLOW . "Version: " . TextFormat::WHITE . $desc->getVersion());
+        $sender->sendMessage(TextFormat::YELLOW . "Status: " . $status);
+
+        if ($desc->getDescription() !== "") {
+            $sender->sendMessage(TextFormat::YELLOW . "Description: " . TextFormat::GRAY . $desc->getDescription());
+        }
+        if ($desc->getWebsite() !== "") {
+            $sender->sendMessage(TextFormat::YELLOW . "Website: " . TextFormat::BLUE . $desc->getWebsite());
+        }
+        if (count($authors = $desc->getAuthors()) > 0) {
+            $sender->sendMessage(TextFormat::YELLOW . "Authors: " . TextFormat::GOLD . implode(", ", $authors));
+        }
+        $sender->sendMessage(TextFormat::BOLD . TextFormat::DARK_AQUA . $footer);
+    }
+
+}
\ No newline at end of file
diff --git a/src/imperazim/components/commands/VersionCommand.php b/src/imperazim/components/commands/VersionCommand.php
new file mode 100644
index 0000000..76f3479
--- /dev/null
+++ b/src/imperazim/components/commands/VersionCommand.php
@@ -0,0 +1,227 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\components\commands;
+
+use imperazim\command\Command;
+use imperazim\command\result\CommandResult;
+use imperazim\command\result\CommandFailure;
+use pocketmine\lang\KnownTranslationFactory;
+use pocketmine\network\mcpe\protocol\ProtocolInfo;
+use pocketmine\permission\DefaultPermissionNames;
+use pocketmine\plugin\Plugin;
+use pocketmine\utils\TextFormat;
+use pocketmine\utils\Utils;
+use pocketmine\VersionInfo;
+use function count;
+use function implode;
+use function stripos;
+use function strtolower;
+use function round;
+use function memory_get_usage_real;
+use function floor;
+use const PHP_VERSION;
+
+/**
+* Command to display detailed server information and version data.
+*
+* This command provides comprehensive details about the server software,
+* Minecraft version, performance metrics, system information, and components.
+*
+* @package imperazim\components\commands
+*/
+final class VersionCommand extends Command {
+
+    /**
+    * Builds the command configuration.
+    *
+    * @return array Command settings including name, aliases, description and permission
+    */
+    public function onBuild(): array {
+        return [
+            'name' => 'version',
+            'aliases' => ['ver',
+                'about'],
+            'description' => 'See detailed information about the server',
+            'permission' => DefaultPermissionNames::COMMAND_VERSION
+        ];
+    }
+
+    /**
+    * Executes the version command logic.
+    *
+    * Displays server information when no arguments are provided, or searches
+    * for plugins when arguments are given.
+    *
+    * @param CommandResult $result The command execution result container
+    */
+    public function onExecute(CommandResult $result): void {
+        $sender = $result->getSender();
+        $args = $result->getArgumentsList();
+        $pluginManager = $sender->getServer()->getPluginManager();
+
+        if (count($args) === 0) {
+            $plugin = $this->getPlugin();
+            $server = $sender->getServer();
+
+            $header = "§l§6»§r §lSERVER INFORMATION§r §6«";
+            $divider = "§8§l»§r§7" . str_repeat("─", 38) . "§8§l«";
+            $footer = "§8§l»§r§7" . str_repeat("─", 38) . "§8§l«";
+
+            $message = [];
+
+            $message[] = $header;
+            $message[] = $divider;
+            $message[] = "§e§l»§r §aSOFTWARE";
+            $message[] = " §8▪ §7Server: §f" . VersionInfo::NAME;
+            $message[] = " §8▪ §7Library: §f" . $plugin->getName() . " §8(v" . $plugin->getDescription()->getVersion() . ")";
+
+            $versionColor = VersionInfo::IS_DEVELOPMENT_BUILD ? "§c" : "§a";
+            $message[] = " §8▪ §7Version: " . $versionColor . VersionInfo::VERSION()->getFullVersion();
+            $message[] = " §8▪ §7Git: §3" . VersionInfo::GIT_HASH();
+
+            $message[] = $divider;
+            $message[] = "§e§l»§r §aMINECRAFT";
+            $message[] = " §8▪ §7Version: §f" . ProtocolInfo::MINECRAFT_VERSION_NETWORK;
+            $message[] = " §8▪ §7Protocol: §f" . ProtocolInfo::CURRENT_PROTOCOL;
+
+            $message[] = $divider;
+            $message[] = "§e§l»§r §aPERFORMANCE";
+            $message[] = " §8▪ §7Uptime: §f" . $this->formatUptime($server->getTick());
+            $message[] = " §8▪ §7TPS: §f" . round($server->getTicksPerSecond(), 1);
+            $message[] = " §8▪ §7Load: §f" . round($server->getTickUsage(), 1) . "%";
+            $message[] = " §8▪ §7Memory: §f" . $this->formatMemory(memory_get_usage());
+
+            $message[] = $divider;
+            $message[] = "§e§l»§r §aSYSTEM";
+            $message[] = " §8▪ §7PHP: §f" . PHP_VERSION;
+
+            $jitMode = Utils::getOpcacheJitMode();
+            if ($jitMode !== null) {
+                $jitStatus = $jitMode !== 0
+                ? "§aEnabled §8(Mode: " . $jitMode . ")"
+                : "§cDisabled";
+            } else {
+                $jitStatus = "§cNot Supported";
+            }
+            $message[] = " §8▪ §7PHP JIT: " . $jitStatus;
+
+            $message[] = " §8▪ §7OS: §f" . Utils::getOS();
+
+            $message[] = $divider;
+            $message[] = "§e§l»§r §aCOMPONENTS";
+            $message[] = " §8▪ §7Enabled: §a" . count($plugin->componentsManager->enabledComponents);
+            $message[] = " §8▪ §7Custom: §b" . count(\LibraryComponents::$customComponents) - count($plugin->componentsManager->enabledComponents);
+
+            $message[] = $footer;
+
+            $sender->sendMessage(implode("\n", $message));
+        } else {
+            $pluginName = implode(" ", $args);
+            $exactPlugin = $pluginManager->getPlugin($pluginName);
+
+            if ($exactPlugin instanceof Plugin) {
+                $this->describeToSender($exactPlugin, $sender);
+                return;
+            }
+
+            $found = false;
+            $pluginName = strtolower($pluginName);
+            foreach ($pluginManager->getPlugins() as $plugin) {
+                if (stripos($plugin->getName(), $pluginName) !== false) {
+                    $this->describeToSender($plugin, $sender);
+                    $found = true;
+                }
+            }
+
+            if (!$found) {
+                $sender->sendMessage(KnownTranslationFactory::pocketmine_command_version_noSuchPlugin());
+            }
+        }
+    }
+
+    /**
+    * Formats memory bytes into human-readable string.
+    *
+    * @param int $bytes Memory usage in bytes
+    * @return string Formatted memory string (e.g. "128.54 MB")
+    */
+    private function formatMemory(int $bytes): string {
+        $units = ['B',
+            'KB',
+            'MB',
+            'GB'];
+        $index = 0;
+
+        while ($bytes >= 1024 && $index < 3) {
+            $bytes /= 1024;
+            $index++;
+        }
+
+        return round($bytes, 2) . ' ' . $units[$index];
+    }
+
+    /**
+    * Formats server uptime from ticks into human-readable duration.
+    *
+    * @param int $ticks Server uptime in ticks
+    * @return string Formatted duration (e.g. "2h 15m")
+    */
+    private function formatUptime(int $ticks): string {
+        $seconds = $ticks / 20;
+        $minutes = $seconds / 60;
+        $hours = $minutes / 60;
+
+        if ($hours >= 1) {
+            return floor($hours) . 'h ' . floor($minutes % 60) . 'm';
+        }
+        if ($minutes >= 1) {
+            return floor($minutes) . 'm ' . floor($seconds % 60) . 's';
+        }
+        return floor($seconds) . 's';
+    }
+
+    /**
+    * Handles command execution failures.
+    *
+    * @param CommandFailure $failure Container with failure details
+    */
+    public function onFailure(CommandFailure $failure): void {
+        $sender = $failure->getSender();
+        if ($failure->getReason() === CommandFailure::EXECUTION_ERROR) {
+            $data = $failure->getData();
+            $sender->sendMessage("Fatal error: " . $failure->getMessage());
+            $sender->sendMessage("Location: " . $data['file'] . ": " . $data['line']);
+            return;
+        }
+        $sender->sendMessage($failure->getMessage());
+    }
+
+    /**
+    * Describes plugin details to the sender.
+    *
+    * @param Plugin $plugin Plugin to describe
+    * @param mixed $sender Command sender
+    */
+    private function describeToSender(Plugin $plugin, mixed $sender) : void {
+        $desc = $plugin->getDescription();
+        $sender->sendMessage(TextFormat::DARK_GREEN . $desc->getName() . TextFormat::RESET . " version " . TextFormat::DARK_GREEN . $desc->getVersion());
+
+        if ($desc->getDescription() !== "") {
+            $sender->sendMessage($desc->getDescription());
+        }
+
+        if ($desc->getWebsite() !== "") {
+            $sender->sendMessage("Website: " . $desc->getWebsite());
+        }
+
+        if (count($authors = $desc->getAuthors()) > 0) {
+            if (count($authors) === 1) {
+                $sender->sendMessage("Author: " . implode(", ", $authors));
+            } else {
+                $sender->sendMessage("Authors: " . implode(", ", $authors));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/components/filesystem/File.php b/src/imperazim/components/filesystem/File.php
index a507a0c..fcde41e 100644
--- a/src/imperazim/components/filesystem/File.php
+++ b/src/imperazim/components/filesystem/File.php
@@ -43,9 +43,6 @@ public function __construct(
       } else {
         $directory = str_replace('//', '/', $directoryOrConfig . '/');
       }
-      if (!in_array($fileType, self::getTypes())) {
-        throw new FileSystemException("Invalid file type: $fileType");
-      }
       $this->directoryOrConfig = $directory;
       $this->fileName = $fileName ?? '';
       $this->fileType = $fileType ?? self::TYPE_YML;
@@ -61,6 +58,27 @@ public function __construct(
     }
   }
 
+  // Add these new methods to support Island management
+  public function read(): array {
+    return $this->get(null, []);
+  }
+
+  public function write(array $data): void {
+    $extension = self::getExtensionByType($this->getFileType());
+    $content = self::serializeContent($extension, $data);
+    $this->writeFile($content);
+  }
+
+  public function getFileName(): string {
+    return $this->fileName;
+  }
+
+  public function getFolder(): string {
+    return $this->directoryOrConfig instanceof Config 
+      ? dirname($this->directoryOrConfig->getPath())
+      : $this->directoryOrConfig;
+  }
+  
   /**
   * Clone the File object with empty data.
   * @return self
@@ -136,8 +154,9 @@ public static function serializeContent(string $extension, array $data): string
         'txt' => self::writeList(array_keys($data)),
         'ini' => self::writeIniFile($data)
       };
+    } else {
+      return self::writeList(array_keys($data));
     }
-    throw new FileSystemException("Unsupported file type: {$extension}");
   }
 
   /**
@@ -156,8 +175,9 @@ public static function deserializeContent(string $extension, string $fileContent
         'txt' => array_fill_keys(self::parseList($fileContent), true),
         'ini' => parse_ini_string($fileContent, true)
       };
+    } else {
+      return array_fill_keys(self::parseList($fileContent), true);
     }
-    throw new FileSystemException("Unsupported file type: {$extension}");
   }
 
   /**
diff --git a/src/imperazim/components/filesystem/Path.php b/src/imperazim/components/filesystem/Path.php
index baff19b..b381503 100644
--- a/src/imperazim/components/filesystem/Path.php
+++ b/src/imperazim/components/filesystem/Path.php
@@ -49,6 +49,53 @@ public function getFolder(): string {
     return $this->sourceFolder;
   }
 
+  /**
+  * Checks if the directory exists.
+  * @return bool
+  */
+  public function exists(): bool {
+    return is_dir($this->sourceFolder);
+  }
+
+  /**
+  * Gets all files in the directory as File objects.
+  * @return File[]
+  */
+  public function getFiles(): array {
+    if (!$this->exists()) {
+      return [];
+    }
+    
+    $files = [];
+    $iterator = new DirectoryIterator($this->sourceFolder);
+    
+    foreach ($iterator as $file) {
+      if ($file->isDot() || $file->isDir()) continue;
+      
+      $fileName = $file->getBasename('.' . $file->getExtension());
+      $extension = $file->getExtension();
+      $fileType = File::getTypeByExtension($extension);
+      
+      $files[] = new File(
+        directoryOrConfig: $this->sourceFolder,
+        fileName: $fileName,
+        fileType: $fileType
+      );
+    }
+    
+    return $files;
+  }
+
+  /**
+  * Gets all file base names (without extension) in the directory.
+  * @return string[]
+  */
+  public function getBaseNames(): array {
+    return array_map(
+      fn(File $file) => $file->getFileName(),
+      $this->getFiles()
+    );
+  }
 
   /**
   * Adds a new file to the directory using the File class.
@@ -270,11 +317,13 @@ public static function getRecursiveFiles(string $folder): array {
 
       foreach ($files as $file) {
         if ($file->isFile()) {
+          $extension = $file->getExtension();
+          $fileType = File::getTypeByExtension($extension);
           $filesInfo[] = [
             'directory' => $file->getPath(),
-            'fileName' => $file->getBasename(),
-            'fileType' => File::getTypeByExtension($file->getExtension()),
-            'content' => File::deserializeContent($file->getExtension(), file_get_contents($file->getRealPath()))
+            'fileName' => $file->getBasename('.' . $extension),
+            'fileType' => $fileType,
+            'content' => File::deserializeContent($extension, file_get_contents($file->getRealPath()))
           ];
         }
       }
diff --git a/src/imperazim/components/filesystem/traits/FileExtensionTypes.php b/src/imperazim/components/filesystem/traits/FileExtensionTypes.php
index 8a41b92..8fce184 100644
--- a/src/imperazim/components/filesystem/traits/FileExtensionTypes.php
+++ b/src/imperazim/components/filesystem/traits/FileExtensionTypes.php
@@ -58,7 +58,10 @@ public static function getExtensions(): array {
   public static function getTypeByExtension(string $extension): ?string {
     $extension = strtolower($extension);
     $type = array_search($extension, self::$typeToExtension, true);
-    return $type !== false ? $type : null;
+    if ($type !== false) {
+      return $type;
+    }
+    return 'file:' . $extension;
   }
 
   /**
@@ -68,8 +71,15 @@ public static function getTypeByExtension(string $extension): ?string {
   * @return string|null
   */
   public static function getExtensionByType(string $type, bool $withPoint = false): ?string {
-    $extension = self::$typeToExtension[$type] ?? null;
-    return $extension !== null ? ($withPoint ? '.' . $extension : $extension) : null;
+    if (isset(self::$typeToExtension[$type])) {
+      $extension = self::$typeToExtension[$type];
+      return $withPoint ? '.' . $extension : $extension;
+    }
+    if (str_starts_with($type, 'file:')) {
+      $extension = substr($type, 5);
+      return $withPoint ? '.' . $extension : $extension;
+    }
+    return null;
   }
-  
+
 }
\ No newline at end of file
diff --git a/src/imperazim/components/item/traits/ItemRarityTrait.php b/src/imperazim/components/item/traits/ItemRarityTrait.php
deleted file mode 100644
index cb0cf13..0000000
--- a/src/imperazim/components/item/traits/ItemRarityTrait.php
+++ /dev/null
@@ -1,32 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\item\traits;
-
-/**
-* Trait ItemRarityTrait
-* @package imperazim\components\item\traits
-*/
-trait ItemRarityTrait {
-  
-  const COMMON = 'common';
-  const UNCOMMON = 'uncommon';
-  const RARE = 'rare';
-  const EPIC = 'epic';
-  const LEGENDARY = 'legendary';
-
-  /** @var string|null */
-  protected ?string $rarity = null;
-
-  /** @return string|null */
-  public function getRarity(): ?string {
-    return $this->rarity;
-  }
-
-  /** @param string|null $rarity */
-  public function setRarity(?string $rarity): void {
-    $this->rarity = $rarity;
-  }
-  
-}
\ No newline at end of file
diff --git a/src/imperazim/components/plugin/PluginToolkit.php b/src/imperazim/components/plugin/PluginToolkit.php
index 526365a..c961f8e 100644
--- a/src/imperazim/components/plugin/PluginToolkit.php
+++ b/src/imperazim/components/plugin/PluginToolkit.php
@@ -351,7 +351,7 @@ public function saveRecursiveResources(?string $loadType = '--merge'): ?array {
     private function processFile(array $file, ?string $loadType): ?File {
       try {
         $fileName = $file['fileName'] ?? null;
-        $fileType = $file['fileType'] ?? null;
+        $fileType = $file['fileType'] ?? 'file:unknown';
         $fileContent = $file['content'] ?? null;
         $fileDirectory = $file['directory'] ?? null;
 
diff --git a/src/imperazim/components/trigger/ItemTrigger.php b/src/imperazim/components/trigger/ItemTrigger.php
new file mode 100644
index 0000000..98f196e
--- /dev/null
+++ b/src/imperazim/components/trigger/ItemTrigger.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace imperazim\components\trigger;
+
+use pocketmine\player\Player;
+use pocketmine\item\Item;
+use pocketmine\inventory\PlayerInventory;
+
+/**
+* Class ItemTrigger
+* Checks if a player has a specific item and returns their inventory for functional operations.
+* @package imperazim\components\trigger
+*/
+final class ItemTrigger extends PerPlayerTrigger {
+
+  /**
+  * @param string $itemClass Item class to check (e.g., Item::class).
+  * @param \Closure $callback Action to execute when the player has the item. Receives Player and PlayerInventory.
+  */
+  public function __construct(string $itemClass, \Closure $callback) {
+    // Define condition and pass inventory to the callback
+    $condition = function(Player $player) use ($itemClass, $callback): bool {
+      $inventory = $player->getInventory();
+      
+      // Functional approach: Check if any item matches the class
+      $hasItem = count(array_filter(
+        $inventory->getContents(),
+        fn(Item $item) => $item instanceof $itemClass
+      )) > 0;
+
+      if ($hasItem) {
+        $callback($player, $inventory); // Pass both player and inventory
+        return true;
+      }
+      return false;
+    };
+
+    parent::__construct($condition, fn(Player $player) => $callback($player, $player->getInventory()));
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/components/trigger/TriggerTypes.php b/src/imperazim/components/trigger/TriggerTypes.php
index 6c44ba7..4bc902f 100644
--- a/src/imperazim/components/trigger/TriggerTypes.php
+++ b/src/imperazim/components/trigger/TriggerTypes.php
@@ -12,5 +12,6 @@ final class TriggerTypes {
   
   const GLOBAL = 0;
   const PER_PLAYER = 1;
+  const ITEM = 2;
   
 }
\ No newline at end of file
diff --git a/src/imperazim/components/ui/Form.php b/src/imperazim/components/ui/Form.php
deleted file mode 100644
index a1c1160..0000000
--- a/src/imperazim/components/ui/Form.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\components\ui;
-
-use imperazim\vendor\libform\Form as IForm;
-
-/**
-* Class Form
-* @package imperazim\components\ui
-*/
-abstract class Form extends Base {
-  
-  /**
-  * Construct and set up the ui.
-  * @return IForm
-  */
-  protected abstract function structure(): IForm;
-
-  /**
-  * Validate the ui type.
-  * @param mixed $ui
-  * @return bool
-  */
-  protected function isValid(mixed $ui): bool {
-    return $ui instanceof IForm;
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/form/Form.php b/src/imperazim/form/Form.php
new file mode 100644
index 0000000..7a9bc0b
--- /dev/null
+++ b/src/imperazim/form/Form.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form;
+
+use pocketmine\player\Player;
+use pocketmine\form\Form as PocketMineForm;
+use imperazim\form\base\elements\Title;
+
+/**
+* Abstract base class for all forms.
+*/
+abstract class Form implements PocketMineForm {
+  /** @var Title Form title */
+  protected Title $title;
+
+  /**
+  * Constructs the form.
+  *
+  * @param Title $title Form title
+  */
+  public function __construct(Title $title) {
+    $this->title = $title;
+  }
+
+  /**
+  * Gets form title.
+  *
+  * @return Title Title element
+  */
+  public function getTitle(): Title {
+    return $this->title;
+  }
+
+  /**
+  * Sets form title.
+  *
+  * @param Title $title New title
+  */
+  public function setTitle(Title $title): void {
+    $this->title = $title;
+  }
+
+  /**
+  * Sends form to player.
+  *
+  * @param Player $player Target player
+  */
+  public function sendTo(Player $player): void {
+    $player->sendForm($this);
+  }
+
+  /**
+  * Serializes form for JSON.
+  *
+  * @return array<string, mixed> Serialized data
+  */
+  final public function jsonSerialize(): array {
+    return [
+      'type' => $this->getFormType(),
+      'title' => $this->title->getText(),
+      ...$this->serializeFormData()
+    ];
+  }
+
+  /**
+  * Serializes form-specific data.
+  *
+  * @return array<string, mixed> Form data
+  */
+  abstract protected function serializeFormData(): array;
+
+  /**
+  * Gets form type identifier.
+  *
+  * @return string Form type
+  */
+  abstract protected function getFormType(): string;
+}
\ No newline at end of file
diff --git a/src/imperazim/form/FormData.php b/src/imperazim/form/FormData.php
new file mode 100644
index 0000000..fea7ace
--- /dev/null
+++ b/src/imperazim/form/FormData.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form;
+
+use ArrayAccess;
+use IteratorAggregate;
+use Countable;
+use ArrayIterator;
+use Traversable;
+
+/**
+* Data container for forms with array-like access.
+*
+* @implements ArrayAccess<string|int, mixed>
+* @implements IteratorAggregate<string|int, mixed>
+*/
+final class FormData implements ArrayAccess, IteratorAggregate, Countable {
+  /** @var array<string|int, mixed> Data storage */
+  private array $data;
+
+  /**
+  * @param array<string|int, mixed> $data Initial data
+  */
+  public function __construct(array $data = []) {
+    $this->data = $data;
+  }
+
+  /**
+  * Checks if offset exists.
+  *
+  * @param mixed $offset Offset to check
+  * @return bool Existence status
+  */
+  public function offsetExists(mixed $offset): bool {
+    return isset($this->data[$offset]);
+  }
+
+  /**
+  * Gets value by offset.
+  *
+  * @param mixed $offset Data key
+  * @return mixed Value or null
+  */
+  public function offsetGet(mixed $offset): mixed {
+    return $this->data[$offset] ?? null;
+  }
+
+  /**
+  * Sets value by offset.
+  *
+  * @param mixed $offset Data key
+  * @param mixed $value Value to set
+  */
+  public function offsetSet(mixed $offset, mixed $value): void {
+    if ($offset === null) {
+      $this->data[] = $value;
+    } else {
+      $this->data[$offset] = $value;
+    }
+  }
+
+  /**
+  * Unsets value by offset.
+  *
+  * @param mixed $offset Data key
+  */
+  public function offsetUnset(mixed $offset): void {
+    unset($this->data[$offset]);
+  }
+
+  /**
+  * Gets data iterator.
+  *
+  * @return Traversable Data iterator
+  */
+  public function getIterator(): Traversable {
+    return new ArrayIterator($this->data);
+  }
+
+  /**
+  * Counts data items.
+  *
+  * @return int Item count
+  */
+  public function count(): int {
+    return count($this->data);
+  }
+
+  /**
+  * Gets value by key.
+  *
+  * @param string|int $key Data key
+  * @return mixed Value or null
+  */
+  public function get(string|int $key): mixed {
+    return $this->offsetGet($key);
+  }
+
+  /**
+  * Converts data to array.
+  *
+  * @return array<string|int, mixed> Data array
+  */
+  public function toArray(): array {
+    return $this->data;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/FormResult.php b/src/imperazim/form/FormResult.php
new file mode 100644
index 0000000..9736ea7
--- /dev/null
+++ b/src/imperazim/form/FormResult.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form;
+
+/**
+* Represents the result state of a form submission.
+*/
+enum FormResult: string {
+  /** Indicates the form should close */
+  case CLOSE = 'close';
+
+    /** Indicates the form should remain open */
+  case KEEP = 'keep';
+}
\ No newline at end of file
diff --git a/src/imperazim/form/LibForm.php b/src/imperazim/form/LibForm.php
new file mode 100644
index 0000000..d38b8e8
--- /dev/null
+++ b/src/imperazim/form/LibForm.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace imperazim\form;
+
+use pocketmine\plugin\PluginBase;
+
+final class LibForm extends PluginBase {
+    /**
+     * This class only exists for plugin independence 
+     * reasons.
+     */
+}
\ No newline at end of file
diff --git a/src/imperazim/form/base/elements/Content.php b/src/imperazim/form/base/elements/Content.php
new file mode 100644
index 0000000..f43b08b
--- /dev/null
+++ b/src/imperazim/form/base/elements/Content.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\base\elements;
+
+/**
+* Represents a form content/text element.
+*/
+final class Content extends TextElement {
+  /**
+  * @param string $text Content text
+  */
+  public function __construct(string $text) {
+    parent::__construct($text);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/base/elements/TextElement.php b/src/imperazim/form/base/elements/TextElement.php
new file mode 100644
index 0000000..74c8f51
--- /dev/null
+++ b/src/imperazim/form/base/elements/TextElement.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\base\elements;
+
+use JsonSerializable;
+
+/**
+* Abstract base class for text-based form elements.
+*/
+abstract class TextElement implements JsonSerializable {
+  /**
+  * @param string $text Display text
+  */
+  public function __construct(private string $text) {}
+
+  /**
+  * Gets the element's text content.
+  *
+  * @return string Display text
+  */
+  public function getText(): string {
+    return $this->text;
+  }
+
+  /**
+  * Serializes the element to a string.
+  *
+  * @return string Serialized text
+  */
+  public function jsonSerialize(): string {
+    return $this->text;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/base/elements/Title.php b/src/imperazim/form/base/elements/Title.php
new file mode 100644
index 0000000..8f1fa6f
--- /dev/null
+++ b/src/imperazim/form/base/elements/Title.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\base\elements;
+
+/**
+* Represents a form title element.
+*/
+final class Title extends TextElement {
+  /**
+  * @param string $text Title text
+  */
+  public function __construct(string $text) {
+    parent::__construct($text);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/CustomForm.php b/src/imperazim/form/custom/CustomForm.php
new file mode 100644
index 0000000..53965b1
--- /dev/null
+++ b/src/imperazim/form/custom/CustomForm.php
@@ -0,0 +1,189 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom;
+
+use JsonSerializable;
+use InvalidArgumentException;
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormData;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\custom\elements\ElementCollection;
+use imperazim\form\custom\response\CustomResponse;
+
+/**
+* Abstract base class for custom forms.
+*/
+abstract class CustomForm extends Form {
+  /** @var ElementCollection|null Cached elements */
+  private ?ElementCollection $elementsCache = null;
+
+  /** @var FormData Form data container */
+  private FormData $formData;
+
+  /** @var Player Target player */
+  private Player $player;
+
+  /** @var bool Bypass validation */
+  private bool $force;
+
+  /**
+  * Constructs the form.
+  *
+  * @param Player $player Target player
+  * @param array|FormData $data Form data
+  * @param bool $force Bypass validation
+  */
+  public function __construct(
+    Player $player,
+    array|FormData $data = [],
+    bool $force = false
+  ) {
+    $this->player = $player;
+    $this->force = $force;
+    $this->formData = $data instanceof FormData ? $data : new FormData($data);
+
+    parent::__construct($this->title($player, $this->formData));
+
+    if ($force) {
+      $this->sendTo($player);
+    }
+  }
+
+  /**
+  * Gets form title.
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return Title Title element
+  */
+  abstract protected function title(Player $player, FormData $data): Title;
+
+  /**
+  * Gets form elements.
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return ElementCollection Elements collection
+  */
+  abstract protected function elements(Player $player, FormData $data): ElementCollection;
+
+  /**
+  * Handles form submission.
+  *
+  * @param Player $player Submitting player
+  * @param CustomResponse $response Form response
+  * @return FormResult Action result
+  */
+  abstract protected function onSubmit(
+    Player $player,
+    CustomResponse $response
+  ): FormResult;
+
+  /**
+  * Handles form closure.
+  *
+  * @param Player $player Closing player
+  * @param FormData $data Form data
+  * @return FormResult Action result
+  */
+  abstract protected function onClose(
+    Player $player,
+    FormData $data
+  ): FormResult;
+
+  /**
+  * Handles form response.
+  *
+  * @param Player $player Responding player
+  * @param mixed $raw Raw response data
+  */
+  public function handleResponse(Player $player, $raw): void {
+    if ($raw !== null && !is_array($raw)) {
+      throw new InvalidArgumentException("Response data must be array or null.");
+    }
+
+    $elements = $this->getCachedElements($player, $this->formData);
+    $idMap = [];
+    $elementMap = [];
+
+    if (is_array($raw)) {
+      foreach ($elements as $idx => $element) {
+        $elementMap[$element->getId()] = $element;
+
+        if ($element->hasValue() && array_key_exists($idx, $raw)) {
+          $idMap[$element->getId()] = $raw[$idx];
+        }
+      }
+    }
+
+    if ($raw === null) {
+      $result = $this->onClose($player, $this->formData);
+    } else {
+      $response = new CustomResponse(
+        $this->formData,
+        $raw,
+        $idMap,
+        $elementMap
+      );
+
+      if (!$this->force && count($response->getElementsRaw()) !== count($elements)) {
+        throw new InvalidArgumentException("Invalid number of fields.");
+      }
+
+      $result = $this->onSubmit($player, $response);
+    }
+
+    if ($result === FormResult::KEEP) {
+      $this->sendTo($player);
+    }
+  }
+
+  /**
+  * Serializes form data.
+  *
+  * @return array Serialized data
+  */
+  protected function serializeFormData(): array {
+    $elements = $this->getCachedElements($this->player, $this->formData);
+    return [
+      'content' => array_map(
+        fn(JsonSerializable $e) => $e->jsonSerialize(),
+        $elements
+      )
+    ];
+  }
+
+  /**
+  * Gets form type.
+  *
+  * @return string Form type identifier
+  */
+  protected function getFormType(): string {
+    return 'custom_form';
+  }
+
+  /**
+  * Gets and validates cached elements.
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return array Validated elements
+  * @throws InvalidArgumentException If elements lack IDs
+  */
+  private function getCachedElements(Player $player, FormData $data): array {
+    if ($this->elementsCache === null) {
+      $this->elementsCache = $this->elements($player, $data);
+
+      foreach ($this->elementsCache as $element) {
+        if (!$element->hasId()) {
+          throw new InvalidArgumentException("All elements must have an ID.");
+        }
+      }
+    }
+    return iterator_to_array($this->elementsCache);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/DynamicCustomForm.php b/src/imperazim/form/custom/DynamicCustomForm.php
new file mode 100644
index 0000000..a669a1f
--- /dev/null
+++ b/src/imperazim/form/custom/DynamicCustomForm.php
@@ -0,0 +1,153 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom;
+
+use Closure;
+use JsonSerializable;
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormData;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\custom\elements\Element;
+use imperazim\form\custom\elements\ElementCollection;
+use imperazim\form\custom\response\CustomResponse;
+
+/**
+* Dynamic implementation of a custom form.
+*/
+final class DynamicCustomForm extends Form {
+  /** @var ElementCollection Form elements */
+  private ElementCollection $elements;
+
+  /** @var Closure Submission handler */
+  private Closure $onSubmit;
+
+  /** @var Closure Closure handler */
+  private Closure $onClose;
+
+  /**
+  * Constructs the form.
+  *
+  * @param Title $title Form title
+  */
+  public function __construct(Title $title) {
+    parent::__construct($title);
+    $this->elements = new ElementCollection();
+    $this->onSubmit = fn(Player $p, CustomResponse $r): FormResult => FormResult::CLOSE;
+    $this->onClose = fn(Player $p): FormResult => FormResult::CLOSE;
+  }
+
+  /**
+  * Creates a new form instance.
+  *
+  * @param string|Title $title Form title
+  * @return self New instance
+  */
+  final public static function create(string|Title $title): self {
+    return new self($title instanceof Title ? $title : new Title($title));
+  }
+
+  /**
+  * Builds a form using configuration closure.
+  *
+  * @param string|Title $title Form title
+  * @param Closure $configurator Configuration callback
+  * @return self Configured instance
+  */
+  final public static function build(string|Title $title, Closure $configurator): self {
+    $form = self::create($title);
+    $configurator($form);
+    return $form;
+  }
+
+  /**
+  * Adds an element to the form.
+  *
+  * @param Element $element Form element
+  * @return self
+  */
+  public function addElement(Element $element): self {
+    $this->elements->add($element);
+    return $this;
+  }
+
+  /**
+  * Sets submission handler.
+  *
+  * @param Closure $handler Submission handler
+  * @return self
+  */
+  public function setOnSubmit(Closure $handler): self {
+    $this->onSubmit = $handler;
+    return $this;
+  }
+
+  /**
+  * Sets close handler.
+  *
+  * @param Closure $handler Close handler
+  * @return self
+  */
+  public function setOnClose(Closure $handler): self {
+    $this->onClose = $handler;
+    return $this;
+  }
+
+  /**
+  * Serializes form data.
+  *
+  * @return array Serialized data
+  */
+  protected function serializeFormData(): array {
+    return [
+      'content' => array_map(
+        fn(JsonSerializable $e) => $e->jsonSerialize(),
+        iterator_to_array($this->elements)
+      )
+    ];
+  }
+
+  /**
+  * Gets form type.
+  *
+  * @return string Form type identifier
+  */
+  protected function getFormType(): string {
+    return 'custom_form';
+  }
+
+  /**
+  * Handles form response.
+  *
+  * @param Player $player Responding player
+  * @param mixed $raw Raw response data
+  */
+  public function handleResponse(Player $player, $raw): void {
+    if ($raw === null) {
+      $result = ($this->onClose)($player);
+    } elseif (is_array($raw)) {
+      $idMap = [];
+      $elementMap = [];
+
+      foreach ($this->elements as $idx => $element) {
+        $elementMap[$element->getId()] = $element;
+
+        if ($element->hasValue() && array_key_exists($idx, $raw)) {
+          $idMap[$element->getId()] = $raw[$idx];
+        }
+      }
+
+      $response = new CustomResponse(new FormData([]), $raw, $idMap, $elementMap);
+      $result = ($this->onSubmit)($player, $response);
+    } else {
+      throw new InvalidArgumentException("Invalid response data type");
+    }
+
+    if ($result === FormResult::KEEP) {
+      $this->sendTo($player);
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Dropdown.php b/src/imperazim/form/custom/elements/Dropdown.php
new file mode 100644
index 0000000..0ed7505
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Dropdown.php
@@ -0,0 +1,120 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+use imperazim\form\custom\response\SelectedOption;
+
+/**
+* Represents a dropdown selection element.
+*/
+final class Dropdown extends Element {
+  /** @var Option[] Available options */
+  private array $options;
+
+  /** @var int Default option index */
+  private int $defaultIndex;
+
+  /**
+  * @param string $id Element ID
+  * @param string $text Label text
+  * @param array $options Options array
+  * @param string|int $default Default selection
+  */
+  public function __construct(
+    private string $id,
+    private string $text,
+    array $options,
+    string|int $default = 0
+  ) {
+    parent::__construct($id);
+    $this->options = $this->normalizeOptions($options);
+    $this->defaultIndex = $this->findOptionIndex($default);
+  }
+
+  /**
+  * Normalizes options array.
+  *
+  * @param array $options Raw options
+  * @return Option[] Normalized options
+  */
+  private function normalizeOptions(array $options): array {
+    $normalized = [];
+    foreach ($options as $key => $value) {
+      if ($value instanceof Option) {
+        $normalized[] = $value;
+      } elseif (is_array($value)) {
+        $normalized[] = new Option(
+          (string)($value['id'] ?? $key),
+          (string)($value['text'] ?? '')
+        );
+      } else {
+        $normalized[] = new Option((string)$key, (string)$value);
+      }
+    }
+    return $normalized;
+  }
+
+  /**
+  * Finds option index by ID or value.
+  *
+  * @param string|int $default Default identifier
+  * @return int Option index
+  */
+  private function findOptionIndex(string|int $default): int {
+    if (is_int($default)) {
+      return $default;
+    }
+
+    foreach ($this->options as $index => $option) {
+      if ($option->getId() === $default) {
+        return $index;
+      }
+    }
+    return 0;
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'dropdown',
+      'text' => $this->text,
+      'options' => array_map(fn(Option $o) => $o->getText(), $this->options),
+      'default' => $this->defaultIndex
+    ];
+  }
+
+  /**
+  * Gets option by index.
+  *
+  * @param int $index Option position
+  * @return Option|null Option or null
+  */
+  public function getOptionByIndex(int $index): ?Option {
+    return $this->options[$index] ?? null;
+  }
+
+  /**
+  * Gets selected option.
+  *
+  * @param int $index Selected index
+  * @return SelectedOption|null Selected option or null
+  */
+  public function getSelectedOption(int $index): ?SelectedOption {
+    $option = $this->getOptionByIndex($index);
+    if ($option === null) {
+      return null;
+    }
+
+    return new SelectedOption(
+      $index,
+      $option->getId(),
+      $option->getText()
+    );
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Element.php b/src/imperazim/form/custom/elements/Element.php
new file mode 100644
index 0000000..9fca74e
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Element.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace imperazim\form\custom\elements;
+
+use JsonSerializable;
+use InvalidArgumentException;
+
+/**
+ * Abstract base class for form elements.
+ */
+abstract class Element implements JsonSerializable {
+    /**
+     * @param string|null $id Element identifier
+     */
+    public function __construct(private readonly ?string $id = null) {}
+
+    /**
+     * Gets element ID.
+     *
+     * @return string Element ID
+     * @throws InvalidArgumentException If no ID is set
+     */
+    public function getId(): string {
+        if ($this->id === null) {
+            throw new InvalidArgumentException("Element has no ID.");
+        }
+        return $this->id;
+    }
+    
+    /**
+     * Checks if element has an ID.
+     *
+     * @return bool True if has ID
+     */
+    public function hasId(): bool {
+        return $this->id !== null;
+    }
+    
+    /**
+     * Checks if element holds a value.
+     *
+     * @return bool True if element has value
+     */
+    public function hasValue(): bool {
+        return true;
+    }
+
+    /**
+     * Serializes element for JSON.
+     *
+     * @return array Serialized data
+     */
+    abstract public function jsonSerialize(): array;
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/ElementCollection.php b/src/imperazim/form/custom/elements/ElementCollection.php
new file mode 100644
index 0000000..3937124
--- /dev/null
+++ b/src/imperazim/form/custom/elements/ElementCollection.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+use ArrayAccess;
+use Countable;
+use IteratorAggregate;
+use Traversable;
+use RuntimeException;
+
+/**
+* Immutable collection of form elements.
+*/
+final class ElementCollection implements ArrayAccess, IteratorAggregate, Countable {
+  /** @var Element[] Element storage */
+  private array $elements = [];
+
+  /**
+  * Adds an element to the collection.
+  *
+  * @param Element $element Element to add
+  */
+  public function add(Element $element): void {
+    $this->elements[] = $element;
+  }
+
+  /**
+  * Creates collection from array.
+  *
+  * @param Element[] $elements Elements array
+  * @return self New collection
+  */
+  public static function fromArray(array $elements): self {
+    $collection = new self();
+    $collection->elements = $elements;
+    return $collection;
+  }
+
+  /**
+  * Gets element by index.
+  *
+  * @param int $index Element position
+  * @return Element|null Element or null
+  */
+  public function getByIndex(int $index): ?Element {
+    return $this->elements[$index] ?? null;
+  }
+
+  /**
+  * Counts elements in collection.
+  *
+  * @return int Element count
+  */
+  public function count(): int {
+    return count($this->elements);
+  }
+
+  /**
+  * Gets iterator for elements.
+  *
+  * @return Traversable<Element> Element iterator
+  */
+  public function getIterator(): Traversable {
+    yield from $this->elements;
+  }
+
+  /**
+  * Checks if offset exists.
+  *
+  * @param mixed $offset Offset to check
+  * @return bool Existence status
+  */
+  public function offsetExists(mixed $offset): bool {
+    return isset($this->elements[$offset]);
+  }
+
+  /**
+  * Gets element by offset.
+  *
+  * @param mixed $offset Element position
+  * @return Element|null Element or null
+  */
+  public function offsetGet(mixed $offset): ?Element {
+    return $this->elements[$offset] ?? null;
+  }
+
+  /**
+  * Disabled setter (immutable).
+  *
+  * @throws RuntimeException Always
+  */
+  public function offsetSet(mixed $offset, mixed $value): void {
+    throw new RuntimeException('ElementCollection is immutable');
+  }
+
+  /**
+  * Disabled unsetter (immutable).
+  *
+  * @throws RuntimeException Always
+  */
+  public function offsetUnset(mixed $offset): void {
+    throw new RuntimeException('ElementCollection is immutable');
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Input.php b/src/imperazim/form/custom/elements/Input.php
new file mode 100644
index 0000000..d6f15bf
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Input.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+/**
+* Represents an input field element.
+*/
+final class Input extends Element {
+  /**
+  * @param string $id Element ID
+  * @param string $text Label text
+  * @param string $placeholder Placeholder text
+  * @param string $default Default value
+  */
+  public function __construct(
+    private string $id,
+    private string $text,
+    private string $placeholder = '',
+    private string $default = ''
+  ) {
+    parent::__construct($id);
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'input',
+      'text' => $this->text,
+      'placeholder' => $this->placeholder,
+      'default' => $this->default
+      ];
+    }
+  }
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Label.php b/src/imperazim/form/custom/elements/Label.php
new file mode 100644
index 0000000..4407a47
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Label.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+use Ramsey\Uuid\Uuid;
+
+/**
+* Represents a label element (non-interactive text).
+*/
+final class Label extends Element {
+  /**
+  * @param string $text Display text
+  */
+  public function __construct(private string $text) {
+    parent::__construct(Uuid::uuid4()->toString());
+  }
+
+  /**
+  * Checks if element holds a value.
+  *
+  * @return bool Always false for labels
+  */
+  public function hasValue(): bool {
+    return false;
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'label',
+      'text' => $this->text
+    ];
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Option.php b/src/imperazim/form/custom/elements/Option.php
new file mode 100644
index 0000000..c7a25fd
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Option.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+/**
+* Represents a selectable option.
+*/
+final class Option {
+  /**
+  * @param string $id Option identifier
+  * @param string $text Display text
+  */
+  public function __construct(
+    private string $id,
+    private string $text
+  ) {}
+
+  /**
+  * Gets option ID.
+  *
+  * @return string Option ID
+  */
+  public function getId(): string {
+    return $this->id;
+  }
+
+  /**
+  * Gets display text.
+  *
+  * @return string Display text
+  */
+  public function getText(): string {
+    return $this->text;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Slider.php b/src/imperazim/form/custom/elements/Slider.php
new file mode 100644
index 0000000..3b63681
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Slider.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+/**
+* Represents a slider element.
+*/
+final class Slider extends Element {
+  /**
+  * @param string $id Element ID
+  * @param string $text Label text
+  * @param int $min Minimum value
+  * @param int $max Maximum value
+  * @param int $step Step value
+  * @param int $default Default value
+  */
+  public function __construct(
+    private string $id,
+    private string $text,
+    private int $min,
+    private int $max,
+    private int $step,
+    private int $default
+  ) {
+    parent::__construct($id);
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'slider',
+      'text' => $this->text,
+      'min' => $this->min,
+      'max' => $this->max,
+      'step' => $this->step,
+      'default' => $this->default
+      ];
+    }
+  }
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/StepSlider.php b/src/imperazim/form/custom/elements/StepSlider.php
new file mode 100644
index 0000000..aa0c1fb
--- /dev/null
+++ b/src/imperazim/form/custom/elements/StepSlider.php
@@ -0,0 +1,120 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+use imperazim\form\custom\response\SelectedOption;
+
+/**
+* Represents a step slider element.
+*/
+final class StepSlider extends Element {
+  /** @var Option[] Available steps */
+  private array $steps;
+
+  /** @var int Default step index */
+  private int $defaultIndex;
+
+  /**
+  * @param string $id Element ID
+  * @param string $text Label text
+  * @param array $steps Steps array
+  * @param string|int $default Default selection
+  */
+  public function __construct(
+    private string $id,
+    private string $text,
+    array $steps,
+    string|int $default = 0
+  ) {
+    parent::__construct($id);
+    $this->steps = $this->normalizeSteps($steps);
+    $this->defaultIndex = $this->findStepIndex($default);
+  }
+
+  /**
+  * Normalizes steps array.
+  *
+  * @param array $steps Raw steps
+  * @return Option[] Normalized steps
+  */
+  private function normalizeSteps(array $steps): array {
+    $normalized = [];
+    foreach ($steps as $key => $value) {
+      if ($value instanceof Option) {
+        $normalized[] = $value;
+      } elseif (is_array($value)) {
+        $normalized[] = new Option(
+          (string)($value['id'] ?? $key),
+          (string)($value['text'] ?? '')
+        );
+      } else {
+        $normalized[] = new Option((string)$key, (string)$value);
+      }
+    }
+    return $normalized;
+  }
+
+  /**
+  * Finds step index by ID or value.
+  *
+  * @param string|int $default Default identifier
+  * @return int Step index
+  */
+  private function findStepIndex(string|int $default): int {
+    if (is_int($default)) {
+      return $default;
+    }
+
+    foreach ($this->steps as $index => $step) {
+      if ($step->getId() === $default) {
+        return $index;
+      }
+    }
+    return 0;
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'step_slider',
+      'text' => $this->text,
+      'steps' => array_map(fn(Option $s) => $s->getText(), $this->steps),
+      'default' => $this->defaultIndex
+    ];
+  }
+
+  /**
+  * Gets step by index.
+  *
+  * @param int $index Step position
+  * @return Option|null Step or null
+  */
+  public function getStepByIndex(int $index): ?Option {
+    return $this->steps[$index] ?? null;
+  }
+
+  /**
+  * Gets selected step.
+  *
+  * @param int $index Selected index
+  * @return SelectedOption|null Selected step or null
+  */
+  public function getSelectedStep(int $index): ?SelectedOption {
+    $step = $this->getStepByIndex($index);
+    if ($step === null) {
+      return null;
+    }
+
+    return new SelectedOption(
+      $index,
+      $step->getId(),
+      $step->getText()
+    );
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/elements/Toggle.php b/src/imperazim/form/custom/elements/Toggle.php
new file mode 100644
index 0000000..88ed47d
--- /dev/null
+++ b/src/imperazim/form/custom/elements/Toggle.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\elements;
+
+/**
+* Represents a toggle switch element.
+*/
+final class Toggle extends Element {
+  /**
+  * @param string $id Element ID
+  * @param string $text Label text
+  * @param bool $default Default state
+  */
+  public function __construct(
+    private string $id,
+    private string $text,
+    private bool $default = false
+  ) {
+    parent::__construct($id);
+  }
+
+  /**
+  * Serializes element for JSON.
+  *
+  * @return array Serialized data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => 'toggle',
+      'text' => $this->text,
+      'default' => $this->default
+      ];
+    }
+  }
\ No newline at end of file
diff --git a/src/imperazim/form/custom/response/CustomResponse.php b/src/imperazim/form/custom/response/CustomResponse.php
new file mode 100644
index 0000000..99c9aaf
--- /dev/null
+++ b/src/imperazim/form/custom/response/CustomResponse.php
@@ -0,0 +1,223 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\response;
+
+use imperazim\form\FormData;
+use imperazim\form\custom\elements\Element;
+use imperazim\form\custom\elements\Dropdown;
+use imperazim\form\custom\elements\StepSlider;
+use InvalidArgumentException;
+
+/**
+* Represents a custom form response.
+*/
+final class CustomResponse {
+  /**
+  * @param FormData $data Form data
+  * @param array<int,mixed> $raw Raw response data
+  * @param array<string,mixed> $idMap ID-value mapping
+  * @param array<string,Element> $elementMap Element mapping
+  */
+  public function __construct(
+    private FormData $data,
+    private array $raw,
+    private array $idMap = [],
+    private array $elementMap = []
+  ) {
+    if (empty($raw)) {
+      throw new InvalidArgumentException("Raw data must be array");
+    }
+  }
+
+  /**
+  * Gets form data.
+  *
+  * @return FormData Requested data
+  */
+  public function getFormData(): FormData {
+    return $this->data;
+  }
+
+  /**
+  * Gets element value by ID.
+  *
+  * @param string $id Element ID
+  * @return mixed Element value
+  * @throws InvalidArgumentException If ID not found
+  */
+  public function getElement(string $id): mixed {
+    if (!array_key_exists($id, $this->idMap)) {
+      throw new InvalidArgumentException("ID '{$id}' not found.");
+    }
+    return $this->idMap[$id];
+  }
+
+  /**
+  * Gets raw response data.
+  *
+  * @return array Raw data
+  */
+  public function getElementsRaw(): array {
+    return $this->raw;
+  }
+
+  /**
+  * Gets string value.
+  *
+  * @param string $id Element ID
+  * @param string|null $default Default value
+  * @return string|null String value or default
+  */
+  public function getString(string $id, ?string $default = null): ?string {
+    try {
+      $value = $this->getElement($id);
+      return $value === null ? $default : (string)$value;
+    } catch (InvalidArgumentException) {
+      return $default;
+    }
+  }
+
+  /**
+  * Gets integer value.
+  *
+  * @param string $id Element ID
+  * @param int|null $default Default value
+  * @return int|null Integer value or default
+  */
+  public function getInt(string $id, ?int $default = null): ?int {
+    try {
+      $value = $this->getElement($id);
+      return $value === null ? $default : (int)$value;
+    } catch (InvalidArgumentException) {
+      return $default;
+    }
+  }
+
+  /**
+  * Gets boolean value.
+  *
+  * @param string $id Element ID
+  * @param bool|null $default Default value
+  * @return bool|null Boolean value or default
+  */
+  public function getBool(string $id, ?bool $default = null): ?bool {
+    try {
+      $value = $this->getElement($id);
+      return $value === null ? $default : (bool)$value;
+    } catch (InvalidArgumentException) {
+      return $default;
+    }
+  }
+
+  /**
+  * Gets float value.
+  *
+  * @param string $id Element ID
+  * @param float|null $default Default value
+  * @return float|null Float value or default
+  */
+  public function getFloat(string $id, ?float $default = null): ?float {
+    try {
+      $value = $this->getElement($id);
+      return $value === null ? $default : (float)$value;
+    } catch (InvalidArgumentException) {
+      return $default;
+    }
+  }
+
+  /**
+  * Gets array value.
+  *
+  * @param string $id Element ID
+  * @param array|null $default Default value
+  * @return array|null Array value or default
+  */
+  public function getArray(string $id, ?array $default = null): ?array {
+    try {
+      $value = $this->getElement($id);
+      return is_array($value) ? $value : $default;
+    } catch (InvalidArgumentException) {
+      return $default;
+    }
+  }
+
+  /**
+  * Gets toggle value.
+  *
+  * @param string $id Element ID
+  * @return bool Toggle value
+  */
+  public function getToggle(string $id): bool {
+    return (bool) $this->getElement($id);
+  }
+
+  /**
+  * Gets input value.
+  *
+  * @param string $id Element ID
+  * @return string Input value
+  */
+  public function getInput(string $id): string {
+    return (string) $this->getElement($id);
+  }
+
+  /**
+  * Gets slider value.
+  *
+  * @param string $id Element ID
+  * @return float Slider value
+  */
+  public function getSlider(string $id): float {
+    return (float) $this->getElement($id);
+  }
+
+  /**
+  * Gets dropdown selection.
+  *
+  * @param string $id Element ID
+  * @return SelectedOption Selected option
+  * @throws InvalidArgumentException If element not dropdown
+  */
+  public function getDropdown(string $id): SelectedOption {
+    $index = (int) $this->getElement($id);
+    $element = $this->elementMap[$id] ?? null;
+
+    if (!$element instanceof Dropdown) {
+      throw new InvalidArgumentException("Element with ID {$id} is not a Dropdown.");
+    }
+
+    $selected = $element->getSelectedOption($index);
+    return $selected ?? new SelectedOption($index, (string)$index, 'Unknown');
+  }
+
+  /**
+  * Gets step slider selection.
+  *
+  * @param string $id Element ID
+  * @return SelectedOption Selected step
+  * @throws InvalidArgumentException If element not step slider
+  */
+  public function getStepSlider(string $id): SelectedOption {
+    $index = (int) $this->getElement($id);
+    $element = $this->elementMap[$id] ?? null;
+
+    if (!$element instanceof StepSlider) {
+      throw new InvalidArgumentException("Element with ID {$id} is not a StepSlider.");
+    }
+
+    $selected = $element->getSelectedStep($index);
+    return $selected ?? new SelectedOption($index, (string)$index, 'Unknown');
+  }
+
+  /**
+  * Checks if element exists in response.
+  *
+  * @param string $id Element ID
+  * @return bool True if exists
+  */
+  public function has(string $id): bool {
+    return array_key_exists($id, $this->idMap);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/custom/response/SelectedOption.php b/src/imperazim/form/custom/response/SelectedOption.php
new file mode 100644
index 0000000..b87942c
--- /dev/null
+++ b/src/imperazim/form/custom/response/SelectedOption.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\custom\response;
+
+/**
+* Represents a selected option in a form element.
+*/
+final class SelectedOption {
+  /**
+  * @param int $index Option index
+  * @param string $id Option ID
+  * @param string $text Display text
+  */
+  public function __construct(
+    private int $index,
+    private string $id,
+    private string $text
+  ) {}
+
+  /**
+  * Gets option index.
+  *
+  * @return int Option index
+  */
+  public function getIndex(): int {
+    return $this->index;
+  }
+
+  /**
+  * Gets option ID.
+  *
+  * @return string Option ID
+  */
+  public function getId(): string {
+    return $this->id;
+  }
+
+  /**
+  * Gets display text.
+  *
+  * @return string Display text
+  */
+  public function getText(): string {
+    return $this->text;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/DynamicLongForm.php b/src/imperazim/form/long/DynamicLongForm.php
new file mode 100644
index 0000000..e165ce8
--- /dev/null
+++ b/src/imperazim/form/long/DynamicLongForm.php
@@ -0,0 +1,219 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long;
+
+use Closure;
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\base\elements\Content;
+use imperazim\form\long\elements\Button;
+use imperazim\form\long\elements\ButtonTexture;
+use imperazim\form\long\elements\ButtonCollection;
+use imperazim\form\long\response\ButtonResponse;
+
+/**
+* Dynamic implementation of a long form with fluent interface.
+*/
+final class DynamicLongForm extends Form {
+  /** @var Content Form content */
+  private Content $content;
+
+  /** @var ButtonCollection Button collection */
+  private ButtonCollection $buttons;
+
+  /** @var Closure Close handler */
+  private Closure $onClose;
+
+  /**
+  * Constructs a dynamic form.
+  *
+  * @param Title $title Form title
+  */
+  public function __construct(Title $title) {
+    parent::__construct($title);
+    $this->content = new Content("");
+    $this->buttons = new ButtonCollection();
+    $this->onClose = fn(Player $player) => FormResult::CLOSE;
+  }
+
+  /**
+  * Creates a new form instance.
+  *
+  * @param string|Title $title Form title
+  * @return self New form instance
+  */
+  final public static function create(string|Title $title): self {
+    return new self($title instanceof Title ? $title : new Title($title));
+  }
+
+  /**
+  * Builds a form using a configuration closure.
+  *
+  * @param string|Title $title Form title
+  * @param Closure $configurator Configuration callback
+  * @return self Configured form instance
+  */
+  final public static function build(string|Title $title, Closure $configurator): self {
+    $form = self::create($title);
+    $configurator($form);
+    return $form;
+  }
+
+  /**
+  * Sets form content.
+  *
+  * @param string|Content $content Form content
+  * @return self
+  */
+  public function setContent(string|Content $content): self {
+    $this->content = $content instanceof Content ? $content : new Content($content);
+    return $this;
+  }
+
+  /**
+  * Gets current content.
+  *
+  * @return Content Current content
+  */
+  public function getContent(): Content {
+    return $this->content;
+  }
+
+  /**
+  * Sets button collection.
+  *
+  * @param ButtonCollection $buttons Button collection
+  * @return self
+  */
+  public function setButtons(ButtonCollection $buttons): self {
+    $this->buttons = $buttons;
+    return $this;
+  }
+
+  /**
+  * Gets button collection.
+  *
+  * @return ButtonCollection Current buttons
+  */
+  public function getButtons(): ButtonCollection {
+    return $this->buttons;
+  }
+
+  /**
+  * Adds a button to the form.
+  *
+  * @param Button|string $button Button instance or text
+  * @param ButtonTexture|string|array|null $image Button image
+  * @param Closure|null $handler Click handler
+  * @return self
+  */
+  public function addButton(
+    Button|string $button,
+    ButtonTexture|string|array|null $image = null,
+    ?Closure $handler = null
+  ): self {
+    if ($button instanceof Button) {
+      $this->buttons->add($button);
+      return $this;
+    }
+
+    $img = $this->processImage($image);
+    $response = new ButtonResponse($handler ?? fn(Player $p) => FormResult::CLOSE);
+    $this->buttons->add(new Button($button, $img, $response));
+
+    return $this;
+  }
+
+  /**
+  * Processes image parameter.
+  *
+  * @param ButtonTexture|string|array|null $image Image data
+  * @return ButtonTexture Processed texture
+  */
+  private function processImage(ButtonTexture|string|array|null $image): ButtonTexture {
+    if ($image instanceof ButtonTexture) {
+      return $image;
+    }
+
+    $type = ButtonTexture::PATH;
+    $data = '';
+
+    if (is_array($image)) {
+      $type = $image['type'] ?? $type;
+      $data = $image['data'] ?? $data;
+    } elseif (is_string($image)) {
+      $data = $image;
+      $type = filter_var($data, FILTER_VALIDATE_URL) ? ButtonTexture::URL : ButtonTexture::PATH;
+    }
+
+    return new ButtonTexture($data, $type);
+  }
+
+  /**
+  * Sets close handler.
+  *
+  * @param Closure $handler Close handler
+  * @return self
+  */
+  public function setOnClose(Closure $handler): self {
+    $this->onClose = $handler;
+    return $this;
+  }
+
+  /**
+  * Gets close handler.
+  *
+  * @return Closure Current handler
+  */
+  public function getOnClose(): Closure {
+    return $this->onClose;
+  }
+
+  /**
+  * Gets form type.
+  *
+  * @return string Form type identifier
+  */
+  protected function getFormType(): string {
+    return "form";
+  }
+
+  /**
+  * Serializes form data.
+  *
+  * @return array Serialized form data
+  */
+  protected function serializeFormData(): array {
+    return [
+      'content' => $this->content->getText(),
+      'buttons' => array_map(
+        fn($button) => $button->jsonSerialize(),
+        iterator_to_array($this->buttons)
+      )
+    ];
+  }
+
+  /**
+  * Handles form response.
+  *
+  * @param Player $player Responding player
+  * @param mixed $data Response data
+  */
+  public function handleResponse(Player $player, $data): void {
+    if ($data === null) {
+      $result = ($this->onClose)($player);
+    } elseif (is_int($data) && ($button = $this->buttons[$data] ?? null)) {
+      $result = $button->getResponse()->handle($player);
+    } else {
+      $result = FormResult::CLOSE;
+    }
+
+    if ($result === FormResult::KEEP) {
+      $this->sendTo($player);
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/LongForm.php b/src/imperazim/form/long/LongForm.php
new file mode 100644
index 0000000..60c9995
--- /dev/null
+++ b/src/imperazim/form/long/LongForm.php
@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long;
+
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormData;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\base\elements\Content;
+use imperazim\form\long\elements\ButtonCollection;
+
+/**
+* Abstract base class for long (simple) forms.
+*/
+abstract class LongForm extends Form {
+  /** @var FormData Form data container */
+  private FormData $formData;
+
+  /**
+  * Constructs a new LongForm instance.
+  *
+  * @param Player $player The player to whom the form is sent.
+  * @param array|FormData $data Additional form data.
+  * @param bool $force Whether to immediately send the form.
+  */
+  public function __construct(
+    private readonly Player $player,
+    array|FormData $data = [],
+    private readonly bool $force = false
+  ) {
+    $this->formData = $data instanceof FormData ? $data : new FormData($data);
+    parent::__construct($this->title($player, $this->formData));
+
+    if ($force) {
+      $this->sendTo($player);
+    }
+  }
+
+  /**
+  * Gets the form title.
+  *
+  * @param Player $player The player viewing the form.
+  * @param FormData $data Form data container.
+  * @return Title The title element.
+  */
+  abstract protected function title(Player $player, FormData $data): Title;
+
+  /**
+  * Gets the form content.
+  *
+  * @param Player $player The player viewing the form.
+  * @param FormData $data Form data container.
+  * @return Content The content element.
+  */
+  abstract protected function content(Player $player, FormData $data): Content;
+
+  /**
+  * Gets the button collection.
+  *
+  * @param Player $player The player viewing the form.
+  * @param FormData $data Form data container.
+  * @return ButtonCollection The button collection.
+  */
+  abstract protected function buttons(Player $player, FormData $data): ButtonCollection;
+
+  /**
+  * Handles form closure.
+  *
+  * @param Player $player The player who closed the form.
+  * @param FormData $data Form data container.
+  * @return FormResult The result controlling form behavior.
+  */
+  protected function onClose(Player $player, FormData $data): FormResult {
+    return FormResult::CLOSE;
+  }
+
+  /**
+  * Returns the form type.
+  *
+  * @return string The form type identifier.
+  */
+  protected function getFormType(): string {
+    return "form";
+  }
+
+  /**
+  * Serializes form data for UI rendering.
+  *
+  * @return array The serialized form data.
+  */
+  protected function serializeFormData(): array {
+    return [
+      'content' => $this->content($this->player, $this->formData)->getText(),
+      'buttons' => array_map(
+        fn($button) => $button->jsonSerialize(),
+        iterator_to_array($this->buttons($this->player, $this->formData))
+      )
+    ];
+  }
+
+  /**
+  * Handles form responses.
+  *
+  * @param Player $player The responding player.
+  * @param mixed $raw The raw response data.
+  */
+  public function handleResponse(Player $player, $raw): void {
+    if ($raw === null) {
+      $result = $this->onClose($player, $this->formData);
+    } elseif (is_int($raw)) {
+      $button = $this->buttons($player, $this->formData)[$raw] ?? null;
+      $result = $button ? $button->getResponse()->handle($player) : FormResult::CLOSE;
+    } else {
+      return;
+    }
+
+    if ($result === FormResult::KEEP) {
+      $this->sendTo($player);
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/elements/Button.php b/src/imperazim/form/long/elements/Button.php
new file mode 100644
index 0000000..7b93b2b
--- /dev/null
+++ b/src/imperazim/form/long/elements/Button.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long\elements;
+
+use JsonSerializable;
+use imperazim\form\long\elements\ButtonTexture;
+use imperazim\form\long\response\ButtonResponse;
+
+/**
+* Represents a form button.
+*/
+final class Button implements JsonSerializable {
+  /**
+  * @param string $text Button text
+  * @param ButtonTexture $image Button image
+  * @param ButtonResponse $response Click handler
+  */
+  public function __construct(
+    private readonly string $text,
+    private readonly ButtonTexture $image,
+    private readonly ButtonResponse $response
+  ) {}
+
+  /**
+  * Gets button text.
+  *
+  * @return string Button text
+  */
+  public function getText(): string {
+    return $this->text;
+  }
+
+  /**
+  * Gets button texture.
+  *
+  * @return ButtonTexture Button image
+  */
+  public function getTexture(): ButtonTexture {
+    return $this->image;
+  }
+
+  /**
+  * Gets button response handler.
+  *
+  * @return ButtonResponse Response handler
+  */
+  public function getResponse(): ButtonResponse {
+    return $this->response;
+  }
+
+  /**
+  * Serializes button for JSON.
+  *
+  * @return array Serialized button data
+  */
+  public function jsonSerialize(): array {
+    return [
+      'text' => $this->text,
+      'image' => $this->image->jsonSerialize()
+    ];
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/elements/ButtonCollection.php b/src/imperazim/form/long/elements/ButtonCollection.php
new file mode 100644
index 0000000..4097ad2
--- /dev/null
+++ b/src/imperazim/form/long/elements/ButtonCollection.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long\elements;
+
+use ArrayAccess;
+use Countable;
+use IteratorAggregate;
+use Traversable;
+use RuntimeException;
+use InvalidArgumentException;
+
+/**
+* Immutable collection of form buttons.
+*/
+final class ButtonCollection implements ArrayAccess, IteratorAggregate, Countable {
+  /** @var Button[] Button storage */
+  private array $buttons = [];
+
+  /**
+  * Adds a button to the collection.
+  *
+  * @param Button $button Button to add
+  */
+  public function add(Button $button): void {
+    $this->buttons[] = $button;
+  }
+
+  /**
+  * Creates collection from array.
+  *
+  * @param Button[] $buttons Button array
+  * @return self New collection
+  */
+  public static function fromArray(array $buttons): self {
+    $collection = new self();
+    $collection->buttons = $buttons;
+    return $collection;
+  }
+
+  /**
+  * Gets button by index.
+  *
+  * @param int $index Button position
+  * @return Button|null Button or null
+  */
+  public function getByIndex(int $index): ?Button {
+    return $this->buttons[$index] ?? null;
+  }
+
+  /**
+  * Counts buttons in collection.
+  *
+  * @return int Number of buttons
+  */
+  public function count(): int {
+    return count($this->buttons);
+  }
+
+  /**
+  * Gets iterator for buttons.
+  *
+  * @return Traversable<Button> Button iterator
+  */
+  public function getIterator(): Traversable {
+    yield from $this->buttons;
+  }
+
+  /**
+  * Checks if offset exists.
+  *
+  * @param mixed $offset Offset to check
+  * @return bool Existence status
+  */
+  public function offsetExists(mixed $offset): bool {
+    return isset($this->buttons[$offset]);
+  }
+
+  /**
+  * Gets button by offset.
+  *
+  * @param mixed $offset Button position
+  * @return Button|null Button or null
+  */
+  public function offsetGet(mixed $offset): ?Button {
+    return $this->buttons[$offset] ?? null;
+  }
+
+  /**
+  * Disabled setter (immutable).
+  *
+  * @throws RuntimeException Always
+  */
+  public function offsetSet(mixed $offset, mixed $value): void {
+    throw new RuntimeException('ButtonCollection is immutable');
+  }
+
+  /**
+  * Disabled unsetter (immutable).
+  *
+  * @throws RuntimeException Always
+  */
+  public function offsetUnset(mixed $offset): void {
+    throw new RuntimeException('ButtonCollection is immutable');
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/elements/ButtonTexture.php b/src/imperazim/form/long/elements/ButtonTexture.php
new file mode 100644
index 0000000..e174e03
--- /dev/null
+++ b/src/imperazim/form/long/elements/ButtonTexture.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long\elements;
+
+use JsonSerializable;
+use InvalidArgumentException;
+
+/**
+* Represents a button texture.
+*/
+final class ButtonTexture implements JsonSerializable {
+  /** @var string Local file path type */
+  public const PATH = 'path';
+
+  /** @var string Remote URL type */
+  public const URL = 'url';
+
+  /**
+  * @param string $texture Texture path/URL
+  * @param string $type Texture type (PATH/URL)
+  * @throws InvalidArgumentException For invalid types
+  */
+  public function __construct(
+    private readonly string $texture,
+    private readonly string $type = self::PATH
+  ) {
+    if (!in_array($type, [self::PATH, self::URL], true)) {
+      throw new InvalidArgumentException("Invalid image type: $type");
+    }
+  }
+
+  /**
+  * Gets the texture source.
+  *
+  * @return string The texture path/URL.
+  */
+  public function getTexture(): string {
+    return $this->texture;
+  }
+
+  /**
+  * Gets the texture type.
+  *
+  * @return string The texture type constant.
+  */
+  public function getType(): string {
+    return $this->type;
+  }
+
+  /**
+  * Serializes the object for JSON.
+  *
+  * @return array The serialized data.
+  */
+  public function jsonSerialize(): array {
+    return [
+      'type' => $this->type,
+      'data' => $this->texture
+    ];
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/long/response/ButtonResponse.php b/src/imperazim/form/long/response/ButtonResponse.php
new file mode 100644
index 0000000..353b5ac
--- /dev/null
+++ b/src/imperazim/form/long/response/ButtonResponse.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\long\response;
+
+use pocketmine\player\Player;
+use imperazim\form\FormResult;
+
+/**
+* Handles button click responses.
+*/
+final class ButtonResponse {
+  /**
+  * @param \Closure $handler Response handler function
+  */
+  public function __construct(private \Closure $handler) {}
+
+  /**
+  * Executes the response handler.
+  *
+  * @param Player $player Clicking player
+  * @return FormResult Form behavior result
+  */
+  public function handle(Player $player): FormResult {
+    return ($this->handler)($player);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/modal/DynamicModalForm.php b/src/imperazim/form/modal/DynamicModalForm.php
new file mode 100644
index 0000000..5b1ae57
--- /dev/null
+++ b/src/imperazim/form/modal/DynamicModalForm.php
@@ -0,0 +1,161 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\modal;
+
+use Closure;
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\base\elements\Content;
+use imperazim\form\modal\response\ModalResponse;
+
+/**
+* Dynamic implementation of a modal form.
+*/
+final class DynamicModalForm extends Form {
+  /** @var Content Form content */
+  private Content $content;
+
+  /** @var string First button text */
+  private string $button1Text = 'Yes';
+
+  /** @var string Second button text */
+  private string $button2Text = 'No';
+
+  /** @var Closure Confirmation handler */
+  private Closure $onConfirm;
+
+  /** @var Closure Cancellation handler */
+  private Closure $onCancel;
+
+  /** @var Closure Closure handler */
+  private Closure $onClose;
+
+  /**
+  * Constructs the dynamic form.
+  *
+  * @param Title $title Form title
+  */
+  public function __construct(Title $title) {
+    parent::__construct($title);
+    $this->content = new Content('');
+    $this->onConfirm = fn(Player $p, ModalResponse $r): FormResult => FormResult::CLOSE;
+    $this->onCancel = fn(Player $p, ModalResponse $r): FormResult => FormResult::CLOSE;
+    $this->onClose = fn(Player $p, $d): FormResult => FormResult::CLOSE;
+  }
+
+  /**
+  * Creates a new form instance.
+  *
+  * @param string|Title $title Form title
+  * @return self New instance
+  */
+  public static function create(string|Title $title): self {
+    return new self($title instanceof Title ? $title : new Title($title));
+  }
+
+  /**
+  * Builds a form using configuration closure.
+  *
+  * @param string|Title $title Form title
+  * @param Closure $configurator Configuration callback
+  * @return self Configured instance
+  */
+  final public static function build(string|Title $title, Closure $configurator): self {
+    $form = self::create($title);
+    $configurator($form);
+    return $form;
+  }
+
+  /**
+  * Sets form content.
+  *
+  * @param string|Content $content Form content
+  * @return self
+  */
+  public function setContent(string|Content $content): self {
+    $this->content = $content instanceof Content ? $content : new Content($content);
+    return $this;
+  }
+
+  /**
+  * Configures first button.
+  *
+  * @param string $text Button text
+  * @param Closure $handler Click handler
+  * @return self
+  */
+  public function setButton1(string $text, Closure $handler): self {
+    $this->button1Text = $text;
+    $this->onConfirm = $handler;
+    return $this;
+  }
+
+  /**
+  * Configures second button.
+  *
+  * @param string $text Button text
+  * @param Closure $handler Click handler
+  * @return self
+  */
+  public function setButton2(string $text, Closure $handler): self {
+    $this->button2Text = $text;
+    $this->onCancel = $handler;
+    return $this;
+  }
+
+  /**
+  * Sets close handler.
+  *
+  * @param Closure $handler Close handler
+  * @return self
+  */
+  public function setOnClose(Closure $handler): self {
+    $this->onClose = $handler;
+    return $this;
+  }
+
+  /**
+  * Gets form type.
+  *
+  * @return string Form type identifier
+  */
+  protected function getFormType(): string {
+    return 'modal';
+  }
+
+  /**
+  * Serializes form data.
+  *
+  * @return array Serialized data
+  */
+  public function serializeFormData(): array {
+    return [
+      'content' => $this->content->getText(),
+      'button1' => $this->button1Text,
+      'button2' => $this->button2Text,
+    ];
+  }
+
+  /**
+  * Handles form response.
+  *
+  * @param Player $player Responding player
+  * @param mixed $data Response data
+  */
+  public function handleResponse(Player $player, $data): void {
+    $result = match(true) {
+      $data === null => ($this->onClose)($player, $this->content),
+      $data === true => ($this->onConfirm)($player, ModalResponse::from(true)),
+      $data === false => ($this->onCancel)($player, ModalResponse::from(false)),
+      default => FormResult::CLOSE
+      };
+
+      if ($result === FormResult::KEEP) {
+        $this->sendTo($player);
+      }
+    }
+  }
\ No newline at end of file
diff --git a/src/imperazim/form/modal/ModalForm.php b/src/imperazim/form/modal/ModalForm.php
new file mode 100644
index 0000000..5b99896
--- /dev/null
+++ b/src/imperazim/form/modal/ModalForm.php
@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\modal;
+
+use pocketmine\player\Player;
+use imperazim\form\Form;
+use imperazim\form\FormData;
+use imperazim\form\FormResult;
+use imperazim\form\base\elements\Title;
+use imperazim\form\base\elements\Content;
+use imperazim\form\modal\elements\ModalButton;
+
+/**
+* Abstract base class for modal forms.
+*/
+abstract class ModalForm extends Form {
+  /** @var FormData Form data container */
+  private FormData $formData;
+
+  /** @var Player Target player */
+  private Player $player;
+
+  /** @var bool Whether to force send */
+  private bool $force;
+
+  /**
+  * Constructs the modal form.
+  *
+  * @param Player $player Target player
+  * @param array|FormData $data Form data
+  * @param bool $force Whether to force send
+  */
+  public function __construct(
+    Player $player,
+    array|FormData $data = [],
+    bool $force = false
+  ) {
+    $this->player = $player;
+    $this->force = $force;
+    $this->formData = $data instanceof FormData ? $data : new FormData($data);
+
+    parent::__construct($this->title($player, $this->formData));
+
+    if ($force) {
+      $this->sendTo($player);
+    }
+  }
+
+  /**
+  * Gets form title.
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return Title Title element
+  */
+  abstract protected function title(Player $player, FormData $data): Title;
+
+  /**
+  * Gets form content.
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return Content Content element
+  */
+  abstract protected function content(Player $player, FormData $data): Content;
+
+  /**
+  * Gets first button (confirmation).
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return ModalButton Button element
+  */
+  abstract protected function button1(Player $player, FormData $data): ModalButton;
+
+  /**
+  * Gets second button (cancellation).
+  *
+  * @param Player $player Viewing player
+  * @param FormData $data Form data
+  * @return ModalButton Button element
+  */
+  abstract protected function button2(Player $player, FormData $data): ModalButton;
+
+  /**
+  * Handles confirmation action.
+  *
+  * @param Player $player Confirming player
+  * @param FormData $data Form data
+  * @return FormResult Action result
+  */
+  abstract protected function onConfirm(Player $player, FormData $data): FormResult;
+
+  /**
+  * Handles cancellation action.
+  *
+  * @param Player $player Canceling player
+  * @param FormData $data Form data
+  * @return FormResult Action result
+  */
+  abstract protected function onCancel(Player $player, FormData $data): FormResult;
+
+  /**
+  * Handles form closure.
+  *
+  * @param Player $player Closing player
+  * @param FormData $data Form data
+  * @return FormResult Action result
+  */
+  protected function onClose(Player $player, FormData $data): FormResult {
+    return FormResult::CLOSE;
+  }
+
+  /**
+  * Gets form type.
+  *
+  * @return string Form type identifier
+  */
+  protected function getFormType(): string {
+    return 'modal';
+  }
+
+  /**
+  * Serializes form data.
+  *
+  * @return array Serialized data
+  */
+  protected function serializeFormData(): array {
+    return [
+      'content' => $this->content($this->player, $this->formData)->getText(),
+      'button1' => $this->button1($this->player, $this->formData)->getText(),
+      'button2' => $this->button2($this->player, $this->formData)->getText(),
+    ];
+  }
+
+  /**
+  * Handles form response.
+  *
+  * @param Player $player Responding player
+  * @param mixed $raw Raw response data
+  */
+  public function handleResponse(Player $player, $raw): void {
+    $result = match(true) {
+      $raw === null => $this->onClose($player, $this->formData),
+      $raw === true => $this->onConfirm($player, $this->formData),
+      $raw === false => $this->onCancel($player, $this->formData),
+      default => FormResult::CLOSE
+      };
+
+      if ($result === FormResult::KEEP) {
+        $this->sendTo($player);
+      }
+    }
+  }
\ No newline at end of file
diff --git a/src/imperazim/form/modal/elements/ModalButton.php b/src/imperazim/form/modal/elements/ModalButton.php
new file mode 100644
index 0000000..fe257ff
--- /dev/null
+++ b/src/imperazim/form/modal/elements/ModalButton.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\modal\elements;
+
+use imperazim\form\modal\result\ModalResult;
+
+/**
+* Represents a button in a modal dialog.
+*/
+final class ModalButton {
+  /**
+  * @param string $text Button display text
+  * @param ModalResult $type Associated result type
+  */
+  private function __construct(
+    private string $text,
+    private ModalResult $type
+  ) {}
+
+  /**
+  * Creates a confirmation button.
+  *
+  * @param string $label Button text
+  * @return self New confirmation button
+  */
+  public static function confirm(string $label = 'Yes'): self {
+    return new self($label, ModalResult::CONFIRM);
+  }
+
+  /**
+  * Creates a cancellation button.
+  *
+  * @param string $label Button text
+  * @return self New cancellation button
+  */
+  public static function cancel(string $label = 'No'): self {
+    return new self($label, ModalResult::CANCEL);
+  }
+
+  /**
+  * Gets button text.
+  *
+  * @return string Display text
+  */
+  public function getText(): string {
+    return $this->text;
+  }
+
+  /**
+  * Gets button result type.
+  *
+  * @return ModalResult Result type
+  */
+  public function getType(): ModalResult {
+    return $this->type;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/modal/response/ModalResponse.php b/src/imperazim/form/modal/response/ModalResponse.php
new file mode 100644
index 0000000..f4ec62b
--- /dev/null
+++ b/src/imperazim/form/modal/response/ModalResponse.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\modal\response;
+
+use imperazim\form\modal\result\ModalResult;
+
+/**
+* Represents a response from a modal dialog.
+*/
+final class ModalResponse {
+  /**
+  * @param ModalResult $result The modal result state
+  */
+  public function __construct(private ModalResult $result) {}
+
+  /**
+  * Creates a response from boolean confirmation status.
+  *
+  * @param bool $confirmed True for confirmation
+  * @return self New ModalResponse instance
+  */
+  public static function from(bool $confirmed): self {
+    return new self($confirmed ? ModalResult::CONFIRM : ModalResult::CANCEL);
+  }
+
+  /**
+  * Checks if response was confirmed.
+  *
+  * @return bool True if confirmed
+  */
+  public function isConfirmed(): bool {
+    return $this->result === ModalResult::CONFIRM;
+  }
+
+  /**
+  * Checks if response was canceled.
+  *
+  * @return bool True if canceled
+  */
+  public function isCanceled(): bool {
+    return $this->result === ModalResult::CANCEL;
+  }
+
+  /**
+  * Gets the modal result.
+  *
+  * @return ModalResult The result state
+  */
+  public function getResult(): ModalResult {
+    return $this->result;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/form/modal/result/ModalResult.php b/src/imperazim/form/modal/result/ModalResult.php
new file mode 100644
index 0000000..09bdbec
--- /dev/null
+++ b/src/imperazim/form/modal/result/ModalResult.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\form\modal\result;
+
+/**
+* Represents the result state of a modal submission.
+*/
+enum ModalResult: string {
+  /** Indicates a confirmation response */
+  case CONFIRM = 'confirm';
+
+    /** Indicates a declension response */
+  case CANCEL = 'cancel';
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/LibPacket.php b/src/imperazim/packet/LibPacket.php
new file mode 100644
index 0000000..34813f6
--- /dev/null
+++ b/src/imperazim/packet/LibPacket.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet;
+
+use pocketmine\plugin\Plugin;
+use pocketmine\plugin\PluginBase;
+use pocketmine\event\EventPriority;
+use pocketmine\network\mcpe\protocol\PacketPool;
+use imperazim\packet\monitor\PacketMonitor;
+use imperazim\packet\monitor\PacketMonitorInterface;
+use imperazim\packet\interceptor\PacketInterceptor;
+use imperazim\packet\interceptor\PacketInterceptorInterface;
+
+final class LibPacket extends PluginBase {
+    /**
+    * Creates a packet interceptor instance.
+    *
+    * @param Plugin $registerer The plugin registering the interceptor
+    * @param int $priority Event priority (default: EventPriority::NORMAL)
+    * @param bool $handleCancelled Whether to handle cancelled events (default: false)
+    *
+    * @return PacketInterceptorInterface Configured packet interceptor
+    *
+    * @throws \InvalidArgumentException If MONITOR priority is used for interception
+    */
+    public static function createInterceptor(
+        Plugin $registerer,
+        int $priority = EventPriority::NORMAL,
+        bool $handleCancelled = false
+    ): PacketInterceptorInterface {
+        return new PacketInterceptor(
+            $registerer,
+            PacketPool::getInstance(),
+            $priority,
+            $handleCancelled
+        );
+    }
+
+    /**
+    * Creates a packet monitor instance.
+    *
+    * @param Plugin $registerer The plugin registering the monitor
+    * @param bool $handleCancelled Whether to handle cancelled events (default: false)
+    *
+    * @return PacketMonitorInterface Configured packet monitor
+    */
+    public static function createMonitor(
+        Plugin $registerer,
+        bool $handleCancelled = false
+    ): PacketMonitorInterface {
+        return new PacketMonitor(
+            $registerer,
+            PacketPool::getInstance(),
+            $handleCancelled
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/handler/PacketHandler.php b/src/imperazim/packet/handler/PacketHandler.php
new file mode 100644
index 0000000..00ca788
--- /dev/null
+++ b/src/imperazim/packet/handler/PacketHandler.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\handler;
+
+use imperazim\packet\utils\TypeValidator;
+
+/**
+* Abstract base class for packet handlers used in interception.
+* Provides common functionality for handling packet IDs.
+*/
+abstract class PacketHandler implements PacketHandlerInterface {
+    /** @var array Packet network IDs this handler manages */
+    protected array $packetIds = [];
+
+    /**
+    * Constructor.
+    *
+    * @param array $packetClasses Array of packet classes to handle
+    */
+    public function __construct(array $packetClasses) {
+        $this->packetIds = TypeValidator::validatePacketClasses($packetClasses);
+    }
+
+    /**
+    * Gets the packet network IDs this handler manages.
+    *
+    * @return array Array of packet network IDs
+    */
+    public function getPacketIds(): array {
+        return $this->packetIds;
+    }
+
+    /**
+    * Handles a packet (must be implemented by concrete classes).
+    *
+    * @param mixed $packet The packet to handle
+    * @param mixed $session The network session
+    *
+    * @return bool Whether to allow the packet to continue processing
+    */
+    abstract public function handle($packet, $session): bool;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/handler/PacketHandlerInterface.php b/src/imperazim/packet/handler/PacketHandlerInterface.php
new file mode 100644
index 0000000..054cf07
--- /dev/null
+++ b/src/imperazim/packet/handler/PacketHandlerInterface.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\handler;
+
+use pocketmine\network\mcpe\NetworkSession;
+
+/**
+* Interface for packet handlers used in interception.
+*/
+interface PacketHandlerInterface {
+    /**
+    * Handles a packet.
+    *
+    * @param mixed $packet The packet to handle
+    * @param NetworkSession $session The network session
+    *
+    * @return bool Whether to allow the packet to continue processing
+    */
+    public function handle($packet, NetworkSession $session): bool;
+
+    /**
+    * Gets the packet network IDs this handler manages.
+    *
+    * @return array Array of packet network IDs
+    */
+    public function getPacketIds(): array;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/handler/PacketMonitorHandler.php b/src/imperazim/packet/handler/PacketMonitorHandler.php
new file mode 100644
index 0000000..8b008ce
--- /dev/null
+++ b/src/imperazim/packet/handler/PacketMonitorHandler.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\handler;
+
+use imperazim\packet\utils\TypeValidator;
+
+/**
+* Abstract base class for packet monitor handlers.
+* Provides common functionality for monitoring packet IDs.
+*/
+abstract class PacketMonitorHandler implements PacketMonitorHandlerInterface {
+    /** @var array Packet network IDs this handler monitors */
+    protected array $packetIds = [];
+
+    /**
+    * Constructor.
+    *
+    * @param array $packetClasses Array of packet classes to monitor
+    */
+    public function __construct(array $packetClasses) {
+        $this->packetIds = TypeValidator::validatePacketClasses($packetClasses);
+    }
+
+    /**
+    * Gets the packet network IDs this handler monitors.
+    *
+    * @return array Array of packet network IDs
+    */
+    public function getPacketIds(): array {
+        return $this->packetIds;
+    }
+
+    /**
+    * Handles a packet (must be implemented by concrete classes).
+    *
+    * @param mixed $packet The packet to handle
+    * @param mixed $session The network session
+    */
+    abstract public function handle($packet, $session): void;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/handler/PacketMonitorHandlerInterface.php b/src/imperazim/packet/handler/PacketMonitorHandlerInterface.php
new file mode 100644
index 0000000..a3face0
--- /dev/null
+++ b/src/imperazim/packet/handler/PacketMonitorHandlerInterface.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\handler;
+
+use pocketmine\network\mcpe\NetworkSession;
+
+/**
+* Interface for packet monitor handlers.
+*/
+interface PacketMonitorHandlerInterface {
+    /**
+    * Handles a packet for monitoring purposes.
+    *
+    * @param mixed $packet The packet to handle
+    * @param NetworkSession $session The network session
+    */
+    public function handle($packet, NetworkSession $session): void;
+
+    /**
+    * Gets the packet network IDs this handler monitors.
+    *
+    * @return array Array of packet network IDs
+    */
+    public function getPacketIds(): array;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/interceptor/PacketInterceptor.php b/src/imperazim/packet/interceptor/PacketInterceptor.php
new file mode 100644
index 0000000..7acde0a
--- /dev/null
+++ b/src/imperazim/packet/interceptor/PacketInterceptor.php
@@ -0,0 +1,197 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\interceptor;
+
+use pocketmine\plugin\Plugin;
+use pocketmine\network\mcpe\protocol\PacketPool;
+use pocketmine\event\server\DataPacketReceiveEvent;
+use pocketmine\event\server\DataPacketSendEvent;
+use pocketmine\event\HandlerListManager;
+use pocketmine\event\RegisteredListener;
+use pocketmine\network\mcpe\NetworkBroadcastUtils;
+use imperazim\packet\handler\PacketHandlerInterface;
+
+/**
+* Packet interception system implementation.
+* Allows intercepting and modifying incoming and outgoing packets.
+*/
+final class PacketInterceptor implements PacketInterceptorInterface {
+    /** @var array Incoming packet handlers grouped by packet ID */
+    private array $incomingHandlers = [];
+
+    /** @var array Outgoing packet handlers grouped by packet ID */
+    private array $outgoingHandlers = [];
+
+    /** @var RegisteredListener|null Incoming packet event listener */
+    private ?RegisteredListener $incomingListener = null;
+
+    /** @var RegisteredListener|null Outgoing packet event listener */
+    private ?RegisteredListener $outgoingListener = null;
+
+    /**
+    * Constructor.
+    *
+    * @param Plugin $plugin The plugin instance
+    * @param PacketPool $packetPool Packet pool instance
+    * @param int $priority Event handling priority
+    * @param bool $handleCancelled Whether to handle cancelled events
+    */
+    public function __construct(
+        private Plugin $plugin,
+        private PacketPool $packetPool,
+        private int $priority,
+        private bool $handleCancelled
+    ) {}
+
+    /**
+    * Registers a handler for incoming packets.
+    *
+    * @param PacketHandlerInterface $handler The handler to register
+    */
+    public function registerIncoming(PacketHandlerInterface $handler): void {
+        foreach ($handler->getPacketIds() as $pid) {
+            $this->incomingHandlers[$pid][spl_object_id($handler)] = $handler;
+        }
+        $this->registerIncomingEvent();
+    }
+
+    /**
+    * Registers a handler for outgoing packets.
+    *
+    * @param PacketHandlerInterface $handler The handler to register
+    */
+    public function registerOutgoing(PacketHandlerInterface $handler): void {
+        foreach ($handler->getPacketIds() as $pid) {
+            $this->outgoingHandlers[$pid][spl_object_id($handler)] = $handler;
+        }
+        $this->registerOutgoingEvent();
+    }
+
+    /**
+    * Registers the incoming packet event if not already registered.
+    */
+    private function registerIncomingEvent(): void {
+        if ($this->incomingListener !== null) return;
+
+        $this->incomingListener = $this->plugin->getServer()->getPluginManager()->registerEvent(
+            DataPacketReceiveEvent::class,
+            function(DataPacketReceiveEvent $event): void {
+                $packet = $event->getPacket();
+                $pid = $packet::NETWORK_ID;
+                $session = $event->getOrigin();
+
+                if (isset($this->incomingHandlers[$pid])) {
+                    $continue = true;
+                    foreach ($this->incomingHandlers[$pid] as $handler) {
+                        if (!$handler->handle($packet, $session)) {
+                            $continue = false;
+                            break;
+                        }
+                    }
+                    if (!$continue) {
+                        $event->cancel();
+                    }
+                }
+            },
+            $this->priority,
+            $this->plugin,
+            $this->handleCancelled
+        );
+    }
+
+    /**
+    * Registers the outgoing packet event if not already registered.
+    */
+    private function registerOutgoingEvent(): void {
+        if ($this->outgoingListener !== null) return;
+
+        $this->outgoingListener = $this->plugin->getServer()->getPluginManager()->registerEvent(
+            DataPacketSendEvent::class,
+            function(DataPacketSendEvent $event): void {
+                $originalTargets = $event->getTargets();
+                $packets = $event->getPackets();
+                $modified = false;
+
+                foreach ($packets as $packet) {
+                    $pid = $packet::NETWORK_ID;
+
+                    if (isset($this->outgoingHandlers[$pid])) {
+                        $remainingTargets = $originalTargets;
+
+                        foreach ($remainingTargets as $i => $target) {
+                            foreach ($this->outgoingHandlers[$pid] as $handler) {
+                                if (!$handler->handle($packet, $target)) {
+                                    unset($remainingTargets[$i]);
+                                    $modified = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if ($modified) {
+                            $event->cancel();
+                            if (!empty($remainingTargets)) {
+                                $players = [];
+                                foreach ($remainingTargets as $target) {
+                                    $player = $target->getPlayer();
+                                    if ($player !== null) {
+                                        $players[] = $player;
+                                    }
+                                }
+                                if (!empty($players)) {
+                                    NetworkBroadcastUtils::broadcastPackets($players, [$packet]);
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            },
+            $this->priority,
+            $this->plugin,
+            $this->handleCancelled
+        );
+    }
+
+    /**
+    * Unregisters an incoming packet handler.
+    *
+    * @param PacketHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterIncoming(PacketHandlerInterface $handler): void {
+        $hid = spl_object_id($handler);
+        foreach ($handler->getPacketIds() as $pid) {
+            unset($this->incomingHandlers[$pid][$hid]);
+            if (empty($this->incomingHandlers[$pid])) {
+                unset($this->incomingHandlers[$pid]);
+            }
+        }
+
+        if (empty($this->incomingHandlers) && $this->incomingListener !== null) {
+            HandlerListManager::global()->getListFor(DataPacketReceiveEvent::class)->unregister($this->incomingListener);
+            $this->incomingListener = null;
+        }
+    }
+
+    /**
+    * Unregisters an outgoing packet handler.
+    *
+    * @param PacketHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterOutgoing(PacketHandlerInterface $handler): void {
+        $hid = spl_object_id($handler);
+        foreach ($handler->getPacketIds() as $pid) {
+            unset($this->outgoingHandlers[$pid][$hid]);
+            if (empty($this->outgoingHandlers[$pid])) {
+                unset($this->outgoingHandlers[$pid]);
+            }
+        }
+
+        if (empty($this->outgoingHandlers) && $this->outgoingListener !== null) {
+            HandlerListManager::global()->getListFor(DataPacketSendEvent::class)->unregister($this->outgoingListener);
+            $this->outgoingListener = null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/interceptor/PacketInterceptorInterface.php b/src/imperazim/packet/interceptor/PacketInterceptorInterface.php
new file mode 100644
index 0000000..04bddbd
--- /dev/null
+++ b/src/imperazim/packet/interceptor/PacketInterceptorInterface.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\interceptor;
+
+use imperazim\packet\handler\PacketHandlerInterface;
+
+/**
+* Interface for packet interception systems.
+* Defines methods for registering and unregistering packet interceptors.
+*/
+interface PacketInterceptorInterface {
+    /**
+    * Registers a handler for incoming packets.
+    *
+    * @param PacketHandlerInterface $handler The handler to register
+    */
+    public function registerIncoming(PacketHandlerInterface $handler): void;
+
+    /**
+    * Registers a handler for outgoing packets.
+    *
+    * @param PacketHandlerInterface $handler The handler to register
+    */
+    public function registerOutgoing(PacketHandlerInterface $handler): void;
+
+    /**
+    * Unregisters an incoming packet handler.
+    *
+    * @param PacketHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterIncoming(PacketHandlerInterface $handler): void;
+
+    /**
+    * Unregisters an outgoing packet handler.
+    *
+    * @param PacketHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterOutgoing(PacketHandlerInterface $handler): void;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/monitor/PacketMonitor.php b/src/imperazim/packet/monitor/PacketMonitor.php
new file mode 100644
index 0000000..303d188
--- /dev/null
+++ b/src/imperazim/packet/monitor/PacketMonitor.php
@@ -0,0 +1,163 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\monitor;
+
+use pocketmine\plugin\Plugin;
+use pocketmine\network\mcpe\protocol\PacketPool;
+use pocketmine\event\server\DataPacketReceiveEvent;
+use pocketmine\event\server\DataPacketSendEvent;
+use pocketmine\event\HandlerListManager;
+use pocketmine\event\RegisteredListener;
+use imperazim\packet\handler\PacketMonitorHandlerInterface;
+
+/**
+* Packet monitoring system implementation.
+* Allows registering handlers to monitor incoming and outgoing packets.
+*/
+final class PacketMonitor implements PacketMonitorInterface {
+    /** @var array Incoming packet handlers grouped by packet ID */
+    private array $incomingHandlers = [];
+
+    /** @var array Outgoing packet handlers grouped by packet ID */
+    private array $outgoingHandlers = [];
+
+    /** @var RegisteredListener|null Incoming packet event listener */
+    private ?RegisteredListener $incomingListener = null;
+
+    /** @var RegisteredListener|null Outgoing packet event listener */
+    private ?RegisteredListener $outgoingListener = null;
+
+    /**
+    * Constructor.
+    *
+    * @param Plugin $plugin The plugin instance
+    * @param PacketPool $packetPool Packet pool instance
+    * @param bool $handleCancelled Whether to handle cancelled events
+    */
+    public function __construct(
+        private Plugin $plugin,
+        private PacketPool $packetPool,
+        private bool $handleCancelled
+    ) {}
+
+    /**
+    * Registers a handler for incoming packets.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to register
+    */
+    public function registerIncoming(PacketMonitorHandlerInterface $handler): void {
+        foreach ($handler->getPacketIds() as $pid) {
+            $this->incomingHandlers[$pid][spl_object_id($handler)] = $handler;
+        }
+        $this->registerIncomingEvent();
+    }
+
+    /**
+    * Registers a handler for outgoing packets.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to register
+    */
+    public function registerOutgoing(PacketMonitorHandlerInterface $handler): void {
+        foreach ($handler->getPacketIds() as $pid) {
+            $this->outgoingHandlers[$pid][spl_object_id($handler)] = $handler;
+        }
+        $this->registerOutgoingEvent();
+    }
+
+    /**
+    * Registers the incoming packet event if not already registered.
+    */
+    private function registerIncomingEvent(): void {
+        if ($this->incomingListener !== null) return;
+
+        $this->incomingListener = $this->plugin->getServer()->getPluginManager()->registerEvent(
+            DataPacketReceiveEvent::class,
+            function(DataPacketReceiveEvent $event): void {
+                $packet = $event->getPacket();
+                $pid = $packet::NETWORK_ID;
+                $session = $event->getOrigin();
+
+                if (isset($this->incomingHandlers[$pid])) {
+                    foreach ($this->incomingHandlers[$pid] as $handler) {
+                        $handler->handle($packet, $session);
+                    }
+                }
+            },
+            EventPriority::MONITOR,
+            $this->plugin,
+            $this->handleCancelled
+        );
+    }
+
+    /**
+    * Registers the outgoing packet event if not already registered.
+    */
+    private function registerOutgoingEvent(): void {
+        if ($this->outgoingListener !== null) return;
+
+        $this->outgoingListener = $this->plugin->getServer()->getPluginManager()->registerEvent(
+            DataPacketSendEvent::class,
+            function(DataPacketSendEvent $event): void {
+                $targets = $event->getTargets();
+                $packets = $event->getPackets();
+
+                foreach ($packets as $packet) {
+                    $pid = $packet::NETWORK_ID;
+
+                    if (isset($this->outgoingHandlers[$pid])) {
+                        foreach ($targets as $target) {
+                            foreach ($this->outgoingHandlers[$pid] as $handler) {
+                                $handler->handle($packet, $target);
+                            }
+                        }
+                    }
+                }
+            },
+            EventPriority::MONITOR,
+            $this->plugin,
+            $this->handleCancelled
+        );
+    }
+
+    /**
+    * Unregisters an incoming packet handler.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterIncoming(PacketMonitorHandlerInterface $handler): void {
+        $hid = spl_object_id($handler);
+        foreach ($handler->getPacketIds() as $pid) {
+            unset($this->incomingHandlers[$pid][$hid]);
+            if (empty($this->incomingHandlers[$pid])) {
+                unset($this->incomingHandlers[$pid]);
+            }
+        }
+
+        if (empty($this->incomingHandlers) && $this->incomingListener !== null) {
+            HandlerListManager::global()->getListFor(DataPacketReceiveEvent::class)->unregister($this->incomingListener);
+            $this->incomingListener = null;
+        }
+    }
+
+    /**
+    * Unregisters an outgoing packet handler.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterOutgoing(PacketMonitorHandlerInterface $handler): void {
+        $hid = spl_object_id($handler);
+        foreach ($handler->getPacketIds() as $pid) {
+            unset($this->outgoingHandlers[$pid][$hid]);
+            if (empty($this->outgoingHandlers[$pid])) {
+                unset($this->outgoingHandlers[$pid]);
+            }
+        }
+
+        if (empty($this->outgoingHandlers) && $this->outgoingListener !== null) {
+            HandlerListManager::global()->getListFor(DataPacketSendEvent::class)->unregister($this->outgoingListener);
+            $this->outgoingListener = null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/monitor/PacketMonitorInterface.php b/src/imperazim/packet/monitor/PacketMonitorInterface.php
new file mode 100644
index 0000000..f7719a5
--- /dev/null
+++ b/src/imperazim/packet/monitor/PacketMonitorInterface.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\monitor;
+
+use imperazim\packet\handler\PacketMonitorHandlerInterface;
+
+/**
+* Interface for packet monitoring systems.
+* Defines methods for registering and unregistering packet monitors.
+*/
+interface PacketMonitorInterface {
+    /**
+    * Registers a handler for incoming packets.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to register
+    */
+    public function registerIncoming(PacketMonitorHandlerInterface $handler): void;
+
+    /**
+    * Registers a handler for outgoing packets.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to register
+    */
+    public function registerOutgoing(PacketMonitorHandlerInterface $handler): void;
+
+    /**
+    * Unregisters an incoming packet handler.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterIncoming(PacketMonitorHandlerInterface $handler): void;
+
+    /**
+    * Unregisters an outgoing packet handler.
+    *
+    * @param PacketMonitorHandlerInterface $handler The handler to unregister
+    */
+    public function unregisterOutgoing(PacketMonitorHandlerInterface $handler): void;
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/utils/PacketUtils.php b/src/imperazim/packet/utils/PacketUtils.php
new file mode 100644
index 0000000..1477584
--- /dev/null
+++ b/src/imperazim/packet/utils/PacketUtils.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\utils;
+
+use Closure;
+use ReflectionType;
+use ReflectionFunction;
+use ReflectionNamedType;
+use ReflectionUnionType;
+use ReflectionIntersectionType;
+use InvalidArgumentException;
+
+/**
+* Utility class for working with packet-related closures and type reflection.
+*/
+final class PacketUtils {
+    /**
+    * Parses a closure's signature and validates it against expected parameters and return type.
+    *
+    * @param Closure $closure The closure to analyze
+    * @param array $params Expected parameter types
+    * @param string $return_type Expected return type
+    *
+    * @return array Grouped type information for each parameter
+    *
+    * @throws InvalidArgumentException If signature doesn't match requirements
+    */
+    public static function parseClosureSignature(Closure $closure, array $params, string $return_type): array {
+        $method = new ReflectionFunction($closure);
+
+        // Validate return type
+        $type = $method->getReturnType();
+        if (!($type instanceof ReflectionNamedType) || $type->allowsNull() || $type->getName() !== $return_type) {
+            throw new InvalidArgumentException("Return value must be {$return_type}");
+        }
+
+        // Validate parameters
+        $parameters = $method->getParameters();
+        if (count($parameters) !== count($params)) {
+            throw new InvalidArgumentException("Must accept exactly " . count($params) . " parameters");
+        }
+
+        $parsed_params = [];
+        foreach ($parameters as $index => $parameter) {
+            $param_type = $parameter->getType();
+            $expected_type = $params[$index];
+
+            if ($param_type === null) {
+                throw new InvalidArgumentException("Parameter {$index} must have a type");
+            }
+
+            if ($param_type->allowsNull()) {
+                throw new InvalidArgumentException("Parameter {$index} must not be nullable");
+            }
+
+            $names = self::groupTypes($param_type);
+            $parsed_params[] = $names;
+        }
+
+        return $parsed_params;
+    }
+
+    /**
+    * Groups reflection types into structured arrays.
+    *
+    * @param ReflectionType $type The type to group
+    *
+    * @return array Structured type groups
+    */
+    public static function groupTypes(ReflectionType $type): array {
+        $result = [];
+
+        if ($type instanceof ReflectionNamedType) {
+            $result[] = [$type->getName()];
+        } elseif ($type instanceof ReflectionUnionType) {
+            foreach ($type->getTypes() as $child) {
+                $result[] = self::groupTypes($child)[0];
+            }
+        } elseif ($type instanceof ReflectionIntersectionType) {
+            $group = [];
+            foreach ($type->getTypes() as $child) {
+                $group = array_merge($group, self::groupTypes($child)[0]);
+            }
+            $result[] = $group;
+        }
+
+        return $result;
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/packet/utils/TypeValidator.php b/src/imperazim/packet/utils/TypeValidator.php
new file mode 100644
index 0000000..1f36c21
--- /dev/null
+++ b/src/imperazim/packet/utils/TypeValidator.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\packet\utils;
+
+use pocketmine\network\mcpe\protocol\Packet;
+use pocketmine\network\mcpe\protocol\PacketPool;
+use InvalidArgumentException;
+
+/**
+* Validates packet classes and maps them to network IDs.
+*/
+final class TypeValidator {
+    /**
+    * Validates packet classes and returns their network IDs.
+    *
+    * @param array $classes Array of packet class names
+    *
+    * @return array Unique network IDs of valid packets
+    *
+    * @throws InvalidArgumentException If classes are invalid or don't match packet IDs
+    */
+    public static function validatePacketClasses(array $classes): array {
+        $ids = [];
+        $pool = PacketPool::getInstance();
+
+        foreach ($classes as $class) {
+            if (!is_a($class, Packet::class, true)) {
+                throw new InvalidArgumentException("$class must extend " . Packet::class);
+            }
+
+            $id = $class::NETWORK_ID;
+            $packet = $pool->getPacketById($id);
+
+            if (!$packet instanceof $class) {
+                throw new InvalidArgumentException("Packet ID $id does not match class $class");
+            }
+
+            $ids[] = $id;
+        }
+
+        return array_unique($ids);
+    }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/BaseCommand.php b/src/imperazim/vendor/commando/BaseCommand.php
deleted file mode 100644
index d35e5b6..0000000
--- a/src/imperazim/vendor/commando/BaseCommand.php
+++ /dev/null
@@ -1,208 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando;
-
-use imperazim\vendor\commando\traits\IArgumentable;
-use imperazim\vendor\commando\traits\ArgumentableTrait;
-use imperazim\vendor\commando\constraint\BaseConstraint;
-use imperazim\vendor\commando\exception\InvalidErrorCode;
-
-use pocketmine\plugin\Plugin;
-use InvalidArgumentException;
-use pocketmine\command\Command;
-use pocketmine\utils\TextFormat;
-use pocketmine\plugin\PluginOwned;
-use pocketmine\command\CommandSender;
-
-use function count;
-use function dechex;
-use function str_replace;
-use function array_shift;
-use function array_unique;
-use function array_unshift;
-
-abstract class BaseCommand extends Command implements IArgumentable, IRunnable, PluginOwned {
-  use ArgumentableTrait;
-
-  public const ERR_INVALID_ARG_VALUE = 0x01;
-  public const ERR_TOO_MANY_ARGUMENTS = 0x02;
-  public const ERR_INSUFFICIENT_ARGUMENTS = 0x03;
-  public const ERR_NO_ARGUMENTS = 0x04;
-  public const ERR_INVALID_ARGUMENTS = 0x05;
-
-  /** @var string[] */
-  protected $errorMessages = [
-    self::ERR_INVALID_ARG_VALUE => TextFormat::RED . "Invalid value '{value}' for argument #{position}. Expecting: {expected}.",
-    self::ERR_TOO_MANY_ARGUMENTS => TextFormat::RED . "Too many arguments given.",
-    self::ERR_INSUFFICIENT_ARGUMENTS => TextFormat::RED . "Insufficient number of arguments given.",
-    self::ERR_NO_ARGUMENTS => TextFormat::RED . "No arguments are required for this command.",
-    self::ERR_INVALID_ARGUMENTS => TextFormat::RED . "Invalid arguments supplied.",
-  ];
-
-  /** @var CommandSender */
-  protected CommandSender $currentSender;
-
-  /** @var BaseSubCommand[] */
-  private array $subCommands = [];
-
-  /** @var BaseConstraint[] */
-  private array $constraints = [];
-
-  /** @var Plugin */
-  protected Plugin $plugin;
-
-  public function __construct(
-    Plugin $plugin,
-    array $names,
-    Translatable|string $description = ""
-) {
-    $name = array_shift($names);
-    $aliases = $names;
-    $this->plugin = $plugin;
-    parent::__construct($name, $description, null, $aliases);
-    $this->prepare();
-    $this->usageMessage = $this->generateUsageMessage();
-}
-
-
-  public function getOwningPlugin(): Plugin {
-    return $this->plugin;
-  }
-
-  final public function execute(mixed $sender, string $commandLabel, array $args) {
-    $this->currentSender = $sender;
-    if (!$this->testPermission($sender)) {
-      return;
-    }
-    /** @var BaseCommand|BaseSubCommand $cmd */
-    $cmd = $this;
-    $passArgs = [];
-    if (count($args) > 0) {
-      if (isset($this->subCommands[($label = $args[0])])) {
-        array_shift($args);
-        $this->subCommands[$label]->execute($sender, $label, $args);
-        return;
-      }
-
-      $passArgs = $this->attemptArgumentParsing($cmd, $args);
-    } elseif ($this->hasRequiredArguments()) {
-      $this->sendError(self::ERR_INSUFFICIENT_ARGUMENTS);
-      return;
-    }
-    if ($passArgs !== null) {
-      foreach ($cmd->getConstraints() as $constraint) {
-        if (!$constraint->test($sender, $commandLabel, $passArgs)) {
-          $constraint->onFailure($sender, $commandLabel, $passArgs);
-          return;
-        }
-      }
-      $cmd->onRun($sender, $commandLabel, $passArgs);
-    }
-  }
-
-  /**
-  * @param ArgumentableTrait $ctx
-  * @param array             $args
-  *
-  * @return array|null
-  */
-  private function attemptArgumentParsing($ctx, array $args): ?array {
-    $dat = $ctx->parseArguments($args, $this->currentSender);
-    if (!empty(($errors = $dat["errors"]))) {
-      foreach ($errors as $error) {
-        $this->sendError($error["code"], $error["data"]);
-      }
-
-      return null;
-    }
-
-    return $dat["arguments"];
-  }
-
-  abstract public function onRun(mixed $player, string $aliasUsed, array $args): void;
-
-  protected function sendUsage(): void {
-    $this->currentSender->sendMessage(TextFormat::RED . "Usage: " . $this->getUsage());
-  }
-
-  public function sendError(int $errorCode, array $args = []): void {
-    $str = (string)$this->errorMessages[$errorCode];
-    foreach ($args as $item => $value) {
-      $str = str_replace('{' . $item . '}', (string) $value, $str);
-    }
-    $this->currentSender->sendMessage($str);
-    $this->sendUsage();
-  }
-
-  public function setErrorFormat(int $errorCode, string $format): void {
-    if (!isset($this->errorMessages[$errorCode])) {
-      throw new InvalidErrorCode("Invalid error code 0x" . dechex($errorCode));
-    }
-    $this->errorMessages[$errorCode] = $format;
-  }
-
-  public function setErrorFormats(array $errorFormats): void {
-    foreach ($errorFormats as $errorCode => $format) {
-      $this->setErrorFormat($errorCode, $format);
-    }
-  }
-  
-  /**
-  * Register multiple subcommands at once.
-  * @param array $subcommands An array of BaseSubCommand instances. If no position is specified, the index will be used.
-  * @throws ArgumentOrderException
-  */
-  public function registerSubcommands(array $subcommands): void {
-    foreach ($subcommands as $subCommand) {
-      $this->registerSubCommand($subCommand);
-    }
-  }
-
-  public function registerSubCommand(BaseSubCommand $subCommand): void {
-    $keys = $subCommand->getAliases();
-    array_unshift($keys, $subCommand->getName());
-    $keys = array_unique($keys);
-    foreach ($keys as $key) {
-      if (!isset($this->subCommands[$key])) {
-        $subCommand->setParent($this);
-        $this->subCommands[$key] = $subCommand;
-      } else {
-        throw new InvalidArgumentException("SubCommand with same name / alias for '$key' already exists");
-      }
-    }
-  }
-
-  /**
-  * @return BaseSubCommand[]
-  */
-  public function getSubCommands(): array {
-    return $this->subCommands;
-  }
-
-  public function addConstraints(array $constraints) : void {
-    foreach ($constraints as $constraint) {
-      $this->constraints[] = $constraint;
-    }
-  }
-
-  public function addConstraint(BaseConstraint $constraint) : void {
-    $this->constraints[] = $constraint;
-  }
-
-  /**
-  * @return BaseConstraint[]
-  */
-  public function getConstraints(): array {
-    return $this->constraints;
-  }
-
-  public function getUsageMessage(): string {
-    return $this->getUsage();
-  }
-
-  public function setCurrentSender(CommandSender $sender): void {
-    $this->currentSender = $sender;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/BaseSubCommand.php b/src/imperazim/vendor/commando/BaseSubCommand.php
deleted file mode 100644
index 44e8e40..0000000
--- a/src/imperazim/vendor/commando/BaseSubCommand.php
+++ /dev/null
@@ -1,55 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando;
-
-use pocketmine\plugin\Plugin;
-use function trim;
-
-abstract class BaseSubCommand extends BaseCommand {
-  /** @var BaseCommand */
-  protected BaseCommand $parent;
-
-  public function __construct(
-    Plugin $plugin,
-    array $names,
-    Translatable|string $description = ""
-) {
-    parent::__construct($plugin, $names, $description);
-    $this->usageMessage = "";
-  }
-
-  public function getParent(): BaseCommand {
-    return $this->parent;
-  }
-
-  /**
-  * @param BaseCommand $parent
-  *
-  * @internal Used to pass the parent context from the parent command
-  */
-  public function setParent(BaseCommand $parent): void {
-    $this->parent = $parent;
-  }
-
-  public function getUsage(): string {
-    if (empty($this->usageMessage)) {
-      $parent = $this->parent;
-      $parentNames = "";
-
-      while ($parent instanceof BaseSubCommand) {
-        $parentNames = $parent->getName() . $parentNames;
-        $parent = $parent->getParent();
-      }
-
-      if ($parent instanceof BaseCommand) {
-        $parentNames = $parent->getName() . " " . $parentNames;
-      }
-
-      $this->usageMessage = $this->generateUsageMessage(trim($parentNames));
-    }
-
-    return $this->usageMessage;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/CommandoManager.php b/src/imperazim/vendor/commando/CommandoManager.php
deleted file mode 100644
index 7533bab..0000000
--- a/src/imperazim/vendor/commando/CommandoManager.php
+++ /dev/null
@@ -1,161 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando;
-
-use ReflectionClass;
-use pocketmine\Server;
-use pocketmine\event\Listener;
-use pocketmine\plugin\PluginBase;
-use pocketmine\event\EventPriority;
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\NetworkSession;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
-use pocketmine\network\mcpe\protocol\types\command\CommandOverload;
-use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
-
-use imperazim\components\plugin\PluginToolkit;
-use imperazim\components\plugin\PluginComponent;
-use imperazim\components\plugin\traits\PluginComponentsTrait;
-
-use imperazim\vendor\commando\store\SoftEnumStore;
-use imperazim\vendor\commando\traits\IArgumentable;
-use imperazim\vendor\simplepackethandler\SimplePacketHandler;
-use imperazim\vendor\commando\exception\HookAlreadyRegistered;
-
-use function count;
-use function array_unshift;
-
-/**
-* Class CommandoManager
-* @package imperazim\vendor\commando
-*/
-final class CommandoManager extends PluginComponent implements Listener {
-  use PluginComponentsTrait;
-
-  /** @var bool */
-  private static bool $isIntercepting = false;
-
-  /**
-  * Initializes the commando component.
-  * @param PluginToolkit $plugin The Plugin.
-  */
-  public static function init(PluginToolkit $plugin): array {
-    $interceptor = SimplePacketHandler::createInterceptor($plugin, EventPriority::HIGHEST, false);
-    $interceptor->interceptOutgoing(function(AvailableCommandsPacket $pk, NetworkSession $target) : bool {
-      if (!self::$isIntercepting) {
-        $p = $target->getPlayer();
-        foreach ($pk->commandData as $commandName => $commandData) {
-          $cmd = Server::getInstance()->getCommandMap()->getCommand($commandName);
-          if ($cmd instanceof BaseCommand) {
-            foreach ($cmd->getConstraints() as $constraint) {
-              if (!$constraint->isVisibleTo($p)) {
-                continue 2;
-              }
-            }
-            $pk->commandData[$commandName]->overloads = self::generateOverloads($p, $cmd);
-          }
-        }
-        $pk->softEnums = SoftEnumStore::getEnums();
-        self::$isIntercepting = true;
-        $target->sendDataPacket($pk);
-        self::$isIntercepting = false;
-      }
-      return self::$isIntercepting;
-    });
-
-    self::setPlugin(plugin: $plugin);
-    return [
-      self::LISTENER_COMPONENT => [
-        new self()
-      ]
-    ];
-  }
-
-  /**
-  * @param CommandSender $cs
-  * @param BaseCommand $command
-  *
-  * @return CommandOverload[]
-  */
-  private static function generateOverloads(CommandSender $cs,
-    BaseCommand $command): array {
-    $overloads = [];
-
-    foreach ($command->getSubCommands() as $label => $subCommand) {
-      if (!$subCommand->testPermissionSilent($cs) || $subCommand->getName() !== $label) {
-        // hide aliases
-        continue;
-      }
-      foreach ($subCommand->getConstraints() as $constraint) {
-        if (!$constraint->isVisibleTo($cs)) {
-          continue 2;
-        }
-      }
-      $scParam = new CommandParameter();
-      $scParam->paramName = $label;
-      $scParam->paramType = AvailableCommandsPacket::ARG_FLAG_VALID | AvailableCommandsPacket::ARG_FLAG_ENUM;
-      $scParam->isOptional = false;
-      $scParam->enum = new CommandEnum($label, [$label]);
-
-      $overloadList = self::generateOverloads($cs, $subCommand);
-      if (!empty($overloadList)) {
-        foreach ($overloadList as $overload) {
-          $overloads[] = new CommandOverload(false, [$scParam, ...$overload->getParameters()]);
-        }
-      } else {
-        $overloads[] = new CommandOverload(false, [$scParam]);
-      }
-    }
-
-    foreach (self::generateOverloadList($command) as $overload) {
-      $overloads[] = $overload;
-    }
-
-    return $overloads;
-  }
-
-  /**
-  * @param IArgumentable $argumentable
-  *
-  * @return CommandOverload[]
-  */
-  private static function generateOverloadList(IArgumentable $argumentable): array {
-    $input = $argumentable->getArgumentList();
-    $combinations = [];
-    $outputLength = array_product(array_map("count", $input));
-    $indexes = [];
-    foreach ($input as $k => $charList) {
-      $indexes[$k] = 0;
-    }
-    do {
-      /** @var CommandParameter[] $set */
-      $set = [];
-      foreach ($indexes as $k => $index) {
-        $param = $set[$k] = clone $input[$k][$index]->getNetworkParameterData();
-
-        if (isset($param->enum) && $param->enum instanceof CommandEnum) {
-          $refClass = new ReflectionClass(CommandEnum::class);
-          $refProp = $refClass->getProperty("enumName");
-          $refProp->setAccessible(true);
-          $refProp->setValue($param->enum, "enum#" . spl_object_id($param->enum));
-        }
-      }
-      $combinations[] = new CommandOverload(false, $set);
-
-      foreach ($indexes as $k => $v) {
-        $indexes[$k]++;
-        $lim = count($input[$k]);
-        if ($indexes[$k] >= $lim) {
-          $indexes[$k] = 0;
-          continue;
-        }
-        break;
-      }
-    } while (count($combinations) !== $outputLength);
-
-    return $combinations;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/IRunnable.php b/src/imperazim/vendor/commando/IRunnable.php
deleted file mode 100644
index c57c2ee..0000000
--- a/src/imperazim/vendor/commando/IRunnable.php
+++ /dev/null
@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando;
-
-use imperazim\vendor\commando\constraint\BaseConstraint;
-
-/**
-* Interface IRunnable
-*
-* An interface which is declares the minimum required information
-* to get background information for a command and/or a sub-command
-*
-* @package imperazim\vendor\commando
-*/
-interface IRunnable {
-  public function getName(): string;
-
-  /**
-  * @return string[]
-  */
-  public function getAliases(): array;
-
-  public function getUsageMessage():string;
-
-  /**
-  * @return string[]
-  */
-  public function getPermissions(): array;
-
-  /**
-  * @return BaseConstraint[]
-  */
-  public function getConstraints():array;
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/BaseArgument.php b/src/imperazim/vendor/commando/args/BaseArgument.php
deleted file mode 100644
index b3fdb27..0000000
--- a/src/imperazim/vendor/commando/args/BaseArgument.php
+++ /dev/null
@@ -1,88 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
-
-abstract class BaseArgument {
-  
-  /** @var string */
-  protected string $name;
-  /** @var bool */
-  protected bool $optional = false;
-  /** @var bool */
-  protected bool $hideName = false;
-  /** @var CommandParameter */
-  protected CommandParameter $parameterData;
-
-  public function __construct(string $name, bool $optional = false, bool $hideName = false) {
-    $this->name = $name;
-    $this->optional = $optional;
-    $this->hideName = $hideName;
-
-    $this->parameterData = new CommandParameter();
-    $this->parameterData->paramName = $name;
-    $this->parameterData->paramType = AvailableCommandsPacket::ARG_FLAG_VALID;
-    $this->parameterData->paramType |= $this->getNetworkType();
-    $this->parameterData->isOptional = $this->isOptional();
-  }
-
-  abstract public function getNetworkType(): int;
-
-  /**
-  * @param string            $testString
-  * @param CommandSender     $sender
-  *
-  * @return bool
-  */
-  abstract public function canParse(string $testString, CommandSender $sender): bool;
-
-  /**
-  * @param string        $argument
-  * @param CommandSender $sender
-  *
-  * @return mixed
-  */
-  abstract public function parse(string $argument, CommandSender $sender) : mixed;
-
-  /**
-  * @return string
-  */
-  public function getName(): string {
-    return $this->name;
-  }
-
-  /**
-  * @return bool
-  */
-  public function isOptional(): bool {
-    return $this->optional;
-  }
-
-  /**
-  * @return bool
-  */
-  public function hideName(): bool {
-    return $this->hideName;
-  }
-
-  /**
-  * Returns how much command arguments
-  * it takes to build the full argument
-  *
-  * @return int
-  */
-  public function getSpanLength(): int {
-    return 1;
-  }
-
-  abstract public function getTypeName(): string;
-
-  public function getNetworkParameterData():CommandParameter {
-    return $this->parameterData;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/BlockPositionArgument.php b/src/imperazim/vendor/commando/args/BlockPositionArgument.php
deleted file mode 100644
index 43940eb..0000000
--- a/src/imperazim/vendor/commando/args/BlockPositionArgument.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\math\Vector3;
-use pocketmine\command\CommandSender;
-
-use function preg_match;
-
-class BlockPositionArgument extends Vector3Argument {
-  public function isValidCoordinate(string $coordinate, bool $locatable): bool {
-    return (bool)preg_match("/^(?:" . ($locatable ? "(?:~-|~\+)?" : "") . "-?\d+)" . ($locatable ? "|~" : "") . "$/", $coordinate);
-  }
-
-  public function parse(string $argument, CommandSender $sender) : Vector3 {
-    $v = parent::parse($argument, $sender);
-
-    return $v->floor();
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/BooleanArgument.php b/src/imperazim/vendor/commando/args/BooleanArgument.php
deleted file mode 100644
index 00821f5..0000000
--- a/src/imperazim/vendor/commando/args/BooleanArgument.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-
-class BooleanArgument extends StringEnumArgument {
-
-	protected const VALUES = [
-		"true" => true,
-		"false" => false,
-	];
-
-	public function getTypeName(): string {
-		return "bool";
-	}
-
-	public function getEnumName(): string {
-		return "bool";
-	}
-
-	public function parse(string $argument, CommandSender $sender) {
-		return $this->getValue($argument);
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/FloatArgument.php b/src/imperazim/vendor/commando/args/FloatArgument.php
deleted file mode 100644
index c11ab66..0000000
--- a/src/imperazim/vendor/commando/args/FloatArgument.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-use function preg_match;
-
-class FloatArgument extends BaseArgument {
-	public function getNetworkType(): int {
-		return AvailableCommandsPacket::ARG_TYPE_FLOAT;
-	}
-
-	public function getTypeName(): string {
-		return "decimal";
-	}
-
-	public function canParse(string $testString, CommandSender $sender): bool {
-		return (bool)preg_match("/^-?(?:\d+|\d*\.\d+)$/", $testString);
-	}
-
-	public function parse(string $argument, CommandSender $sender) : float{
-		return (float) $argument;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/IntegerArgument.php b/src/imperazim/vendor/commando/args/IntegerArgument.php
deleted file mode 100644
index cd17234..0000000
--- a/src/imperazim/vendor/commando/args/IntegerArgument.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-use function preg_match;
-
-class IntegerArgument extends BaseArgument {
-  public function getNetworkType(): int {
-    return AvailableCommandsPacket::ARG_TYPE_INT;
-  }
-
-  public function getTypeName(): string {
-    return "int";
-  }
-
-  public function canParse(string $testString, CommandSender $sender): bool {
-    return (bool)preg_match("/^-?(?:\d+)$/", $testString);
-  }
-
-  public function parse(string $argument, CommandSender $sender) : int {
-    return (int) $argument;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/RawStringArgument.php b/src/imperazim/vendor/commando/args/RawStringArgument.php
deleted file mode 100644
index 1d170da..0000000
--- a/src/imperazim/vendor/commando/args/RawStringArgument.php
+++ /dev/null
@@ -1,26 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-class RawStringArgument extends BaseArgument {
-  public function getNetworkType(): int {
-    return AvailableCommandsPacket::ARG_TYPE_STRING;
-  }
-
-  public function getTypeName(): string {
-    return "string";
-  }
-
-  public function canParse(string $testString, CommandSender $sender): bool {
-    return true;
-  }
-
-  public function parse(string $argument, CommandSender $sender) : string {
-    return $argument;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/StringEnumArgument.php b/src/imperazim/vendor/commando/args/StringEnumArgument.php
deleted file mode 100644
index 6e72cd8..0000000
--- a/src/imperazim/vendor/commando/args/StringEnumArgument.php
+++ /dev/null
@@ -1,47 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
-
-use function implode;
-use function array_map;
-use function array_keys;
-use function preg_match;
-use function strtolower;
-
-abstract class StringEnumArgument extends BaseArgument {
-
-  protected const VALUES = [];
-
-  public function __construct(string $name, bool $optional = false) {
-    parent::__construct($name, $optional);
-
-    $this->parameterData->enum = new CommandEnum($this->getEnumName(), $this->getEnumValues());
-  }
-
-  public function getNetworkType(): int {
-    // this will be disregarded by PM anyways because this will be considered as a string enum
-    return -1;
-  }
-
-  public function canParse(string $testString, CommandSender $sender): bool {
-    return (bool)preg_match(
-      "/^(" . implode("|", array_map("\\strtolower", $this->getEnumValues())) . ")$/iu",
-      $testString
-    );
-  }
-
-  public abstract function getEnumName(): string;
-
-  public function getValue(string $string) {
-    return static::VALUES[strtolower($string)];
-  }
-
-  public function getEnumValues(): array {
-    return array_keys(static::VALUES);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/TargetPlayerArgument.php b/src/imperazim/vendor/commando/args/TargetPlayerArgument.php
deleted file mode 100644
index 43f5891..0000000
--- a/src/imperazim/vendor/commando/args/TargetPlayerArgument.php
+++ /dev/null
@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-use function is_null;
-use function preg_match;
-use function strtolower;
-
-class TargetPlayerArgument extends BaseArgument {
-  public function __construct(bool $optional = false, ?string $name = null) {
-    $name = is_null($name) ? "player" : $name;
-
-    parent::__construct($name, $optional);
-  }
-
-  public function getTypeName(): string {
-    return "target";
-  }
-
-  public function getNetworkType(): int {
-    return AvailableCommandsPacket::ARG_TYPE_TARGET;
-  }
-
-  public function canParse(string $testString, CommandSender $sender): bool {
-    return (bool) preg_match("/^(?!rcon|console)[a-zA-Z0-9_ ]{1,16}$/i", $testString);
-  }
-
-  public function parse(string $argument, CommandSender $sender) {
-    return strtolower($argument);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/TextArgument.php b/src/imperazim/vendor/commando/args/TextArgument.php
deleted file mode 100644
index 37e11ea..0000000
--- a/src/imperazim/vendor/commando/args/TextArgument.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-class TextArgument extends RawStringArgument {
-  public function getNetworkType(): int {
-    return AvailableCommandsPacket::ARG_TYPE_RAWTEXT;
-  }
-
-  public function getTypeName(): string {
-    return "text";
-  }
-
-  public function getSpanLength(): int {
-    return PHP_INT_MAX;
-  }
-  public function canParse(string $testString, CommandSender $sender): bool {
-    return $testString !== "";
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/args/Vector3Argument.php b/src/imperazim/vendor/commando/args/Vector3Argument.php
deleted file mode 100644
index f3dde1c..0000000
--- a/src/imperazim/vendor/commando/args/Vector3Argument.php
+++ /dev/null
@@ -1,71 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\args;
-
-use pocketmine\math\Vector3;
-use pocketmine\entity\Entity;
-use pocketmine\command\CommandSender;
-use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
-
-use function count;
-use function substr;
-use function explode;
-use function preg_match;
-
-class Vector3Argument extends BaseArgument {
-  public function getNetworkType(): int {
-    return AvailableCommandsPacket::ARG_TYPE_POSITION;
-  }
-
-  public function getTypeName(): string {
-    return "x y z";
-  }
-
-  public function canParse(string $testString, CommandSender $sender): bool {
-    $coords = explode(" ", $testString);
-    if (count($coords) === 3) {
-      foreach ($coords as $coord) {
-        if (!$this->isValidCoordinate($coord, $sender instanceof Vector3)) {
-          return false;
-        }
-      }
-
-      return true;
-    }
-
-    return false;
-  }
-
-  public function isValidCoordinate(string $coordinate, bool $locatable): bool {
-    return (bool)preg_match("/^(?:" . ($locatable ? "(\\?:~-|~\+)?" : "") . "-?(?:\d+|\d*\.\d+))" . ($locatable ? "|~" : "") . "$/", $coordinate);
-  }
-
-  public function parse(string $argument, CommandSender $sender) : Vector3 {
-    $coords = explode(" ", $argument);
-    $vals = [];
-    foreach ($coords as $k => $coord) {
-      $offset = 0;
-      // if it's locatable and starts with ~- or ~+
-      if ($sender instanceof Entity && preg_match("/^(?:~-|~\+)|~/", $coord)) {
-        // this will work with -n, +n and "" due to typecast later
-        $offset = substr($coord, 1);
-
-        // replace base coordinate with actual entity coordinates
-        $position = $sender->getPosition();
-        $coord = match ($k) {
-          0 => $position->x,
-          1 => $position->y,
-          2 => $position->z,
-        };
-      }
-      $vals[] = (float)$coord + (float)$offset;
-    }
-    return new Vector3(...$vals);
-  }
-
-  public function getSpanLength(): int {
-    return 3;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/constraint/BaseConstraint.php b/src/imperazim/vendor/commando/constraint/BaseConstraint.php
deleted file mode 100644
index 193928e..0000000
--- a/src/imperazim/vendor/commando/constraint/BaseConstraint.php
+++ /dev/null
@@ -1,37 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\constraint;
-
-use pocketmine\command\CommandSender;
-use imperazim\vendor\commando\IRunnable;
-
-abstract class BaseConstraint {
-  /** @var IRunnable */
-  protected IRunnable $context;
-
-  /**
-  * BaseConstraint constructor.
-  *
-  * "Context" is required so that this new-constraint-system doesn't hinder getting command info
-  *
-  * @param IRunnable $context
-  */
-  public function __construct(IRunnable $context) {
-    $this->context = $context;
-  }
-
-  /**
-  * @return IRunnable
-  */
-  public function getContext(): IRunnable {
-    return $this->context;
-  }
-
-  abstract public function test(CommandSender $sender, string $aliasUsed, array $args): bool;
-
-  abstract public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void;
-
-  abstract public function isVisibleTo(CommandSender $sender): bool;
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/constraint/ConsoleRequiredConstraint.php b/src/imperazim/vendor/commando/constraint/ConsoleRequiredConstraint.php
deleted file mode 100644
index dd9abc1..0000000
--- a/src/imperazim/vendor/commando/constraint/ConsoleRequiredConstraint.php
+++ /dev/null
@@ -1,24 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\constraint;
-
-use pocketmine\player\Player;
-use pocketmine\utils\TextFormat;
-use pocketmine\command\CommandSender;
-
-class ConsoleRequiredConstraint extends BaseConstraint {
-
-  public function test(CommandSender $sender, string $aliasUsed, array $args): bool {
-    return $this->isVisibleTo($sender);
-  }
-
-  public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void {
-    $sender->sendMessage(TextFormat::RED . "This command must be executed from a server console."); // f*ck off grammar police
-  }
-
-  public function isVisibleTo(CommandSender $sender): bool {
-    return !($sender instanceof Player);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/constraint/InGameRequiredConstraint.php b/src/imperazim/vendor/commando/constraint/InGameRequiredConstraint.php
deleted file mode 100644
index 5418b91..0000000
--- a/src/imperazim/vendor/commando/constraint/InGameRequiredConstraint.php
+++ /dev/null
@@ -1,24 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\constraint;
-
-use pocketmine\player\Player;
-use pocketmine\utils\TextFormat;
-use pocketmine\command\CommandSender;
-
-class InGameRequiredConstraint extends BaseConstraint {
-
-  public function test(CommandSender $sender, string $aliasUsed, array $args): bool {
-    return $this->isVisibleTo($sender);
-  }
-
-  public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void {
-    $sender->sendMessage(TextFormat::RED . "This command must be executed in-game."); // f*ck off grammar police
-  }
-
-  public function isVisibleTo(CommandSender $sender): bool {
-    return $sender instanceof Player;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/exception/ArgumentOrderException.php b/src/imperazim/vendor/commando/exception/ArgumentOrderException.php
deleted file mode 100644
index 2137cbc..0000000
--- a/src/imperazim/vendor/commando/exception/ArgumentOrderException.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\exception;
-
-class ArgumentOrderException extends CommandoException {}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/exception/CommandoException.php b/src/imperazim/vendor/commando/exception/CommandoException.php
deleted file mode 100644
index 3e64f51..0000000
--- a/src/imperazim/vendor/commando/exception/CommandoException.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\exception;
-
-use Exception;
-
-class CommandoException extends Exception {}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/exception/HookAlreadyRegistered.php b/src/imperazim/vendor/commando/exception/HookAlreadyRegistered.php
deleted file mode 100644
index 094aa2f..0000000
--- a/src/imperazim/vendor/commando/exception/HookAlreadyRegistered.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\exception;
-
-class HookAlreadyRegistered extends CommandoException {}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/exception/InvalidErrorCode.php b/src/imperazim/vendor/commando/exception/InvalidErrorCode.php
deleted file mode 100644
index fcb63e0..0000000
--- a/src/imperazim/vendor/commando/exception/InvalidErrorCode.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\exception;
-
-class InvalidErrorCode extends CommandoException {}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/store/SoftEnumStore.php b/src/imperazim/vendor/commando/store/SoftEnumStore.php
deleted file mode 100644
index f9fa989..0000000
--- a/src/imperazim/vendor/commando/store/SoftEnumStore.php
+++ /dev/null
@@ -1,62 +0,0 @@
-<?php
-
-
-namespace imperazim\vendor\commando\store;
-
-use pocketmine\Server;
-use pocketmine\network\mcpe\NetworkBroadcastUtils;
-use pocketmine\network\mcpe\protocol\ClientboundPacket;
-use pocketmine\network\mcpe\protocol\UpdateSoftEnumPacket;
-use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
-
-use imperazim\vendor\commando\exception\CommandoException;
-
-class SoftEnumStore {
-  /** @var CommandEnum[] */
-  private static array $enums = [];
-
-  public static function getEnumByName(string $name):?CommandEnum {
-    return static::$enums[$name] ?? null;
-  }
-
-  /**
-  * @return CommandEnum[]
-  */
-  public static function getEnums(): array {
-    return static::$enums;
-  }
-
-  public static function addEnum(CommandEnum $enum):void {
-    static::$enums[$enum->getName()] = $enum;
-    self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_ADD);
-  }
-
-  public static function updateEnum(string $enumName, array $values):void {
-    if (self::getEnumByName($enumName) === null) {
-      throw new CommandoException("Unknown enum named " . $enumName);
-    }
-    self::$enums[$enumName] = $enum = new CommandEnum($enumName, $values);
-    self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_SET);
-  }
-
-  public static function removeEnum(string $enumName):void {
-    if (($enum = self::getEnumByName($enumName)) === null) {
-      throw new CommandoException("Unknown enum named " . $enumName);
-    }
-    unset(static::$enums[$enumName]);
-    self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_REMOVE);
-  }
-
-  public static function broadcastSoftEnum(CommandEnum $enum, int $type):void {
-    $pk = new UpdateSoftEnumPacket();
-    $pk->enumName = $enum->getName();
-    $pk->values = $enum->getValues();
-    $pk->type = $type;
-    self::broadcastPacket($pk);
-  }
-
-  private static function broadcastPacket(ClientboundPacket $pk):void {
-    $sv = Server::getInstance();
-    NetworkBroadcastUtils::broadcastPackets($sv->getOnlinePlayers(), [$pk]);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/traits/ArgumentableTrait.php b/src/imperazim/vendor/commando/traits/ArgumentableTrait.php
deleted file mode 100644
index ec2fd5e..0000000
--- a/src/imperazim/vendor/commando/traits/ArgumentableTrait.php
+++ /dev/null
@@ -1,244 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\traits;
-
-use imperazim\vendor\commando\BaseCommand;
-use imperazim\vendor\commando\args\BaseArgument;
-use imperazim\vendor\commando\args\TextArgument;
-use imperazim\vendor\commando\exception\ArgumentOrderException;
-
-use pocketmine\utils\TextFormat;
-use pocketmine\command\CommandSender;
-
-use function trim;
-use function rtrim;
-use function usort;
-use function count;
-use function implode;
-use function is_array;
-use function array_slice;
-
-trait ArgumentableTrait {
-  /** @var BaseArgument[][] */
-  private array $argumentList = []; // [argumentPosition => [...possible BaseArgument(s)]]
-  /** @var bool[] */
-  private array $requiredArgumentCount = [];
-
-  /**
-  * This is where all the arguments, permissions, sub-commands, etc would be registered
-  */
-  abstract protected function prepare() : void;
-
-  /**
-  * Register multiple arguments at once.
-  * @param array $arguments An array of BaseArgument instances. If no position is specified, the index will be used.
-  * @throws ArgumentOrderException
-  */
-  public function registerArguments(array $arguments): void {
-    foreach ($arguments as $position => $argument) {
-      // If the key is not an integer, it means positions are not specified
-      if (!is_int($position)) {
-        $position = array_search($argument, $arguments);
-      }
-      $this->registerArgument($position, $argument);
-    }
-  }
-
-
-  /**
-  * @param int          $position
-  * @param BaseArgument $argument
-  *
-  * @throws ArgumentOrderException
-  */
-  public function registerArgument(int $position, BaseArgument $argument): void {
-    if ($position < 0) {
-      throw new ArgumentOrderException("You cannot register arguments at negative positions");
-    }
-    if ($position > 0 && !isset($this->argumentList[$position - 1])) {
-      throw new ArgumentOrderException("There were no arguments before $position");
-    }
-    foreach ($this->argumentList[$position - 1] ?? [] as $arg) {
-      if ($arg instanceof TextArgument) {
-        throw new ArgumentOrderException("No other arguments can be registered after a TextArgument");
-      }
-      if ($arg->isOptional() && !$argument->isOptional()) {
-        throw new ArgumentOrderException("You cannot register a required argument after an optional argument");
-      }
-    }
-    $this->argumentList[$position][] = $argument;
-    if (!$argument->isOptional()) {
-      $this->requiredArgumentCount[$position] = true;
-    }
-  }
-
-  public function parseArguments(array $rawArgs, CommandSender $sender): array {
-    $return = [
-      "arguments" => [],
-      "errors" => []
-    ];
-    // try parsing arguments
-    $required = count($this->requiredArgumentCount);
-    if (!$this->hasArguments() && count($rawArgs) > 0) {
-      // doesnt take args but sender gives args anyways
-      $return["errors"][] = [
-        "code" => BaseCommand::ERR_NO_ARGUMENTS,
-        "data" => []
-      ];
-    }
-    $offset = 0;
-    if (count($rawArgs) > 0) {
-      foreach ($this->argumentList as $pos => $possibleArguments) {
-        // try the one that spans more first... before the others
-        usort($possibleArguments, function (BaseArgument $a): int {
-          if ($a->getSpanLength() === PHP_INT_MAX) {
-            // if it takes unlimited arguments, pull it down
-            return 1;
-          }
-
-          return -1;
-        });
-        $parsed = false;
-        $optional = true;
-        foreach ($possibleArguments as $argument) {
-          $arg = trim(implode(" ", array_slice($rawArgs, $offset, ($len = $argument->getSpanLength()))));
-          if (!$argument->isOptional()) {
-            $optional = false;
-          }
-          if ($arg !== "" && $argument->canParse($arg, $sender)) {
-            $k = $argument->getName();
-            $result = (clone $argument)->parse($arg, $sender);
-            if (isset($return["arguments"][$k]) && !is_array($return["arguments"][$k])) {
-              $old = $return["arguments"][$k];
-              unset($return["arguments"][$k]);
-              $return["arguments"][$k] = [$old];
-              $return["arguments"][$k][] = $result;
-            } else {
-              $return["arguments"][$k] = $result;
-            }
-            if (!$optional) {
-              $required--;
-            }
-            $offset += $len;
-            $parsed = true;
-            break;
-          }
-          if ($offset > count($rawArgs)) {
-            break; // we've reached the end of the argument list the user passed
-          }
-        }
-        if (!$parsed && !($optional && empty($arg))) {
-          // we tried every other possible argument type, none was satisfied
-          $expectedArgs = $this->argumentList[$offset];
-          $expected = "";
-          foreach ($expectedArgs as $expectedArg) {
-            $expected .= $expectedArg->getTypeName() . "|";
-          }
-
-          $return["errors"][] = [
-            "code" => BaseCommand::ERR_INVALID_ARG_VALUE,
-            "data" => [
-              "value" => $rawArgs[$offset] ?? "",
-              "position" => $pos + 1,
-              "expected" => rtrim($expected, "|")
-            ]
-          ];
-
-          return $return; // let's break it here.
-        }
-      }
-    }
-    if ($offset < count($rawArgs)) {
-      // this means that the arguments our user sent is more than the needed amount
-      $return["errors"][] = [
-        "code" => BaseCommand::ERR_TOO_MANY_ARGUMENTS,
-        "data" => []
-      ];
-    }
-    if ($required > 0) {
-      // We still have more unfilled required arguments
-      $return["errors"][] = [
-        "code" => BaseCommand::ERR_INSUFFICIENT_ARGUMENTS,
-        "data" => []
-      ];
-    }
-
-    // up to my testing this occurs when BaseCommand::ERR_NO_ARGUMENTS and BaseCommand::ERR_TOO_MANY_ARGUMENTS are given as errors
-    // this only (as far as my testing) happens when command accepts arguments (e.g. a subcommand) but the user supplied invalid argument
-    // also the error code remains as shown due to the way they are passed
-    // have a better way? pr please :)
-    if (
-      count($return["errors"]) === 2 &&
-      $return["errors"][0]["code"] === BaseCommand::ERR_NO_ARGUMENTS &&
-      $return["errors"][1]["code"] === BaseCommand::ERR_TOO_MANY_ARGUMENTS
-    ) {
-      unset($return["errors"]);
-
-      $return["errors"][] = [
-        "code" => BaseCommand::ERR_INVALID_ARGUMENTS,
-        "data" => []
-      ];
-    }
-
-    return $return;
-  }
-
-  public function generateUsageMessage(string $parent = ""): string {
-    $name = $parent . (empty($parent) ? "" : " ") . $this->getName();
-    $msg = TextFormat::RED . "/" . $name;
-    $args = [];
-    foreach ($this->argumentList as $arguments) {
-      $hasOptional = false;
-      $names = [];
-      foreach ($arguments as $argument) {
-        $nameData = "";
-        if (!$argument->hideName()) {
-          $nameData .= $argument->getName() . ":";
-        }
-        $names[] = $nameData . $argument->getTypeName();
-        if ($argument->isOptional()) {
-          $hasOptional = true;
-        }
-      }
-      $names = implode("|", $names);
-      if ($hasOptional) {
-        $args[] = "[" . $names . "]";
-      } else {
-        $args[] = "<" . $names . ">";
-      }
-    }
-    $msg .= ((empty($args)) ? "" : " ") . implode(TextFormat::RED . " ", $args) . ": " . $this->getDescription();
-    foreach ($this->subCommands as $label => $subCommand) {
-      if ($label === $subCommand->getName()) {
-        $msg .= "\n - " . $subCommand->generateUsageMessage($name);
-      }
-    }
-
-    return trim($msg);
-  }
-
-  public function hasArguments(): bool {
-    return !empty($this->argumentList);
-  }
-
-  public function hasRequiredArguments(): bool {
-    foreach ($this->argumentList as $arguments) {
-      foreach ($arguments as $argument) {
-        if (!$argument->isOptional()) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  /**
-  * @return BaseArgument[][]
-  */
-  public function getArgumentList(): array {
-    return $this->argumentList;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/commando/traits/IArgumentable.php b/src/imperazim/vendor/commando/traits/IArgumentable.php
deleted file mode 100644
index 1b1424a..0000000
--- a/src/imperazim/vendor/commando/traits/IArgumentable.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\commando\traits;
-
-use pocketmine\command\CommandSender;
-use imperazim\vendor\commando\args\BaseArgument;
-
-interface IArgumentable {
-  public function generateUsageMessage(string $parent = ""): string;
-  public function hasArguments(): bool;
-
-  /**
-  * @return BaseArgument[][]
-  */
-  public function getArgumentList(): array;
-  public function parseArguments(array $rawArgs, CommandSender $sender): array;
-  public function registerArgument(int $position, BaseArgument $argument): void;
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/CustomiesManager.php b/src/imperazim/vendor/customies/CustomiesManager.php
index bd78af2..b2d10a6 100644
--- a/src/imperazim/vendor/customies/CustomiesManager.php
+++ b/src/imperazim/vendor/customies/CustomiesManager.php
@@ -10,6 +10,7 @@
 use pocketmine\scheduler\ClosureTask;
 use pocketmine\event\player\PlayerDropItemEvent;
 use pocketmine\event\player\PlayerInteractEvent;
+use pocketmine\event\entity\EntityDamageByEntityEvent;
 use pocketmine\event\server\DataPacketSendEvent;
 use pocketmine\network\mcpe\protocol\StartGamePacket;
 use pocketmine\network\mcpe\protocol\ItemRegistryPacket;
@@ -32,6 +33,7 @@
 use imperazim\components\plugin\PluginComponent;
 use imperazim\components\plugin\traits\PluginComponentsTrait;
 
+use imperazim\vendor\customies\task\ItemTask;
 use imperazim\vendor\customies\item\ItemComponents;
 use imperazim\vendor\customies\item\CustomiesItemFactory;
 use imperazim\vendor\customies\block\CustomiesBlockFactory;
@@ -72,11 +74,18 @@ public static function init(PluginToolkit $plugin): array {
         new self()
       ],
       self::SCHEDULER_COMPONENT => [
-        'type' => 'delayed',
-        'class' => new ClosureTask(static function () use ($cachePath): void {
-          CustomiesBlockFactory::getInstance()->addWorkerInitHook($cachePath);
-        }),
-        'sleep' => 0
+        [
+          'type' => 'delayed',
+          'class' => new ClosureTask(static function () use ($cachePath): void {
+            CustomiesBlockFactory::getInstance()->addWorkerInitHook($cachePath);
+          }),
+          'sleep' => 0
+        ],
+        [
+          'type' => 'repeating',
+          'class' => new ItemTask(),
+          'sleep' => 20
+        ]
       ]
     ];
   }
@@ -158,4 +167,22 @@ public function onTitle(InventoryTransactionEvent $event) : void {
     }
   }
 
+  public function onEntityDamage(EntityDamageByEntityEvent $event): void {
+    $damager = $event->getDamager();
+    $entity = $event->getEntity();
+
+    // Verifica se o agressor e a vítima são jogadores
+    if ($damager instanceof Player && $entity instanceof Player) {
+      $item = $damager->getInventory()->getItemInHand();
+
+      // Verifica se o item tem o cjogadores
+      if ($item instanceof ItemComponents) {
+        $component = $item->getComponents()['minecraft:on_hit_effect'];
+        if ($item->hasComponent($component->getName())) {
+          $component->applyEffect($entity);
+        }
+      }
+    }
+  }
+
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/ItemComponentsTrait.php b/src/imperazim/vendor/customies/item/ItemComponentsTrait.php
index 5baf048..3e1ffce 100644
--- a/src/imperazim/vendor/customies/item/ItemComponentsTrait.php
+++ b/src/imperazim/vendor/customies/item/ItemComponentsTrait.php
@@ -3,36 +3,38 @@
 
 namespace imperazim\vendor\customies\item;
 
-use imperazim\vendor\customies\item\component\AllowOffHandComponent;
-use imperazim\vendor\customies\item\component\ArmorComponent;
-use imperazim\vendor\customies\item\component\CanDestroyInCreativeComponent;
-use imperazim\vendor\customies\item\component\CooldownComponent;
-use imperazim\vendor\customies\item\component\CreativeCategoryComponent;
-use imperazim\vendor\customies\item\component\CreativeGroupComponent;
-use imperazim\vendor\customies\item\component\DisplayNameComponent;
-use imperazim\vendor\customies\item\component\DurabilityComponent;
+use imperazim\vendor\customies\util\NBT;
 use imperazim\vendor\customies\item\component\FoodComponent;
 use imperazim\vendor\customies\item\component\FuelComponent;
-use imperazim\vendor\customies\item\component\HandEquippedComponent;
 use imperazim\vendor\customies\item\component\IconComponent;
 use imperazim\vendor\customies\item\component\ItemComponent;
-use imperazim\vendor\customies\item\component\MaxStackSizeComponent;
-use imperazim\vendor\customies\item\component\ProjectileComponent;
-use imperazim\vendor\customies\item\component\RenderOffsetsComponent;
+use imperazim\vendor\customies\item\component\DamageComponent;
+use imperazim\vendor\customies\item\component\CooldownComponent;
+use imperazim\vendor\customies\item\component\WearableComponent;
 use imperazim\vendor\customies\item\component\ThrowableComponent;
-use imperazim\vendor\customies\item\component\UseAnimationComponent;
+use imperazim\vendor\customies\item\component\ProjectileComponent;
+use imperazim\vendor\customies\item\component\DurabilityComponent;
 use imperazim\vendor\customies\item\component\UseDurationComponent;
-use imperazim\vendor\customies\item\component\WearableComponent;
+use imperazim\vendor\customies\item\component\DisplayNameComponent;
+use imperazim\vendor\customies\item\component\HandEquippedComponent;
+use imperazim\vendor\customies\item\component\MaxStackSizeComponent;
+use imperazim\vendor\customies\item\component\AllowOffHandComponent;
+use imperazim\vendor\customies\item\component\UseAnimationComponent;
+use imperazim\vendor\customies\item\component\CreativeGroupComponent;
 use imperazim\vendor\customies\item\component\LockInInventoryComponent;
-use imperazim\vendor\customies\util\NBT;
-use pocketmine\entity\Consumable;
-use pocketmine\inventory\ArmorInventory;
+use imperazim\vendor\customies\item\component\CreativeCategoryComponent;
+use imperazim\vendor\customies\item\component\CanDestroyInCreativeComponent;
+
+use RuntimeException;
+use pocketmine\item\Food;
+use pocketmine\item\Tool;
 use pocketmine\item\Armor;
+use pocketmine\item\Sword;
 use pocketmine\item\Durable;
-use pocketmine\item\Food;
 use pocketmine\item\ProjectileItem;
+use pocketmine\entity\Consumable;
 use pocketmine\nbt\tag\CompoundTag;
-use RuntimeException;
+use pocketmine\inventory\ArmorInventory;
 
 trait ItemComponentsTrait {
 
@@ -85,8 +87,7 @@ protected function initComponent(string $texture, ?CreativeInventoryInfo $creati
         ArmorInventory::SLOT_FEET => WearableComponent::SLOT_ARMOR_FEET,
         default => WearableComponent::SLOT_ARMOR
         };
-        $this->addComponent(new ArmorComponent($this->getDefensePoints()));
-        $this->addComponent(new WearableComponent($slot));
+        $this->addComponent(new WearableComponent($slot, $this->getDefensePoints()));
       }
 
       if ($this instanceof Consumable) {
@@ -102,7 +103,7 @@ protected function initComponent(string $texture, ?CreativeInventoryInfo $creati
       }
 
       if ($this instanceof ProjectileItem) {
-        $this->addComponent(new ProjectileComponent("projectile"));
+        $this->addComponent(new ProjectileComponent(1.25, "projectile"));
         $this->addComponent(new ThrowableComponent(true));
       }
 
@@ -113,17 +114,16 @@ protected function initComponent(string $texture, ?CreativeInventoryInfo $creati
       if ($this->getFuelTime() > 0) {
         $this->addComponent(new FuelComponent($this->getFuelTime()));
       }
-    }
+      if ($this->getAttackPoints() > 0) {
+        $this->addComponent(new DamageComponent($this->getAttackPoints() - 1));
+      }
 
-    /**
-    * When a custom item has a texture that is not 16x16, the item will scale when held in a hand based on the size of
-    * the texture. This method adds the minecraft:render_offsets component with the correct data for the provided width
-    * and height of a texture to make the item scale correctly. An optional bool for hand equipped can be used if the
-    * item is something like a tool or weapon.
-    */
-    protected function setupRenderOffsets(int $width, int $height, bool $handEquipped = false): void {
-      $this->addComponent(new HandEquippedComponent($handEquipped));
-      $this->addComponent(new RenderOffsetsComponent($width, $height, $handEquipped));
+      if ($this instanceof Tool) {
+        $this->addComponent(new HandEquippedComponent());
+        if ($this instanceof Sword) {
+          $this->addComponent(new CanDestroyInCreativeComponent(false));
+        }
+      }
     }
 
     /**
diff --git a/src/imperazim/vendor/customies/item/component/AllowOffHandComponent.php b/src/imperazim/vendor/customies/item/component/AllowOffHandComponent.php
index 8df56ef..07538ae 100644
--- a/src/imperazim/vendor/customies/item/component/AllowOffHandComponent.php
+++ b/src/imperazim/vendor/customies/item/component/AllowOffHandComponent.php
@@ -1,25 +1,29 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class AllowOffHandComponent implements ItemComponent {
 
-	private bool $offHand;
+  private bool $offHand;
 
-	public function __construct(bool $offHand = true) {
-		$this->offHand = $offHand;
-	}
+  /**
+  * Determine whether an item can be placed in the off-hand slot of the inventory.
+  * @param bool $offHand Default is set to `true`
+  */
+  public function __construct(bool $offHand = true) {
+    $this->offHand = $offHand;
+  }
 
-	public function getName(): string {
-		return "allow_off_hand";
-	}
+  public function getName(): string {
+    return "allow_off_hand";
+  }
 
-	public function getValue(): bool {
-		return $this->offHand;
-	}
+  public function getValue(): bool {
+    return $this->offHand;
+  }
 
-	public function isProperty(): bool {
-		return true;
-	}
+  public function isProperty(): bool {
+    return true;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ArmorComponent.php b/src/imperazim/vendor/customies/item/component/ArmorComponent.php
deleted file mode 100644
index 8c14a2d..0000000
--- a/src/imperazim/vendor/customies/item/component/ArmorComponent.php
+++ /dev/null
@@ -1,40 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace imperazim\vendor\customies\item\component;
-
-final class ArmorComponent implements ItemComponent {
-
-	public const TEXTURE_TYPE_CHAIN = "chain";
-	public const TEXTURE_TYPE_DIAMOND = "diamond";
-	public const TEXTURE_TYPE_ELYTRA = "elytra";
-	public const TEXTURE_TYPE_GOLD = "gold";
-	public const TEXTURE_TYPE_IRON = "iron";
-	public const TEXTURE_TYPE_LEATHER = "leather";
-	public const TEXTURE_TYPE_NETHERITE = "netherite";
-	public const TEXTURE_TYPE_NONE = "none";
-	public const TEXTURE_TYPE_TURTLE = "turtle";
-
-	private int $protection;
-	private string $textureType;
-
-	public function __construct(int $protection, string $textureType = self::TEXTURE_TYPE_NONE) {
-		$this->protection = $protection;
-		$this->textureType = $textureType;
-	}
-
-	public function getName(): string {
-		return "minecraft:armor";
-	}
-
-	public function getValue(): array {
-		return [
-			"protection" => $this->protection,
-			"texture_type" => $this->textureType
-		];
-	}
-
-	public function isProperty(): bool {
-		return false;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/BlockPlacerComponent.php b/src/imperazim/vendor/customies/item/component/BlockPlacerComponent.php
index fd22f01..1222cc5 100644
--- a/src/imperazim/vendor/customies/item/component/BlockPlacerComponent.php
+++ b/src/imperazim/vendor/customies/item/component/BlockPlacerComponent.php
@@ -1,32 +1,49 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 use pocketmine\block\Block;
+use pocketmine\world\format\io\GlobalBlockStateHandlers;
 
 final class BlockPlacerComponent implements ItemComponent {
 
-    private string $blockIdentifier;
-    private bool $useBlockDescription;
-
-    public function __construct(string $blockIdentifier, bool $useBlockDescription = false) {
-        $this->blockIdentifier = $blockIdentifier;
-        $this->useBlockDescription = $useBlockDescription;
-    }
-
-    public function getName(): string {
-        return "minecraft:block_placer";
-    }
-
-    public function getValue(): array {
-        return [
-            "block" => $this->blockIdentifier,
-            "use_block_description" => $this->useBlockDescription
-        ];
-    }
-
-    public function isProperty(): bool {
-        return false;
+  private Block $block;
+  private array $useOn = [];
+
+  /**
+  * Sets the item as a Planter item component for blocks. Items with this component will place a block when used.
+  * @param Block $block
+  */
+  public function __construct(Block $block) {
+    $this->block = $block;
+  }
+
+  public function getName(): string {
+    return "minecraft:block_placer";
+  }
+
+  public function getValue(): array {
+    return [
+      "block" => GlobalBlockStateHandlers::getSerializer()->serialize($this->block->getStateId())->getName(),
+      "use_on" => $this->useOn
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+
+  /**
+  * Add blocks to the `use_on` array in the required format.
+  * @param Block ...$blocks
+  */
+  public function useOn(Block ...$blocks): self {
+    foreach ($blocks as $block) {
+      $this->useOn[] = [
+        "name" => GlobalBlockStateHandlers::getSerializer()->serialize($block->getStateId())->getName()
+      ];
     }
-}
+    return $this;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/BundleInteractionComponent.php b/src/imperazim/vendor/customies/item/component/BundleInteractionComponent.php
new file mode 100644
index 0000000..29f2bef
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/BundleInteractionComponent.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class BundleInteractionComponent implements ItemComponent {
+
+  private int $numViewableSlots;
+
+  /**
+  * `minecraft:bundle_interaction` enables the bundle-specific interaction scheme and tooltip for an item.
+  * To use this component, the item must have a `minecraft:storage_item` item component defined.
+  * @param int $numViewableSlots The number of slots that are viewable in the bundle.
+  */
+  public function __construct(int $numViewableSlots) {
+    $this->numViewableSlots = $numViewableSlots;
+  }
+
+  public function getName(): string {
+    return "minecraft:bundle_interaction";
+  }
+
+  public function getValue(): array {
+    return [
+      "num_viewable_slots" => $this->numViewableSlots
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ChargeableComponent.php b/src/imperazim/vendor/customies/item/component/ChargeableComponent.php
deleted file mode 100644
index f64bd1a..0000000
--- a/src/imperazim/vendor/customies/item/component/ChargeableComponent.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace imperazim\vendor\customies\item\component;
-
-final class ChargeableComponent implements ItemComponent {
-
-	private float $movementModifier;
-
-	public function __construct(float $movementModifier) {
-		$this->movementModifier = $movementModifier;
-	}
-
-	public function getName(): string {
-		return "minecraft:chargeable";
-	}
-
-	public function getValue(): array {
-		return [
-			"movement_modifier" => $this->movementModifier
-		];
-	}
-
-	public function isProperty(): bool {
-		return false;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/CooldownComponent.php b/src/imperazim/vendor/customies/item/component/CooldownComponent.php
index 038cf63..8f3caeb 100644
--- a/src/imperazim/vendor/customies/item/component/CooldownComponent.php
+++ b/src/imperazim/vendor/customies/item/component/CooldownComponent.php
@@ -1,30 +1,42 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class CooldownComponent implements ItemComponent {
 
-	private string $category;
-	private float $duration;
+  public const CATEGORY_SHIELD = "minecraft:shield";
+  public const CATEGORY_PEARL = "minecraft:ender_pearl";
+  public const CATEGORY_HORN = "minecraft:goat_horn";
+  public const CATEGORY_WINDCHARGE = "minecraft:wind_charge";
+  public const CATEGORY_CHORUS = "minecraft:chorusfruit";
 
-	public function __construct(string $category, float $duration) {
-		$this->category = $category;
-		$this->duration = $duration;
-	}
+  private string $category;
+  private float $duration;
 
-	public function getName(): string {
-		return "minecraft:cooldown";
-	}
+  /**
+  * Sets an item's "Cooldown" time.
+  * After using an item, it becomes unusable for the duration specified by the `duration` setting of this component.
+  * @param string $category The type of cool down for this item. All items with a cool down component with the same category are put on cool down when one is used
+  * @param float $duration The duration of time (in seconds) items with a matching category will spend cooling down before becoming usable again
+  */
+  public function __construct(string $category, float $duration) {
+    $this->category = $category;
+    $this->duration = $duration;
+  }
 
-	public function getValue(): array {
-		return [
-			"category" => $this->category,
-			"duration" => $this->duration
-		];
-	}
+  public function getName(): string {
+    return "minecraft:cooldown";
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function getValue(): array {
+    return [
+      "category" => $this->category,
+      "duration" => $this->duration
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DamageAbsorptionComponent.php b/src/imperazim/vendor/customies/item/component/DamageAbsorptionComponent.php
new file mode 100644
index 0000000..cb2fa15
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/DamageAbsorptionComponent.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class DamageAbsorptionComponent implements ItemComponent {
+
+  private array $absorbableCauses;
+
+  /**
+  * Causes the item to absorb damage that would otherwise be dealt to its wearer.
+  * For this to happen, the item needs to have the durability component and be equipped in an armor slot.
+  * @param array $absorbableCauses List of damage causes (such as entity_attack and magma) that can be absorbed by the item.
+  */
+  public function __construct(array $absorbableCauses) {
+    $this->absorbableCauses = $absorbableCauses;
+  }
+
+  public function getName(): string {
+    return "minecraft:damage_absorption";
+  }
+
+  public function getValue(): array {
+    return [
+      "absorbable_causes" => $this->absorbableCauses
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DamageComponent.php b/src/imperazim/vendor/customies/item/component/DamageComponent.php
new file mode 100644
index 0000000..016647c
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/DamageComponent.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class DamageComponent implements ItemComponent {
+
+  private int $damage;
+
+  /**
+  * Determines how much extra damage an item does on attack. Note that this must be a positive value.
+  * @param int $damage Should be a Intger above `0`
+  */
+  public function __construct(int $damage) {
+    $this->damage = $damage;
+  }
+
+  public function getName(): string {
+    return "damage";
+  }
+
+  public function getValue(): int {
+    return $this->damage;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DiggerComponent.php b/src/imperazim/vendor/customies/item/component/DiggerComponent.php
index 5d3521d..c5fb654 100644
--- a/src/imperazim/vendor/customies/item/component/DiggerComponent.php
+++ b/src/imperazim/vendor/customies/item/component/DiggerComponent.php
@@ -1,5 +1,5 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
@@ -10,42 +10,62 @@
 
 final class DiggerComponent implements ItemComponent {
 
-	private array $destroySpeeds;
-
-	public function getName(): string {
-		return "minecraft:digger";
-	}
-
-	public function getValue(): array {
-		return [
-			"destroy_speeds" => $this->destroySpeeds
-		];
-	}
-
-	public function isProperty(): bool {
-		return false;
-	}
-
-	public function withBlocks(int $speed, Block ...$blocks): DiggerComponent {
-		foreach($blocks as $block){
-			$this->destroySpeeds[] = [
-				"block" => [
-					"name" => GlobalBlockStateHandlers::getSerializer()->serialize($block->getStateId())->getName()
-				],
-				"speed" => $speed
-			];
-		}
-		return $this;
-	}
-
-	public function withTags(int $speed, string ...$tags): DiggerComponent {
-		$query = implode(",", array_map(fn($tag) => "'" . $tag . "'", $tags));
-		$this->destroySpeeds[] = [
-			"block" => [
-				"tags" => "query.any_tag(" . $query . ")"
-			],
-			"speed" => $speed
-		];
-		return $this;
-	}
+  private array $destroySpeeds;
+  private bool $useEfficiency;
+
+  /**
+  * Allows a creator to determine how quickly an item can dig specific blocks.
+  * @param bool $useEfficiency Determines whether the item should be impacted if the `efficiency` enchant is applied to it.
+  */
+  public function __construct(bool $useEfficiency) {
+    $this->useEfficiency = $useEfficiency;
+  }
+
+  public function getName(): string {
+    return "minecraft:digger";
+  }
+
+  public function getValue(): array {
+    return [
+      "destroy_speeds" => $this->destroySpeeds,
+      "use_efficiency" => $this->useEfficiency,
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+
+  /**
+  * Add blocks to the `destroy_speeds` array in the required format.
+  * @param int $speed Digging speed for the correlating block(s)
+  * @param Block ...$blocks A list of blocks to dig with correlating speeds of digging
+  */
+  public function withBlocks(int $speed, Block ...$blocks): DiggerComponent {
+    foreach ($blocks as $block) {
+      $this->destroySpeeds[] = [
+        "block" => [
+          "name" => GlobalBlockStateHandlers::getSerializer()->serialize($block->getStateId())->getName()
+        ],
+        "speed" => $speed
+      ];
+    }
+    return $this;
+  }
+
+  /**
+  * Add blocks to the `destroy_speeds` array in the required format.
+  * @param int $speed Digging speed for the correlating block(s)
+  * @param string ...$tags A list of blocks to dig with correlating speeds of digging
+  */
+  public function withTags(int $speed, string ...$tags): DiggerComponent {
+    $query = implode(",", array_map(fn($tag) => "'" . $tag . "'", $tags));
+    $this->destroySpeeds[] = [
+      "block" => [
+        "tags" => "query.any_tag(" . $query . ")"
+      ],
+      "speed" => $speed
+    ];
+    return $this;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DisplayNameComponent.php b/src/imperazim/vendor/customies/item/component/DisplayNameComponent.php
index 67838bf..afea1d0 100644
--- a/src/imperazim/vendor/customies/item/component/DisplayNameComponent.php
+++ b/src/imperazim/vendor/customies/item/component/DisplayNameComponent.php
@@ -1,27 +1,32 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class DisplayNameComponent implements ItemComponent {
 
-	private string $name;
+  private string $name;
 
-	public function __construct(string $name) {
-		$this->name = $name;
-	}
+  /**
+  * Sets the item display name within Minecraft: Bedrock Edition.
+  * This component may also be used to pull from the localization file by referencing a key from it.
+  * @param string $name Name shown for an item
+  */
+  public function __construct(string $name) {
+    $this->name = $name;
+  }
 
-	public function getName(): string {
-		return "minecraft:display_name";
-	}
+  public function getName(): string {
+    return "minecraft:display_name";
+  }
 
-	public function getValue(): array {
-		return [
-			"value" => $this->name
-		];
-	}
+  public function getValue(): array {
+    return [
+      "value" => $this->name
+    ];
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DurabilityComponent.php b/src/imperazim/vendor/customies/item/component/DurabilityComponent.php
index 1bfeec7..cc2a5f0 100644
--- a/src/imperazim/vendor/customies/item/component/DurabilityComponent.php
+++ b/src/imperazim/vendor/customies/item/component/DurabilityComponent.php
@@ -1,27 +1,41 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class DurabilityComponent implements ItemComponent {
 
-	private int $maxDurability;
+  private int $maxDurability;
+  private int $minDamageChance;
+  private int $maxDamageChance;
 
-	public function __construct(int $maxDurability) {
-		$this->maxDurability = $maxDurability;
-	}
+  /**
+  * Sets how much damage the item can take before breaking, and allows the item to be combined at an anvil, grindstone, or crafting table.
+  * @param int $maxDurability Max durability is the amount of damage that this item can take before breaking
+  * @param int $minDamageChance Specifies the percentage minimum chance for durability to take damage. Range: [0, 100]. Default is set to `100`
+  * @param int $maxDamageChance Specifies the percentage maximum chance for durability to take damage. Range: [0, 100]. Default is set to `100`
+  */
+  public function __construct(int $maxDurability, int $minDamageChance = 100, int $maxDamageChance = 100) {
+    $this->maxDurability = $maxDurability;
+    $this->minDamageChance = $minDamageChance;
+    $this->maxDamageChance = $maxDamageChance;
+  }
 
-	public function getName(): string {
-		return "minecraft:durability";
-	}
+  public function getName(): string {
+    return "minecraft:durability";
+  }
 
-	public function getValue(): array {
-		return [
-			"max_durability" => $this->maxDurability
-		];
-	}
+  public function getValue(): array {
+    return [
+      "damage_chance" => [
+        "min" => $this->minDamageChance,
+        "max" => $this->maxDamageChance
+      ],
+      "max_durability" => $this->maxDurability
+    ];
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/DyeableComponent.php b/src/imperazim/vendor/customies/item/component/DyeableComponent.php
new file mode 100644
index 0000000..912dd8c
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/DyeableComponent.php
@@ -0,0 +1,31 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class DyeableComponent implements ItemComponent {
+
+  private string $hex;
+
+  /**
+  * Allows the item to be dyed by cauldron water. Once dyed, the item will display the `dyed` texture defined in the `minecraft:icon` component rather than `default`.
+  * @param string $hex The hex color code (e.g "#47ff5a")
+  */
+  public function __construct(string $hex) {
+    $this->hex = $hex;
+  }
+
+  public function getName(): string {
+    return "minecraft:dyeable";
+  }
+
+  public function getValue(): array {
+    return [
+      "default_color" => $this->hex
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/EnchantableSlotComponent.php b/src/imperazim/vendor/customies/item/component/EnchantableSlotComponent.php
new file mode 100644
index 0000000..337f1ec
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/EnchantableSlotComponent.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class EnchantableSlotComponent implements ItemComponent {
+
+	public const SLOT_ALL = "all";
+	public const SLOT_BOOTS = "armor_feet";
+	public const SLOT_CHESTPLATE = "armor_torso";
+	public const SLOT_HELMET = "armor_head";
+	public const SLOT_LEGGINGS = "armor_legs";
+	public const SLOT_AXE = "axe";
+	public const SLOT_BOW = "bow";
+	public const SLOT_COSMETIC_HEAD = "cosmetic_head";
+	public const SLOT_CROSSBOW = "crossbow";
+	public const SLOT_ELYTRA = "elytra";
+	public const SLOT_FISHING_ROD = "fishing_rod";
+	public const SLOT_FLINT = "flintsteel";
+	public const SLOT_HOE = "hoe";
+	public const SLOT_PICKAXE = "pickaxe";
+	public const SLOT_SHEARS = "shears";
+	public const SLOT_SHIELD = "shield";
+	public const SLOT_SHOVEL = "shovel";
+	public const SLOT_SWORD = "sword";
+
+	private string $slot;
+
+	/**
+	 * What enchantments can be applied (ex. Using bow would allow this item to be enchanted as if it were a bow).
+	 * @param string $slot Specifies which types of enchantments can be applied. For example, `bow` would allow this item to be enchanted as if it were a bow
+	 */
+	public function __construct(string $slot = self::SLOT_ALL) {
+		$this->slot = $slot;
+	}
+
+	public function getName(): string {
+		return "enchantable_slot";
+	}
+
+	public function getValue(): string {
+		return $this->slot;
+	}
+
+	public function isProperty(): bool {
+		return true;
+	}
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/EnchantableValueComponent.php b/src/imperazim/vendor/customies/item/component/EnchantableValueComponent.php
new file mode 100644
index 0000000..6654df1
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/EnchantableValueComponent.php
@@ -0,0 +1,47 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class EnchantableValueComponent implements ItemComponent {
+
+  // Armor Enchantability
+  public const ARMOR_LEATHER = 15;
+  public const ARMOR_CHAIN = 12;
+  public const ARMOR_IRON = 9;
+  public const ARMOR_GOLD = 25;
+  public const ARMOR_DIAMOND = 10;
+  public const ARMOR_TURTLE = 9;
+  public const ARMOR_NETHERITE = 15;
+  public const ARMOR_OTHER = 1;
+  // Tool Enchantability
+  public const TOOL_WOOD = 15;
+  public const TOOL_STONE = 5;
+  public const TOOL_IRON = 14;
+  public const TOOL_GOLD = 22;
+  public const TOOL_DIAMOND = 10;
+  public const TOOL_NETHERITE = 15;
+  public const TOOL_OTHER = 1;
+
+  private int $value;
+
+  /**
+  * The value of the enchantment (minimum of 0).
+  * @param int $value Specifies the value of the enchantment, Default is set to `1`
+  */
+  public function __construct(int $value = 1) {
+    $this->value = $value;
+  }
+
+  public function getName(): string {
+    return "enchantable_value";
+  }
+
+  public function getValue(): int {
+    return $this->value;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/FoilComponent.php b/src/imperazim/vendor/customies/item/component/FoilComponent.php
deleted file mode 100644
index ff340a6..0000000
--- a/src/imperazim/vendor/customies/item/component/FoilComponent.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace imperazim\vendor\customies\item\component;
-
-final class FoilComponent implements ItemComponent {
-
-	private bool $foil;
-
-	public function __construct(bool $foil = true) {
-		$this->foil = $foil;
-	}
-
-	public function getName(): string {
-		return "foil";
-	}
-
-	public function getValue(): bool {
-		return $this->foil;
-	}
-
-	public function isProperty(): bool {
-		return true;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/FoodComponent.php b/src/imperazim/vendor/customies/item/component/FoodComponent.php
index c7e9993..06b887d 100644
--- a/src/imperazim/vendor/customies/item/component/FoodComponent.php
+++ b/src/imperazim/vendor/customies/item/component/FoodComponent.php
@@ -1,27 +1,45 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class FoodComponent implements ItemComponent {
 
-	private bool $canAlwaysEat;
+  private bool $canAlwaysEat;
+  private int $nutrition;
+  private float $saturationModifier;
+  private string $usingConvertsTo;
 
-	public function __construct(bool $canAlwaysEat = false) {
-		$this->canAlwaysEat = $canAlwaysEat;
-	}
+  /**
+  * Sets the item as a food component, allowing it to be edible to the player.
+  * @param bool $canAlwaysEat If true you can always eat this item (even when not hungry)
+  * @param int $nutrition Value that is added to the entity's nutrition when the item is used
+  * @param float $saturationModifier
+  * @param string $usingConvertsTo When used, converts to the item specified by the string in this field. Default does not convert item
+  */
+  public function __construct(bool $canAlwaysEat = false, int $nutrition = 0, float $saturationModifier = 0.6, string $usingConvertsTo = "") {
+    $this->canAlwaysEat = $canAlwaysEat;
+    $this->nutrition = $nutrition;
+    $this->saturationModifier = $saturationModifier;
+    $this->usingConvertsTo = $usingConvertsTo;
+  }
 
-	public function getName(): string {
-		return "minecraft:food";
-	}
+  public function getName(): string {
+    return "minecraft:food";
+  }
 
-	public function getValue(): array {
-		return [
-			"can_always_eat" => $this->canAlwaysEat
-		];
-	}
+  public function getValue(): array {
+    return [
+      "can_always_eat" => $this->canAlwaysEat,
+      "nutrition" => $this->nutrition,
+      "saturation_modifier" => $this->saturationModifier,
+      "using_converts_to" => [
+        "name" => $this->usingConvertsTo
+      ]
+    ];
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/FuelComponent.php b/src/imperazim/vendor/customies/item/component/FuelComponent.php
index ebf09a4..8f43e50 100644
--- a/src/imperazim/vendor/customies/item/component/FuelComponent.php
+++ b/src/imperazim/vendor/customies/item/component/FuelComponent.php
@@ -1,27 +1,31 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class FuelComponent implements ItemComponent {
 
-	private float $duration;
+  private float $duration;
 
-	public function __construct(float $duration) {
-		$this->duration = $duration;
-	}
+  /**
+  * Allows this item to be used as fuel in a furnace to 'cook' other items.
+  * @param float $duration Amount of time, in seconds, this fuel will cook items
+  */
+  public function __construct(float $duration) {
+    $this->duration = $duration;
+  }
 
-	public function getName(): string {
-		return "minecraft:fuel";
-	}
+  public function getName(): string {
+    return "minecraft:fuel";
+  }
 
-	public function getValue(): array {
-		return [
-			"duration" => $this->duration
-		];
-	}
+  public function getValue(): array {
+    return [
+      "duration" => $this->duration
+    ];
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/GlintComponent.php b/src/imperazim/vendor/customies/item/component/GlintComponent.php
new file mode 100644
index 0000000..0dda1f7
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/GlintComponent.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class GlintComponent implements ItemComponent {
+
+  private bool $glint;
+
+  /**
+  * Determines whether the item has the enchanted glint render effect on it.
+  * @param bool $glint Default is set to `true`
+  */
+  public function __construct(bool $glint = true) {
+    $this->glint = $glint;
+  }
+
+  public function getName(): string {
+    return "foil";
+  }
+
+  public function getValue(): bool {
+    return $this->glint;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/HandEquippedComponent.php b/src/imperazim/vendor/customies/item/component/HandEquippedComponent.php
index 36d6110..07d66b9 100644
--- a/src/imperazim/vendor/customies/item/component/HandEquippedComponent.php
+++ b/src/imperazim/vendor/customies/item/component/HandEquippedComponent.php
@@ -1,25 +1,29 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class HandEquippedComponent implements ItemComponent {
 
-	private bool $handEquipped;
+  private bool $handEquipped;
 
-	public function __construct(bool $handEquipped = true) {
-		$this->handEquipped = $handEquipped;
-	}
+  /**
+  * Determines if an item is rendered like a tool while in-hand.
+  * @param bool $handEquipped Default is set to `true`
+  */
+  public function __construct(bool $handEquipped = true) {
+    $this->handEquipped = $handEquipped;
+  }
 
-	public function getName(): string {
-		return "hand_equipped";
-	}
+  public function getName(): string {
+    return "hand_equipped";
+  }
 
-	public function getValue(): bool {
-		return $this->handEquipped;
-	}
+  public function getValue(): bool {
+    return $this->handEquipped;
+  }
 
-	public function isProperty(): bool {
-		return true;
-	}
+  public function isProperty(): bool {
+    return true;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/HoverTextColorComponent.php b/src/imperazim/vendor/customies/item/component/HoverTextColorComponent.php
new file mode 100644
index 0000000..f29750b
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/HoverTextColorComponent.php
@@ -0,0 +1,30 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class HoverTextColorComponent implements ItemComponent {
+
+  private string $hoverTextColor;
+
+  /**
+  * Determines the color of the item name when hovering over it.
+  * @param string $hoverTextColor Specifies the color of the item's hover text
+  * @link [List of Color Code](https://minecraft.wiki/w/Formatting_codes#Color_codes)
+  */
+  public function __construct(string $hoverTextColor) {
+    $this->hoverTextColor = $hoverTextColor;
+  }
+
+  public function getName(): string {
+    return "hover_text_color";
+  }
+
+  public function getValue(): string {
+    return $this->hoverTextColor;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/IconComponent.php b/src/imperazim/vendor/customies/item/component/IconComponent.php
index 0e90464..3dc8b2a 100644
--- a/src/imperazim/vendor/customies/item/component/IconComponent.php
+++ b/src/imperazim/vendor/customies/item/component/IconComponent.php
@@ -5,10 +5,20 @@
 
 final class IconComponent implements ItemComponent {
 
-	private string $texture;
+	private string $default_texture;
+	private string $dyed_texture;
+	private string $trim_texture;
 
-	public function __construct(string $texture) {
-		$this->texture = $texture;
+	/**
+	 * Determines the icon to represent the item in the UI and elsewhere.
+	 * @param string $default_texture the texture name should same as the `resource_pack/textures/item_texture.json` `texture_data`
+	 * @param string $dyed_texture Default is set to `None`
+	 * @param string $trim_texture Default is set to `None`
+	 */
+	public function __construct(string $default_texture, string $dyed_texture = "", string $trim_texture = "") {
+		$this->default_texture = $default_texture;
+		$this->dyed_texture = $dyed_texture;
+		$this->trim_texture = $trim_texture;
 	}
 
 	public function getName(): string {
@@ -17,8 +27,11 @@ public function getName(): string {
 
 	public function getValue(): array {
 		return [
+		  "texture" => $this->default_texture,
 			"textures" => [
-				"default" => $this->texture
+				"default" => $this->default_texture,
+				"dyed" => $this->dyed_texture,
+				"icon_trim" => $this->trim_texture
 			]
 		];
 	}
diff --git a/src/imperazim/vendor/customies/item/component/InteractButtonComponent.php b/src/imperazim/vendor/customies/item/component/InteractButtonComponent.php
new file mode 100644
index 0000000..7d08de1
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/InteractButtonComponent.php
@@ -0,0 +1,36 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class InteractButtonComponent implements ItemComponent {
+
+  private bool|string $interactButton;
+
+  /**
+  * Ineract Button is a boolean or string that determines if the interact button is shown in touch controls, and what text is displayed on the button. When set to 'true', the default 'Use Item' text will be used.
+  * @param bool|string $interactButton
+  */
+  public function __construct(bool|string $interactButton) {
+    if (is_bool($interactButton) === true) {
+      $this->interactButton = "action.interact.use";
+    } else {
+      $this->interactButton = (string) $interactButton;
+    }
+  }
+
+  public function getName(): string {
+    return "minecraft:interact_button";
+  }
+
+  public function getValue(): array {
+    return [
+      "interact_text" => (string) $this->interactButton,
+      "requires_interact" => 1
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ItemTaskComponent.php b/src/imperazim/vendor/customies/item/component/ItemTaskComponent.php
new file mode 100644
index 0000000..1b5fb59
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/ItemTaskComponent.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace imperazim\vendor\customies\item\component;
+
+use Closure;
+use pocketmine\player\Player;
+use pocketmine\item\Item;
+use imperazim\vendor\customies\item\ItemComponents;
+
+final class ItemTaskComponent implements ItemComponents {
+
+  public const FILTER_HAND = 'hand';
+  public const FILTER_INVENTORY = 'inventory';
+
+  private string $itemClass;
+  private Closure $callback;
+  private string $filter;
+
+  /**
+   * Creates a new ItemTaskComponent to define a task that checks for specific items in a player's inventory.
+   *
+   * @param string $itemClass The class of the item to check for (e.g., DiamondSword::class).
+   * @param Closure $callback The action to execute when the item is found. Receives the Player and Item as parameters.
+   * @param string $filter The location to check for the item. Use FILTER_HAND to check the main hand or FILTER_INVENTORY to check the entire inventory.
+   */
+  public function __construct(string $itemClass, Closure $callback, string $filter = self::FILTER_INVENTORY) {
+    $this->itemClass = $itemClass;
+    $this->callback = $callback;
+    $this->filter = $filter;
+  }
+
+  public function getName(): string {
+    return "minecraft:item_task";
+  }
+
+  public function getValue(): array {
+    return [
+      'item_class' => $this->itemClass,
+      'filter' => $this->filter,
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+
+  public function checkCondition(Player $player): ?Item {
+    $inventory = $player->getInventory();
+    switch ($this->filter) {
+      case self::FILTER_HAND:
+        $item = $inventory->getItemInHand();
+        return $item instanceof $this->itemClass ? $item : null;
+      default:
+        foreach ($inventory->getContents() as $item) {
+          if ($item instanceof $this->itemClass) {
+            return $item;
+          }
+        }
+        return null;
+    }
+  }
+
+  public function execute(Player $player, Item $item): void {
+    ($this->callback)($player, $item);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/KnockbackResistanceComponent.php b/src/imperazim/vendor/customies/item/component/KnockbackResistanceComponent.php
deleted file mode 100644
index 7177882..0000000
--- a/src/imperazim/vendor/customies/item/component/KnockbackResistanceComponent.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace imperazim\vendor\customies\item\component;
-
-final class KnockbackResistanceComponent implements ItemComponent {
-
-	private float $protection;
-
-	public function __construct(float $protection) {
-		$this->protection = $protection;
-	}
-
-	public function getName(): string {
-		return "minecraft:knockback_resistance";
-	}
-
-	public function getValue(): array {
-		return [
-			"protection" => $this->protection
-		];
-	}
-
-	public function isProperty(): bool {
-		return false;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/LiquidClippedComponent.php b/src/imperazim/vendor/customies/item/component/LiquidClippedComponent.php
new file mode 100644
index 0000000..fef848f
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/LiquidClippedComponent.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class LiquidClippedComponent implements ItemComponent {
+
+  private bool $liquidClipped;
+
+  /**
+  * Determines whether an item interacts with liquid blocks on use.
+  * @param bool $liquidClipped If the item interacts with liquid blocks on use
+  */
+  public function __construct(bool $liquidClipped = true) {
+    $this->liquidClipped = $liquidClipped;
+  }
+
+  public function getName(): string {
+    return "liquid_clipped";
+  }
+
+  public function getValue(): bool {
+    return $this->liquidClipped;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/MaxStackSizeComponent.php b/src/imperazim/vendor/customies/item/component/MaxStackSizeComponent.php
index 52e86bd..4f5df55 100644
--- a/src/imperazim/vendor/customies/item/component/MaxStackSizeComponent.php
+++ b/src/imperazim/vendor/customies/item/component/MaxStackSizeComponent.php
@@ -1,25 +1,29 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class MaxStackSizeComponent implements ItemComponent {
 
-	private int $maxStackSize;
+  private int $maxStackSize;
 
-	public function __construct(int $maxStackSize) {
-		$this->maxStackSize = $maxStackSize;
-	}
+  /**
+  * Determines how many of an item can be stacked together.
+  * @param int $maxStackSize Max Size, Default is set to `64`
+  */
+  public function __construct(int $maxStackSize = 64) {
+    $this->maxStackSize = $maxStackSize;
+  }
 
-	public function getName(): string {
-		return "max_stack_size";
-	}
+  public function getName(): string {
+    return "max_stack_size";
+  }
 
-	public function getValue(): int {
-		return $this->maxStackSize;
-	}
+  public function getValue(): int {
+    return $this->maxStackSize;
+  }
 
-	public function isProperty(): bool {
-		return true;
-	}
+  public function isProperty(): bool {
+    return true;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/OnHitEffectComponent.php b/src/imperazim/vendor/customies/item/component/OnHitEffectComponent.php
new file mode 100644
index 0000000..9f0f838
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/OnHitEffectComponent.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+use pocketmine\entity\effect\EffectInstance;
+use pocketmine\entity\effect\VanillaEffects;
+use pocketmine\item\Item;
+use pocketmine\player\Player;
+use pocketmine\plugin\Plugin;
+use imperazim\vendor\customies\item\ItemComponents;
+
+final class OnHitEffectComponent implements ItemComponents {
+
+  private EffectInstance $effect;
+  private Plugin $plugin;
+
+  /**
+  * Creates a new OnHitEffectComponent to apply an effect to a player when hit with the item.
+  *
+  * @param Plugin $plugin The plugin instance to register the event listener.
+  * @param EffectInstance $effect The effect to apply to the player when hit.
+  */
+  public function __construct(Plugin $plugin, EffectInstance $effect) {
+    $this->plugin = $plugin;
+    $this->effect = $effect;
+    $this->plugin->getServer()->getPluginManager()->registerEvents($this, $plugin);
+  }
+
+  public function getName(): string {
+    return "minecraft:on_hit_effect";
+  }
+
+  public function getValue(): array {
+    return [
+      'effect_id' => $this->effect->getType()->getId(),
+      'effect_duration' => $this->effect->getDuration(),
+      'effect_amplifier' => $this->effect->getAmplifier(),
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+
+  public function applyEffect(Player $entity): void {
+    $entity->getEffects()->add($this->effect);
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ProjectileComponent.php b/src/imperazim/vendor/customies/item/component/ProjectileComponent.php
index 574d93e..089645a 100644
--- a/src/imperazim/vendor/customies/item/component/ProjectileComponent.php
+++ b/src/imperazim/vendor/customies/item/component/ProjectileComponent.php
@@ -4,10 +4,19 @@
 namespace imperazim\vendor\customies\item\component;
 
 final class ProjectileComponent implements ItemComponent {
-
+  
+  private float $minimumCriticalPower;
 	private string $projectileEntity;
 
-	public function __construct(string $projectileEntity) {
+	/**
+	 * Projectile Component compels the item to shoot, similarly to an arrow. 
+	 * Items with projectile component can be shot from dispensers or used as ammunition for items with the shooter item component. 
+	 * Additionally, this component sets the entity that is spawned for items that also contain the throwable component.
+	 * @param float $minimumCriticalPower Specifies how long a player must charge a projectile for it to critically hit
+	 * @param string $projectileEntity Which entity is to be fired as a projectile
+	 */
+	public function __construct(float $minimumCriticalPower, string $projectileEntity) {
+		$this->minimumCriticalPower = $minimumCriticalPower;
 		$this->projectileEntity = $projectileEntity;
 	}
 
@@ -17,6 +26,7 @@ public function getName(): string {
 
 	public function getValue(): array {
 		return [
+		  "minimum_critical_power" => $this->minimumCriticalPower,
 			"projectile_entity" => $this->projectileEntity
 		];
 	}
diff --git a/src/imperazim/vendor/customies/item/component/RarityComponent.php b/src/imperazim/vendor/customies/item/component/RarityComponent.php
new file mode 100644
index 0000000..704c8a1
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/RarityComponent.php
@@ -0,0 +1,37 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class RarityComponent implements ItemComponent {
+
+  public const COMMON = "common";
+  public const UNCOMMON = "uncommon";
+  public const RARE = "rare";
+  public const EPIC = "epic";
+
+  private string $rarity;
+
+  /**
+  * Rarity Component enables the specifying of the base rarity of an item.
+  * The rarity of the item will determine which color it uses for its name, unless the item has a HoverTextColor component specified, in which case that hover text color will take priority and be used instead of the rarity color.
+  * @param string $type Sets the base rarity of the item. The rarity of an item automatically increases when enchanted, either to Rare when the base rarity is Common or Uncommon, or Epic when the base rarity is Rare
+  */
+  public function __construct(string $rarity = self::COMMON) {
+    $this->rarity = $rarity;
+  }
+
+  public function getName(): string {
+    return "minecraft:rarity";
+  }
+
+  public function getValue(): array {
+    return [
+      "value" => $this->rarity
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/RecordComponent.php b/src/imperazim/vendor/customies/item/component/RecordComponent.php
new file mode 100644
index 0000000..59a9d33
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/RecordComponent.php
@@ -0,0 +1,39 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class RecordComponent implements ItemComponent {
+
+  private int $comparatorSignal;
+  private float $duration;
+  private string $soundEvent;
+
+  /**
+  * Record Component used by record items to play music.
+  * @param int $comparatorSignal Specifies signal strength for comparator blocks to use, from 1 - 13
+  * @param float $duration Specifies duration of sound event in seconds, float value
+  * @param string $soundEvent Sound event type: 13, cat, blocks, chirp, far, mall, mellohi, stal, strad, ward, 11, wait, pigstep, otherside, 5, relic
+  */
+  public function __construct(int $comparatorSignal = 1, float $duration, string $soundEvent = "undefined") {
+    $this->comparatorSignal = $comparatorSignal;
+    $this->duration = $duration;
+    $this->soundEvent = $soundEvent;
+  }
+
+  public function getName(): string {
+    return "minecraft:record";
+  }
+
+  public function getValue(): array {
+    return [
+      "comparator_signal" => $this->comparatorSignal,
+      "duration" => $this->duration,
+      "sound_event" => $this->soundEvent
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/RenderOffsetsComponent.php b/src/imperazim/vendor/customies/item/component/RenderOffsetsComponent.php
deleted file mode 100644
index 8e9cce4..0000000
--- a/src/imperazim/vendor/customies/item/component/RenderOffsetsComponent.php
+++ /dev/null
@@ -1,42 +0,0 @@
-<?php
-declare(strict_types=1);
-
-namespace imperazim\vendor\customies\item\component;
-
-final class RenderOffsetsComponent implements ItemComponent {
-
-	private int $textureWidth;
-	private int $textureHeight;
-	private bool $handEquipped;
-
-	public function __construct(int $textureWidth, int $textureHeight, bool $handEquipped = false) {
-		$this->textureWidth = $textureWidth;
-		$this->textureHeight = $textureHeight;
-		$this->handEquipped = $handEquipped;
-	}
-
-	public function getName(): string {
-		return "minecraft:render_offsets";
-	}
-
-	public function getValue(): array {
-		$horizontal = ($this->handEquipped ? 0.075 : 0.1) / ($this->textureWidth / 16);
-		$vertical = ($this->handEquipped ? 0.125 : 0.1) / ($this->textureHeight / 16);
-		$perspectives = [
-			"first_person" => [
-				"scale" => [$horizontal, $vertical, $horizontal],
-			],
-			"third_person" => [
-				"scale" => [$horizontal, $vertical, $horizontal]
-			]
-		];
-		return [
-			"main_hand" => $perspectives,
-			"off_hand" => $perspectives
-		];
-	}
-
-	public function isProperty(): bool {
-		return false;
-	}
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ShooterComponent.php b/src/imperazim/vendor/customies/item/component/ShooterComponent.php
new file mode 100644
index 0000000..61b1a2c
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/ShooterComponent.php
@@ -0,0 +1,61 @@
+<?php
+declare(strict_types=1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class ShooterComponent implements ItemComponent {
+
+	private bool $chargeOnDraw;
+	private float $maxDrawDuration;
+	private bool $scalePowerByDrawDuration;
+
+	private string $item;
+	private bool $useOffhand;
+	private bool $searchInventory;
+	private bool $useInCreative;
+
+	/**
+	 * Shooter component compels an item to shoot projectiles, similarly to a bow or crossbow. 
+	 * Must have the use_modifiers component in order to function properly.
+	 * @param string $item Ammunition item
+	 * @param bool $useOffhand Can use off-hand? Default is set to false
+	 * @param bool $searchInventory Can search inventory? Default is set to fals
+	 * @param bool $useInCreative Can use in creative mode? Default is set to false
+	 * @param bool $chargeOnDraw Charge on draw? Default is set to false
+	 * @param float $maxDrawDuration Draw Duration. Default is set to 0
+	 * @param bool $scalePowerByDrawDuration Scale power by draw duration? Default is set to false
+	 */
+	public function __construct(string $item, bool $useOffhand = false, bool $searchInventory = false, bool $useInCreative = false, bool $chargeOnDraw = false, float $maxDrawDuration = 0.0, bool $scalePowerByDrawDuration = false) {
+		$this->item = $item;
+		$this->useOffhand = $useOffhand;
+		$this->searchInventory = $searchInventory;
+		$this->useInCreative = $useInCreative;
+		$this->chargeOnDraw = $chargeOnDraw;
+		$this->maxDrawDuration = $maxDrawDuration;
+		$this->scalePowerByDrawDuration = $scalePowerByDrawDuration;
+	}
+
+	public function getName(): string {
+		return "minecraft:shooter";
+	}
+
+	public function getValue(): array {
+		return [
+			"ammunition" => [
+				[
+					"item" => $this->item,
+					"use_offhand" => $this->useOffhand,
+					"search_inventory" => $this->searchInventory,
+					"use_in_creative" => $this->useInCreative
+				]
+			],
+			"charge_on_draw" => $this->chargeOnDraw,
+			"max_draw_duration" => $this->maxDrawDuration,
+			"scale_power_by_draw_duration" => $this->scalePowerByDrawDuration
+		];
+	}
+
+	public function isProperty(): bool {
+		return false;
+	}
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ShouldDespawnComponent.php b/src/imperazim/vendor/customies/item/component/ShouldDespawnComponent.php
new file mode 100644
index 0000000..efe57a4
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/ShouldDespawnComponent.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class ShouldDespawnComponent implements ItemComponent {
+
+  private bool $shouldDespawn;
+
+  /**
+  * Determines if an item should despawn while floating in the world.
+  * @param bool $shouldDespawn item should eventually despawn while floating in the world, Default is set to `true`
+  */
+  public function __construct(bool $shouldDespawn = true) {
+    $this->shouldDespawn = $shouldDespawn;
+  }
+
+  public function getName(): string {
+    return "should_despawn";
+  }
+
+  public function getValue(): bool {
+    return $this->shouldDespawn;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/StackedByDataComponent.php b/src/imperazim/vendor/customies/item/component/StackedByDataComponent.php
new file mode 100644
index 0000000..3b21434
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/StackedByDataComponent.php
@@ -0,0 +1,30 @@
+<?php
+declare(strict_types=1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class StackedByDataComponent implements ItemComponent {
+
+	private bool $stackedByData;
+
+	/**
+	 * Determines if the same item with different aux values can stack. 
+	 * Additionally, this component defines whether the item actors can merge while floating in the world.
+	 * @param bool $stackedByData Should item stack, Default is set to `true`
+	 */
+	public function __construct(bool $stackedByData = true) {
+		$this->stackedByData = $stackedByData;
+	}
+
+	public function getName(): string {
+		return "stacked_by_data";
+	}
+
+	public function getValue(): bool {
+		return $this->stackedByData;
+	}
+
+	public function isProperty(): bool {
+		return true;
+	}
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/ThrowableComponent.php b/src/imperazim/vendor/customies/item/component/ThrowableComponent.php
index df58a9d..97bc401 100644
--- a/src/imperazim/vendor/customies/item/component/ThrowableComponent.php
+++ b/src/imperazim/vendor/customies/item/component/ThrowableComponent.php
@@ -1,27 +1,51 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class ThrowableComponent implements ItemComponent {
 
-	private bool $doSwingAnimation;
+  private bool $doSwingAnimation;
+	private float $launchPowerScale;
+	private float $maxDrawDuration;
+	private float $maxLaunchPower;
+	private float $minDrawDuration;
+	private bool $scalePowerByDrawDuration;
 
-	public function __construct(bool $doSwingAnimation) {
-		$this->doSwingAnimation = $doSwingAnimation;
-	}
+  /**
+  * Sets the throwable item component.
+  * @param bool $doSwingAnimation Determines whether the item should use the swing animation when thrown
+  * @param float $launchPowerScale The scale at which the power of the throw increases
+  * @param float $maxDrawDuration The maximum duration to draw a throwable item
+  * @param float $maxLaunchPower The maximum power to launch the throwable item
+  * @param float $minDrawDuration The minimum duration to draw a throwable item
+  * @param bool $scalePowerByDrawDuration Whether or not the power of the throw increases with duration charged
+  */
+  public function __construct(bool $doSwingAnimation = false, float $launchPowerScale = 1.0, float $maxDrawDuration = 0.0, float $maxLaunchPower = 1.0, float $minDrawDuration = 0.0, bool $scalePowerByDrawDuration = false) {
+    $this->doSwingAnimation = $doSwingAnimation;
+    $this->launchPowerScale = $launchPowerScale;
+    $this->maxDrawDuration = $maxDrawDuration;
+    $this->maxLaunchPower = $maxLaunchPower;
+    $this->minDrawDuration = $minDrawDuration;
+    $this->scalePowerByDrawDuration = $scalePowerByDrawDuration;
+  }
 
-	public function getName(): string {
-		return "minecraft:throwable";
-	}
+  public function getName(): string {
+    return "minecraft:throwable";
+  }
 
-	public function getValue(): array {
-		return [
-			"do_swing_animation" => $this->doSwingAnimation
-		];
-	}
+  public function getValue(): array {
+    return [
+      "do_swing_animation" => $this->doSwingAnimation,
+      "launch_power_scale" => $this->launchPowerScale,
+      "max_draw_duration" => $this->maxDrawDuration,
+      "max_launch_power" => $this->maxLaunchPower,
+      "min_draw_duration" => $this->minDrawDuration,
+      "scale_power_by_draw_duration" => $this->scalePowerByDrawDuration
+    ];
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/UseAnimationComponent.php b/src/imperazim/vendor/customies/item/component/UseAnimationComponent.php
index f45e59d..1d58458 100644
--- a/src/imperazim/vendor/customies/item/component/UseAnimationComponent.php
+++ b/src/imperazim/vendor/customies/item/component/UseAnimationComponent.php
@@ -1,28 +1,40 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class UseAnimationComponent implements ItemComponent {
 
-	public const ANIMATION_EAT = 1;
-	public const ANIMATION_DRINK = 2;
-
-	private int $animation;
-
-	public function __construct(int $animation) {
-		$this->animation = $animation;
-	}
-
-	public function getName(): string {
-		return "use_animation";
-	}
-
-	public function getValue(): int {
-		return $this->animation;
-	}
-
-	public function isProperty(): bool {
-		return true;
-	}
+  public const ANIMATION_NONE = 0;
+  public const ANIMATION_EAT = 1;
+  public const ANIMATION_DRINK = 2;
+  public const ANIMATION_BLOCK = 3;
+  public const ANIMATION_BOW = 4;
+  public const ANIMATION_CAMERA = 5;
+  public const ANIMATION_SPEAR = 6;
+  public const ANIMATION_CROSSBOW = 9;
+  public const ANIMATION_SPYGLASS = 10;
+  public const ANIMATION_BRUSH = 12;
+
+  private int $animation;
+
+  /**
+  * Determines which animation plays when using an item.
+  * @param int $animation Specifies which animation to play when the the item is used, Default is set to `0`
+  */
+  public function __construct(int $animation) {
+    $this->animation = $animation;
+  }
+
+  public function getName(): string {
+    return "use_animation";
+  }
+
+  public function getValue(): int {
+    return $this->animation;
+  }
+
+  public function isProperty(): bool {
+    return true;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/UseDurationComponent.php b/src/imperazim/vendor/customies/item/component/UseDurationComponent.php
index 3acad91..ab755bb 100644
--- a/src/imperazim/vendor/customies/item/component/UseDurationComponent.php
+++ b/src/imperazim/vendor/customies/item/component/UseDurationComponent.php
@@ -1,25 +1,29 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class UseDurationComponent implements ItemComponent {
 
-	private int $duration;
+  private int $duration;
 
-	public function __construct(int $duration) {
-		$this->duration = $duration;
-	}
+  /**
+  * How long the item takes to use in seconds.
+  * @param int $duration Default is set to `20` (`20` means `1` seconds) so (`32` means `1.6` seconds)
+  */
+  public function __construct(int $duration = 20) {
+    $this->duration = $duration;
+  }
 
-	public function getName(): string {
-		return "use_duration";
-	}
+  public function getName(): string {
+    return "use_duration";
+  }
 
-	public function getValue(): int {
-		return $this->duration;
-	}
+  public function getValue(): int {
+    return $this->duration;
+  }
 
-	public function isProperty(): bool {
-		return true;
-	}
+  public function isProperty(): bool {
+    return true;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/UseModifiersComponent.php b/src/imperazim/vendor/customies/item/component/UseModifiersComponent.php
new file mode 100644
index 0000000..2a0397a
--- /dev/null
+++ b/src/imperazim/vendor/customies/item/component/UseModifiersComponent.php
@@ -0,0 +1,35 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\item\component;
+
+final class UseModifiersComponent implements ItemComponent {
+
+  private float $useDuration;
+  private float $movementModifier;
+
+  /**
+  * Determines how long an item takes to use in combination with components such as Shooter, Throwable, or Food.
+  * @param float $useDuration How long the item takes to use in seconds
+  * @param float $movementModifier Modifier value to scale the players movement speed when item is in use
+  */
+  public function __construct(float $movementModifier, float $useDuration = 0) {
+    $this->useDuration = $useDuration;
+    $this->movementModifier = $movementModifier;
+  }
+
+  public function getName(): string {
+    return "minecraft:use_modifiers";
+  }
+
+  public function getValue(): array {
+    return [
+      "movement_modifier" => $this->movementModifier,
+      "use_duration" => $this->useDuration
+    ];
+  }
+
+  public function isProperty(): bool {
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/item/component/WearableComponent.php b/src/imperazim/vendor/customies/item/component/WearableComponent.php
index 9c47731..8aae31b 100644
--- a/src/imperazim/vendor/customies/item/component/WearableComponent.php
+++ b/src/imperazim/vendor/customies/item/component/WearableComponent.php
@@ -1,42 +1,55 @@
 <?php
-declare(strict_types=1);
+declare(strict_types = 1);
 
 namespace imperazim\vendor\customies\item\component;
 
 final class WearableComponent implements ItemComponent {
 
-	public const SLOT_ARMOR = "slot.armor";
-	public const SLOT_ARMOR_CHEST = "slot.armor.chest";
-	public const SLOT_ARMOR_FEET = "slot.armor.feet";
-	public const SLOT_ARMOR_HEAD = "slot.armor.head";
-	public const SLOT_ARMOR_LEGS = "slot.armor.legs";
-	public const SLOT_CHEST = "slot.chest";
-	public const SLOT_ENDERCHEST = "slot.enderchest";
-	public const SLOT_EQUIPPABLE = "slot.equippable";
-	public const SLOT_HOTBAR = "slot.hotbar";
-	public const SLOT_INVENTORY = "slot.inventory";
-	public const SLOT_NONE = "none";
-	public const SLOT_SADDLE = "slot.saddle";
-	public const SLOT_WEAPON_MAIN_HAND = "slot.weapon.mainhand";
-	public const SLOT_WEAPON_OFF_HAND = "slot.weapon.offhand";
-
-	private string $slot;
-
-	public function __construct(string $slot) {
-		$this->slot = $slot;
-	}
-
-	public function getName(): string {
-		return "minecraft:wearable";
-	}
-
-	public function getValue(): array {
-		return [
-			"slot" => $this->slot
+  public const SLOT_ARMOR = "slot.armor";
+  public const SLOT_ARMOR_CHEST = "slot.armor.chest";
+  public const SLOT_ARMOR_FEET = "slot.armor.feet";
+  public const SLOT_ARMOR_HEAD = "slot.armor.head";
+  public const SLOT_ARMOR_LEGS = "slot.armor.legs";
+  public const SLOT_CHEST = "slot.chest";
+  public const SLOT_ENDERCHEST = "slot.enderchest";
+  public const SLOT_EQUIPPABLE = "slot.equippable";
+  public const SLOT_HOTBAR = "slot.hotbar";
+  public const SLOT_INVENTORY = "slot.inventory";
+  public const SLOT_NONE = "none";
+  public const SLOT_SADDLE = "slot.saddle";
+  public const SLOT_WEAPON_MAIN_HAND = "slot.weapon.mainhand";
+  public const SLOT_WEAPON_OFF_HAND = "slot.weapon.offhand";
+
+  private string $slot;
+
+  private int $protection;
+  private bool $dispensable;
+
+  /**
+  * Sets the wearable item component.
+  * @param string $slot Specifies where the item can be worn
+  * @param int $protection How much protection the wearable item provides
+  * @param bool $dispensable Whether the wearable item can be dispensed
+  */
+  public function __construct(string $slot, int $protection = 0, bool $dispensable = true) {
+    $this->slot = $slot;
+    $this->protection = $protection;
+    $this->dispensable = $dispensable;
+  }
+
+  public function getName(): string {
+    return "minecraft:wearable";
+  }
+
+  public function getValue(): array {
+    return [
+      "slot" => $this->slot,
+			"protection" => $this->protection,
+			"dispensable" => $this->dispensable
 		];
-	}
+  }
 
-	public function isProperty(): bool {
-		return false;
-	}
+  public function isProperty(): bool {
+    return false;
+  }
 }
\ No newline at end of file
diff --git a/src/imperazim/vendor/customies/task/ItemTask.php b/src/imperazim/vendor/customies/task/ItemTask.php
new file mode 100644
index 0000000..832055d
--- /dev/null
+++ b/src/imperazim/vendor/customies/task/ItemTask.php
@@ -0,0 +1,31 @@
+<?php
+declare(strict_types = 1);
+
+namespace imperazim\vendor\customies\task;
+
+use pocketmine\Server;
+use pocketmine\scheduler\Task;
+use imperazim\vendor\customies\item\ItemComponents;
+use imperazim\vendor\customies\item\CustomiesItemFactory;
+
+final class ItemTask extends Task {
+
+  public function onRun(): void {
+    $server = Server::getInstance();
+
+    foreach ($server->getOnlinePlayers() as $player) {
+      $inventory = $player->getInventory();
+
+      foreach ($inventory->getContents() as $item) {
+        if ($item instanceof ItemComponents && $item->hasComponent("minecraft:item_task")) {
+          /** @var \imperazim\vendor\customies\item\component\ItemTaskComponent $component */
+          $component = $item->getComponent("minecraft:item_task");
+
+          if ($itemInstance = $component->checkCondition($player)) {
+            $component->execute($player, $itemInstance);
+          }
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/imperazim/bugfixes/BugFixesListener.php b/src/imperazim/vendor/fix/BugFixesListener.php
similarity index 96%
rename from src/imperazim/bugfixes/BugFixesListener.php
rename to src/imperazim/vendor/fix/BugFixesListener.php
index aabaeb0..579c997 100644
--- a/src/imperazim/bugfixes/BugFixesListener.php
+++ b/src/imperazim/vendor/fix/BugFixesListener.php
@@ -2,7 +2,7 @@
 
 declare(strict_types = 1);
 
-namespace imperazim\bugfixes;
+namespace imperazim\vendor\fix;
 
 use pocketmine\math\Facing;
 use pocketmine\player\Player;
@@ -17,7 +17,7 @@
 * Specifically, it listens for suffocation events and tries to prevent the player
 * from taking damage by checking if there is space for the player to move.
 *
-* @package imperazim\bugfixes
+* @package imperazim\vendor\fix
 */
 final class BugFixesListener implements Listener {
 
diff --git a/src/imperazim/bugfixes/BugFixesManager.php b/src/imperazim/vendor/fix/BugFixesManager.php
similarity index 90%
rename from src/imperazim/bugfixes/BugFixesManager.php
rename to src/imperazim/vendor/fix/BugFixesManager.php
index f9d7803..2715cda 100644
--- a/src/imperazim/bugfixes/BugFixesManager.php
+++ b/src/imperazim/vendor/fix/BugFixesManager.php
@@ -2,7 +2,7 @@
 
 declare(strict_types = 1);
 
-namespace imperazim\bugfixes;
+namespace imperazim\vendor\fix;
 
 use imperazim\components\plugin\PluginToolkit;
 use imperazim\components\plugin\PluginComponent;
@@ -10,7 +10,7 @@
 
 /**
 * Class BugFixesManager
-* @package imperazim\bugfixes
+* @package imperazim\vendor\fix
 */
 final class BugFixesManager extends PluginComponent {
   use PluginComponentsTrait;
diff --git a/src/imperazim/vendor/libform/Form.php b/src/imperazim/vendor/libform/Form.php
deleted file mode 100644
index 2b9ebe0..0000000
--- a/src/imperazim/vendor/libform/Form.php
+++ /dev/null
@@ -1,72 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform;
-
-use pocketmine\player\Player;
-use pocketmine\form\Form as IForm;
-use imperazim\vendor\libform\elements\Title;
-
-/**
-* Class Form
-* @package imperazim\vendor\libform
-*/
-abstract class Form implements IForm {
-
-  /**
-  * Form constructor.
-  * @param Title $title The title of the form.
-  */
-  public function __construct(
-    protected ?Title $title = new Title('')
-  ) {}
-
-  /**
-  * Gets the title of the form.
-  * @return Title The title of the form.
-  */
-  public function getTitle(): ?Title {
-    return $this->title;
-  }
-
-  /**
-  * Sets the title of the form.
-  * @param Title $title The new title of the form.
-  */
-  public function setTitle(?Title $title = new Title('')): void {
-    $this->title = $title;
-  }
-
-  /**
-  * Sends the form to the specified player.
-  * @param Player $player The player to send the form to.
-  */
-  public function sendTo(Player $player): void {
-    $player->sendForm($this);
-  }
-
-  /**
-  * Serializes the form data to an array.
-  * @return array<string, mixed> The serialized form data.
-  */
-  final public function jsonSerialize(): array {
-    $data = $this->serializeFormData();
-    $data['type'] = $this->getType();
-    $data['title'] = $this->getTitle()->getText();
-    return $data;
-  }
-
-  /**
-  * Serializes specific form data to an array.
-  * @return array<string, mixed> The serialized specific form data.
-  */
-  abstract protected function serializeFormData(): array;
-
-  /**
-  * Gets the type of the form.
-  * @return string The type of the form.
-  */
-  abstract protected function getType(): string;
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Button.php b/src/imperazim/vendor/libform/elements/Button.php
deleted file mode 100644
index 4d7f20b..0000000
--- a/src/imperazim/vendor/libform/elements/Button.php
+++ /dev/null
@@ -1,119 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use imperazim\vendor\libform\interaction\ButtonResponse;
-use imperazim\vendor\libform\traits\IdentifiableElement;
-
-/**
-* Class Button
-* @param imperazim\vendor\libform\elements
-*/
-final class Button implements \JsonSerializable {
-  use IdentifiableElement;
-
-  /**
-  * Button constructor.
-  * @param string|array $text The text displayed on the button.
-  * @param Image|null $image The image associated with the button.
-  * @param string|null $identifier The identifier associated with the button.
-  * @param ButtonResponse|null $response The response function to be executed when the button is pressed.
-  */
-  public function __construct(
-    private string|array $text,
-    private ?Image $image = null,
-    ?string $identifier = null,
-    private ?ButtonResponse $response = null,
-    private ?bool $reopen = false
-  ) {
-    $this->setIdentifier($identifier);
-  }
-
-  /**
-  * Defines the text of the button.
-  * @param string|array $text The new text for the button.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setText(string|array $text): self {
-    $this->text = $text;
-    return $this;
-  }
-
-  /**
-  * Gets the text of the button.
-  * @return string The text of the button.
-  */
-  public function getText(): string {
-    return is_array($this->text) ? implode("§r\n", $this->text) : $this->text;
-  }
-
-  /**
-  * Defines the image of the button.
-  * @param Image $image The new image for the button.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setImage(Image $image): self {
-    $this->image = $image;
-    return $this;
-  }
-
-  /**
-  * Gets the image of the button.
-  * @return Image|null The image of the button.
-  */
-  public function getImage(): ?Image {
-    return $this->image;
-  }
-
-  /**
-  * Defines the response function of the button.
-  * @param ButtonResponse $response The new response function for the button.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setResponse(ButtonResponse $response): self {
-    $this->response = $response;
-    return $this;
-  }
-
-  /**
-  * Gets the response function of the button.
-  * @return ButtonResponse|null The response function of the button.
-  */
-  public function getResponse(): ?ButtonResponse {
-    return $this->response;
-  }
-
-  /**
-  * Defines whether to reopen.
-  * @param bool $reopen The new value for should reopen.
-  * @return self Returns result whether to reopen.
-  */
-  public function setShouldReopen(bool $reopen): self {
-    $this->reopen = $reopen;
-    return $this;
-  }
-
-  /**
-  * Gets result whether to reopen
-  * @return bool Gets result whether to reopen
-  */
-  public function getShouldReopen(): bool {
-    return $this->reopen;
-  }
-
-  /**
-  * Serializes the button to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the button.
-  */
-  public function jsonSerialize(): array {
-    $data = [
-      "text" => $this->getText()
-    ];
-    if ($this->image !== null) {
-      $data["image"] = $this->image;
-    }
-    return $data;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Content.php b/src/imperazim/vendor/libform/elements/Content.php
deleted file mode 100644
index 63c54bc..0000000
--- a/src/imperazim/vendor/libform/elements/Content.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use imperazim\vendor\libform\traits\IdentifiableElement;
-
-/**
-* Class Content
-* @param imperazim\vendor\libform\elements
-*/
-final class Content implements \JsonSerializable {
-  use IdentifiableElement;
-
-  /**
-  * Content constructor.
-  * @param string $text The text displayed on the content.
-  */
-  public function __construct(private string $text) {}
-
-  /**
-  * Defines the text of the content.
-  * @param string $text The new text for the content.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setText(string $text): self {
-    $this->text = $text;
-    return $this;
-  }
-
-  /**
-  * Gets the text of the content.
-  * @return string The text of the content.
-  */
-  public function getText(): string {
-    return is_array($this->text) ? implode("§r\n", $this->text) : $this->text;
-  }
-
-  /**
-  * Serializes the content to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the content.
-  */
-  public function jsonSerialize(): array {
-    $data = [
-      "text" => $this->getText()
-    ];
-    return $data;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Dropdown.php b/src/imperazim/vendor/libform/elements/Dropdown.php
deleted file mode 100644
index 8903e4d..0000000
--- a/src/imperazim/vendor/libform/elements/Dropdown.php
+++ /dev/null
@@ -1,31 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-/**
-* Class Dropdown
-* @param imperazim\vendor\libform\elements
-*/
-class Dropdown extends Selector {
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  protected function getType(): string {
-    return "dropdown";
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  protected function serializeElementData(): array {
-    return [
-      "options" => $this->options,
-      "default" => $this->default,
-      ];
-    }
-  }
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Element.php b/src/imperazim/vendor/libform/elements/Element.php
deleted file mode 100644
index 0d253a2..0000000
--- a/src/imperazim/vendor/libform/elements/Element.php
+++ /dev/null
@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use imperazim\vendor\libform\traits\IdentifiableElement;
-
-/**
-* Class Element
-* @param imperazim\vendor\libform\elements
-*/
-abstract class Element implements \JsonSerializable {
-  use IdentifiableElement;
-
-  /**
-  * Element constructor.
-  * @param string $text The text of the element.
-  */
-  public function __construct(
-    public /*readonly*/ string $text
-  ) {}
-
-  /**
-  * Serializes the element to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the element.
-  */
-  final public function jsonSerialize(): array {
-    $data = $this->serializeElementData();
-    $data["type"] = $this->getType();
-    $data["text"] = $this->text;
-    return $data;
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  abstract protected function serializeElementData(): array;
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  abstract protected function getType(): string;
-
-  /**
-  * Validates the value for the element.
-  * @param mixed $value The value to validate.
-  */
-  abstract protected function validateValue(mixed $value): void;
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/ElementWithValue.php b/src/imperazim/vendor/libform/elements/ElementWithValue.php
deleted file mode 100644
index 1433a3e..0000000
--- a/src/imperazim/vendor/libform/elements/ElementWithValue.php
+++ /dev/null
@@ -1,43 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-/**
-* Class ElementWithValue
-* @param imperazim\vendor\libform\elements
-*/
-abstract class ElementWithValue extends Element {
-
-  /**
-  * ElementWithValue constructor.
-  * @param string $text The text of the element.
-  * @param TValue|null $value The initial value of the element.
-  */
-  public function __construct(
-    public string $text,
-    protected mixed $value = null
-  ) {
-    parent::__construct($text);
-  }
-
-  /**
-  * Gets the value of the element.
-  * @return TValue The value of the element.
-  * @throws \UnexpectedValueException if the value is not initialized.
-  */
-  public function getValue(): mixed {
-    return $this->value ?? throw new \UnexpectedValueException("Trying to access an uninitialized value");
-  }
-
-  /**
-  * Sets the value of the element.
-  * @param TValue $value The new value of the element.
-  */
-  public function setValue(mixed $value): void {
-    $this->validateValue($value);
-    $this->value = $value;
-  }
-  
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Image.php b/src/imperazim/vendor/libform/elements/Image.php
deleted file mode 100644
index cc7a97b..0000000
--- a/src/imperazim/vendor/libform/elements/Image.php
+++ /dev/null
@@ -1,74 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-/**
-* Class Image
-* @param imperazim\vendor\libform\elements
-*/
-final class Image implements \JsonSerializable {
-
-  /**
-  * Private constructor to prevent direct instantiation.
-  * @param string $data The data of the image.
-  * @param string $type The type of the image.
-  */
-  public function __construct(
-    public /*readonly*/ string $data, 
-    public /*readonly*/ string $type
-  ) {}
-
-  /**
-  * Creates an Image instance with a URL.
-  * @param string $data The URL of the image.
-  * @return self Returns an Image instance.
-  */
-  public static function url(string $data): self {
-    return new self($data, "url");
-  }
-
-  /**
-  * Creates an Image instance with a file path.
-  * @param string $data The file path of the image.
-  * @return self Returns an Image instance.
-  */
-  public static function path(string $data): self {
-    return new self($data, "path");
-  }
-
-  /**
-  * Creates an Image from string.
-  * @param string $data The encode image.
-  * @return self Returns an Image instance.
-  */
-  public static function fromString(string $data): ?Image {
-    $type = explode('|', $data)[0];
-    return match(strtolower($type)) {
-      'url' => new self(explode('|', $data)[1], $type),
-      'path' => new self(explode('|', $data)[1], $type),
-      'null' => null,
-      default => null
-    };
-  }
-
-  /**
-  * Returns a null value indicating no image.
-  * @return null Returns null to indicate no image.
-  */
-  public static function null(): null {
-    return null;
-  }
-
-  /**
-  * Serializes the image data to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the image.
-  */
-  public function jsonSerialize(): array {
-    return [
-      "type" => $this->type,
-      "data" => $this->data,
-    ];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Input.php b/src/imperazim/vendor/libform/elements/Input.php
deleted file mode 100644
index d304272..0000000
--- a/src/imperazim/vendor/libform/elements/Input.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class Input
-* @param imperazim\vendor\libform\elements
-*/
-class Input extends ElementWithValue {
-
-  /**
-  * Input constructor.
-  * @param string $text The text of the input element.
-  * @param string $placeholder The placeholder text for the input.
-  * @param string $default The default text for the input.
-  * @param string|null $identifier The elemment identifier.
-  */
-  public function __construct(
-    public string $text,
-    public /*readonly*/ string $placeholder,
-    public /*readonly*/ string $default = "",
-    public ?string $identifier = null
-  ) {
-    parent::__construct($text);
-    $this->setIdentifier($identifier);
-  }
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  protected function getType(): string {
-    return "input";
-  }
-
-  /**
-  * Validates the value for the input element.
-  * @param mixed $value The value to validate.
-  * @throws FormValidationException if the value is not a string.
-  */
-  protected function validateValue(mixed $value): void {
-    if (!is_string($value)) {
-      throw new FormValidationException("Expected string, got " . gettype($value));
-    }
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  protected function serializeElementData(): array {
-    return [
-      "placeholder" => $this->placeholder,
-      "default" => $this->default,
-    ];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Label.php b/src/imperazim/vendor/libform/elements/Label.php
deleted file mode 100644
index 779a9a9..0000000
--- a/src/imperazim/vendor/libform/elements/Label.php
+++ /dev/null
@@ -1,51 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class Label
-* @param imperazim\vendor\libform\elements
-*/
-class Label extends ElementWithValue {
-
-  /**
-  * Label constructor.
-  * @param string $text The text of the label element.
-  */
-  public function __construct(
-    public string $text
-  ) {
-    parent::__construct($text, null);
-  }
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  protected function getType(): string {
-    return "label";
-  }
-
-  /**
-  * Validates the value for the label element.
-  * @param mixed $value The value to validate.
-  * @throws FormValidationException if the value is not null.
-  */
-  protected function validateValue(mixed $value): void {
-    if (!is_null($value)) {
-      throw new FormValidationException("Expected null, got " . gettype($value));
-    }
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  protected function serializeElementData(): array {
-    return [];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/ModalButton.php b/src/imperazim/vendor/libform/elements/ModalButton.php
deleted file mode 100644
index b177086..0000000
--- a/src/imperazim/vendor/libform/elements/ModalButton.php
+++ /dev/null
@@ -1,73 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use imperazim\vendor\libform\interaction\ModalButtonResponse;
-use imperazim\vendor\libform\traits\IdentifiableElement;
-
-/**
-* Class ModalButton
-* @param imperazim\vendor\libform\elements
-*/
-final class ModalButton implements \JsonSerializable {
-  use IdentifiableElement;
-
-  /**
-  * ModalButton constructor.
-  * @param string $text The text displayed on the button.
-  * @param ModalButtonResponse|null $onclick The response function to be executed when the button is pressed.
-  */
-  public function __construct(
-    private string $text,
-    private ?ModalButtonResponse $onclick = null,
-  ) {}
-
-  /**
-  * Defines the text of the button.
-  * @param string $text The new text for the button.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setText(string $text): self {
-    $this->text = $text;
-    return $this;
-  }
-
-  /**
-  * Gets the text of the button.
-  * @return string The text of the button.
-  */
-  public function getText(): string {
-    return $this->text;
-  }
-
-  /**
-  * Defines the response function of the button.
-  * @param ModalButtonResponse $onclick The new response function for the button.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setResponse(ModalButtonResponse $onclick): self {
-    $this->onclick = $onclick;
-    return $this;
-  }
-
-  /**
-  * Gets the response function of the button.
-  * @return ModalButtonResponse|null The response function of the button.
-  */
-  public function getResponse(): ?ModalButtonResponse {
-    return $this->onclick;
-  }
-
-  /**
-  * Serializes the button to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the button.
-  */
-  public function jsonSerialize(): array {
-    $data = [
-      "text" => $this->getText()
-    ];
-    return $data;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Selector.php b/src/imperazim/vendor/libform/elements/Selector.php
deleted file mode 100644
index 1159989..0000000
--- a/src/imperazim/vendor/libform/elements/Selector.php
+++ /dev/null
@@ -1,62 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class Selector
-* @param imperazim\vendor\libform\elements
-*/
-abstract class Selector extends ElementWithValue {
-
-  /**
-  * Selector constructor.
-  * @param string $text The text of the selector element.
-  * @param array<int, string> $options The list of options for the selector.
-  * @param int $default The default selected index.
-  * @param string|null $identifier The elemment identifier.
-  */
-  public function __construct(
-    public string $text,
-    public array $options,
-    public int $default = 0,
-    public ?string $identifier = null
-  ) {
-    parent::__construct($text, $default);
-    $this->setIdentifier($identifier);
-  }
-
-  /**
-  * Gets the index of the selected option.
-  * @return int The index of the selected option.
-  */
-  public function getSelectedIndex(): int {
-    return $this->getValue();
-  }
-
-  /**
-  * Gets the selected option text.
-  * @return string The text of the selected option.
-  */
-  public function getSelectedOption(): string {
-    return $this->options[$this->getValue()];
-  }
-
-  /**
-  * Validates the value for the selector.
-  * @param mixed $value The value to validate.
-  * @throws FormValidationException if the value is not an integer or does not exist in options.
-  */
-  protected function validateValue(mixed $value): void {
-    if (!is_int($value)) {
-      throw new FormValidationException("Expected int, got " . gettype($value));
-    }
-    if (!isset($this->options[$value])) {
-      throw new FormValidationException("Option $value does not exist");
-    }
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Slider.php b/src/imperazim/vendor/libform/elements/Slider.php
deleted file mode 100644
index a4928ce..0000000
--- a/src/imperazim/vendor/libform/elements/Slider.php
+++ /dev/null
@@ -1,84 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class Slider
-* @param imperazim\vendor\libform\elements
-*/
-class Slider extends ElementWithValue {
-
-  /**
-  * Slider constructor.
-  *
-  * @param string $text The text of the slider element.
-  * @param float $min The minimum value of the slider.
-  * @param float $max The maximum value of the slider.
-  * @param float $step The step value of the slider.
-  * @param float|null $default The default value of the slider.
-  * @param string|null $identifier The elemment identifier.
-  */
-  public function __construct(
-    public string $text,
-    public /*readonly*/ float $min,
-    public /*readonly*/ float $max,
-    public /*readonly*/ float $step = 1.0,
-    public /*readonly*/ ?float $default = null,
-    public ?string $identifier = null
-  ) {
-    parent::__construct($text, $default);
-    $this->setIdentifier($identifier);
-    if ($min > $max) {
-      throw new \InvalidArgumentException("Slider min value should be less than max value");
-    }
-    if ($default === null) {
-      $this->default = $min;
-    } else {
-      if ($default > $max || $default < $min) {
-        throw new \InvalidArgumentException("Default must be in range $min ... $max");
-      }
-    }
-    if ($step <= 0) {
-      throw new \InvalidArgumentException("Step must be greater than zero");
-    }
-  }
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  protected function getType(): string {
-    return "slider";
-  }
-
-  /**
-  * Validates the value for the slider element.
-  * @param mixed $value The value to validate.
-  * @throws FormValidationException if the value is not a float or an int, or if it's out of bounds.
-  */
-  protected function validateValue(mixed $value): void {
-    if (!is_float($value) && !is_int($value)) {
-      throw new FormValidationException("Expected float or int, got " . gettype($value));
-    }
-    if ($value < $this->min || $value > $this->max) {
-      throw new FormValidationException("Value $value is out of bounds (min $this->min, max $this->max)");
-    }
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  protected function serializeElementData(): array {
-    return [
-      "min" => $this->min,
-      "max" => $this->max,
-      "step" => $this->step,
-      "default" => $this->default,
-    ];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/StepSlider.php b/src/imperazim/vendor/libform/elements/StepSlider.php
deleted file mode 100644
index f10587f..0000000
--- a/src/imperazim/vendor/libform/elements/StepSlider.php
+++ /dev/null
@@ -1,33 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class StepSlider
-* @param imperazim\vendor\libform\elements
-*/
-class StepSlider extends Selector {
-
-  /**
-  * Gets the type of the element.
-  * @return string The type of the element.
-  */
-  protected function getType(): string {
-    return "step_slider";
-  }
-
-  /**
-  * Serializes specific element data to an array.
-  * @return array<string, mixed> The serialized specific element data.
-  */
-  protected function serializeElementData(): array {
-    return [
-      "steps" => $this->options,
-      "default" => $this->default
-    ];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Title.php b/src/imperazim/vendor/libform/elements/Title.php
deleted file mode 100644
index 2d7f6b2..0000000
--- a/src/imperazim/vendor/libform/elements/Title.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use imperazim\vendor\libform\traits\IdentifiableElement;
-
-/**
-* Class Title
-* @param imperazim\vendor\libform\elements
-*/
-final class Title implements \JsonSerializable {
-  use IdentifiableElement;
-
-  /**
-  * Title constructor.
-  * @param string $text The text displayed on the title.
-  */
-  public function __construct(private string $text) {}
-
-  /**
-  * Defines the text of the title.
-  * @param string $text The new text for the title.
-  * @return self Returns the current instance for method chaining.
-  */
-  public function setText(string $text): self {
-    $this->text = $text;
-    return $this;
-  }
-
-  /**
-  * Gets the text of the title.
-  * @return string The text of the title.
-  */
-  public function getText(): string {
-    return is_array($this->text) ? implode("§r\n", $this->text) : $this->text;
-  }
-
-  /**
-  * Serializes the title to an array for JSON encoding.
-  * @return array<string, mixed> The serialized data of the title.
-  */
-  public function jsonSerialize(): array {
-    $data = [
-      "text" => $this->getText()
-    ];
-    return $data;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/elements/Toggle.php b/src/imperazim/vendor/libform/elements/Toggle.php
deleted file mode 100644
index 23e5869..0000000
--- a/src/imperazim/vendor/libform/elements/Toggle.php
+++ /dev/null
@@ -1,66 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\elements;
-
-use pocketmine\form\FormValidationException;
-
-/**
-* Class Toggle
-* @param imperazim\vendor\libform\elements
-*/
-class Toggle extends ElementWithValue {
-
-  /**
-  * Toggle constructor.
-  * @param string $text The text of the toggle element.
-  * @param bool $default The default value of the toggle.
-  * @param string|null $identifier The elemment identifier.
-  */
-  public function __construct(
-    public string $text,
-    public /*readonly*/ bool $default = false,
-    public ?string $identifier = null
-  ) {
-    parent::__construct($text);
-    $this->setIdentifier($identifier);
-  }
-
-  /**
-  * Checks if the value has changed from the default.
-  * @return bool True if the value has changed, false otherwise.
-  */
-  public function hasChanged(): bool {
-    return $this->default !== $this->getValue();
-    }
-
-    /**
-    * Gets the type of the element.
-    * @return string The type of the element.
-    */
-    protected function getType(): string {
-      return 'toggle';
-    }
-
-    /**
-    * Validates the value for the toggle element.
-    * @param mixed $value The value to validate.
-    * @throws FormValidationException if the value is not a boolean.
-    */
-    protected function validateValue(mixed $value): void {
-      if (!is_bool($value)) {
-        throw new FormValidationException('Expected bool, got ' . gettype($value));
-      }
-    }
-
-    /**
-    * Serializes specific element data to an array.
-    * @return array<string, mixed> The serialized specific element data.
-    */
-    protected function serializeElementData(): array {
-      return [
-        'default' => $this->default,
-    ];
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/interaction/ButtonResponse.php b/src/imperazim/vendor/libform/interaction/ButtonResponse.php
deleted file mode 100644
index e7773d6..0000000
--- a/src/imperazim/vendor/libform/interaction/ButtonResponse.php
+++ /dev/null
@@ -1,32 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\interaction;
-
-use Closure;
-use pocketmine\player\Player;
-use imperazim\vendor\libform\elements\Button;
-
-/**
-* Class ButtonResponse
-* @package imperazim\vendor\libform\interaction
-*/
-final class ButtonResponse {
-
-  /**
-  * ButtonResponse constructor.
-  * @param Closure(Player, Button): void $callback
-  */
-  public function __construct(private Closure $callback) {}
-
-  /**
-  * Execute the response callback.
-  * @param Player $player
-  * @param Button $button
-  */
-  public function runAt(Player $player, Button $button): void {
-    ($this->callback)($player, $button);
-  }
-  
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/interaction/CustomElementsResponse.php b/src/imperazim/vendor/libform/interaction/CustomElementsResponse.php
deleted file mode 100644
index ff91764..0000000
--- a/src/imperazim/vendor/libform/interaction/CustomElementsResponse.php
+++ /dev/null
@@ -1,79 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\interaction;
-
-use UnexpectedValueException;
-use imperazim\vendor\libform\elements\Input;
-use imperazim\vendor\libform\elements\Label;
-use imperazim\vendor\libform\elements\Slider;
-use imperazim\vendor\libform\elements\Toggle;
-use imperazim\vendor\libform\elements\Element;
-use imperazim\vendor\libform\elements\Dropdown;
-use imperazim\vendor\libform\elements\StepSlider;
-use imperazim\vendor\libform\elements\ElementWithValue;
-
-/**
-* Class CustomElementsResponse
-* @package imperazim\vendor\libform\interaction
-*/
-final class CustomElementsResponse {
-
-  /**
-  * CustomElementsResponse constructor.
-  * @param Element[] $elements
-  */
-  public function __construct(private array $elements) {}
-
-  /**
-  * Get all values from elements in the response, excluding labels.
-  * @return array
-  */
-  public function getValues(): array {
-    return array_map(fn(Element $element) => $element->getValue(), $this->getNonLabelElements());
-  }
-
-  /**
-  * Get all elements
-  * @return Element[]
-  */
-  public function getElements(): array {
-    return $this->getNonLabelElements();
-  }
-
-  /**
-  * Get specific element by your identifier
-  * @param string $id
-  * @return Element|null
-  */
-  public function getElement(string $id): ?Element {
-    foreach ($this->elements as $element) {
-      if ($element->getIdentifier() === $id) {
-        return $element;
-      }
-    }
-    return null;
-  }
-
-  /**
-  * Get result from elements by identifier, excluding labels.
-  * @param int|null $index
-  * @return mixed
-  */
-  public function getElementResult(?int $index = null): mixed {
-    $values = array_map(fn(Element $element) => $element, $this->getNonLabelElements());
-    if ($index == null) {
-      return $values;
-    }
-    return $values[$index] ?? null;
-  }
-
-  /**
-  * Get all non-label elements from the response.
-  * @return Element[]
-  */
-  private function getNonLabelElements(): array {
-    return array_filter($this->elements, fn(Element $element) => !$element instanceof Label);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/interaction/ModalButtonResponse.php b/src/imperazim/vendor/libform/interaction/ModalButtonResponse.php
deleted file mode 100644
index 7884c41..0000000
--- a/src/imperazim/vendor/libform/interaction/ModalButtonResponse.php
+++ /dev/null
@@ -1,31 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\interaction;
-
-use Closure;
-use pocketmine\player\Player;
-use imperazim\vendor\libform\elements\Button;
-
-/**
-* Class ModalButtonResponse
-* @package imperazim\vendor\libform\interaction
-*/
-final class ModalButtonResponse {
-
-  /**
-  * ModalButtonResponse constructor.
-  * @param Closure(Player): void $callback
-  */
-  public function __construct(private Closure $callback) {}
-
-  /**
-  * Execute the response callback.
-  * @param Player $player
-  */
-  public function runAt(Player $player): void {
-    ($this->callback)($player);
-  }
-  
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/traits/IdentifiableElement.php b/src/imperazim/vendor/libform/traits/IdentifiableElement.php
deleted file mode 100644
index 5f80dcb..0000000
--- a/src/imperazim/vendor/libform/traits/IdentifiableElement.php
+++ /dev/null
@@ -1,32 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\traits;
-
-/**
-* Trait IdentifiableElement
-* @package imperazim\vendor\libform\traits
-*/
-trait IdentifiableElement {
-
-  /** @var mixed */
-  private mixed $identifier = null;
-
-  /**
-  * Gets the identifier of the element.
-  * @return mixed The identifier of the element.
-  */
-  public function getIdentifier(): mixed {
-    return $this->identifier;
-  }
-
-  /**
-  * Sets the identifier of the element.
-  * @param mixed $identifier The new identifier of the element.
-  */
-  public function setIdentifier(mixed $identifier): void {
-    $this->identifier = $identifier;
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/types/CustomForm.php b/src/imperazim/vendor/libform/types/CustomForm.php
deleted file mode 100644
index be36d70..0000000
--- a/src/imperazim/vendor/libform/types/CustomForm.php
+++ /dev/null
@@ -1,199 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\types;
-
-use Closure;
-use pocketmine\utils\Utils;
-use pocketmine\player\Player;
-use pocketmine\form\FormValidationException;
-
-use imperazim\vendor\libform\Form;
-use imperazim\vendor\libform\elements\Title;
-use imperazim\vendor\libform\elements\Input;
-use imperazim\vendor\libform\elements\Label;
-use imperazim\vendor\libform\elements\Slider;
-use imperazim\vendor\libform\elements\Toggle;
-use imperazim\vendor\libform\elements\Element;
-use imperazim\vendor\libform\elements\Dropdown;
-use imperazim\vendor\libform\elements\StepSlider;
-use imperazim\vendor\libform\elements\ElementWithValue;
-use imperazim\vendor\libform\interaction\CustomElementsResponse;
-
-/**
-* Class CustomForm
-* @package imperazim\vendor\libform\types
-*/
-final class CustomForm extends Form {
-
-  /**
-  * CustomForm constructor.
-  * @param string $title
-  * @param Element[] $elements
-  * @param (Closure(Player, CustomElementsResponse): mixed)|null $onSubmit
-  * @param (Closure(Player): mixed)|null $onClose
-  */
-  public function __construct(
-    public ?Title $title = new Title(''),
-    protected array $elements = [],
-    private ?Closure $onSubmit = null,
-    private ?Closure $onClose = null,
-  ) {
-    if ($onSubmit !== null) {
-      Utils::validateCallableSignature(function(Player $player, CustomElementsResponse $response) {}, $onSubmit);
-    }
-    if ($onClose !== null) {
-      Utils::validateCallableSignature(function(Player $player) {}, $onClose);
-    }
-    parent::__construct($title);
-  }
-
-  /**
-  * Set the callback to be executed when the form is submitted.
-  * @param Closure(Player, CustomElementsResponse): void $closure
-  */
-  public function onSubmit(Closure $closure): void {
-    $this->onSubmit = $closure;
-  }
-
-  /**
-  * Set the callback to be executed when the form is closed.
-  * @param Closure(Player): void $closure
-  */
-  public function onClose(Closure $closure): void {
-    $this->onClose = $closure;
-  }
-
-  /**
-  * Add a dropdown element to the form.
-  * @param string $text
-  * @param string[] $options
-  * @param int $default
-  */
-  public function addDropdown(string $text, array $options, int $default = 0): void {
-    $this->appendElements(new Dropdown($text, $options, $default));
-  }
-
-  /**
-  * Append multiple elements to the form.
-  * @param Element ...$elements @phpstan-param Element&ElementWithValue<mixed> ...$elements
-  */
-  public function appendElements(Element ...$elements): void {
-    foreach ($elements as $element) {
-      $this->elements[] = $element;
-    }
-  }
-
-  /**
-  * Add an input element to the form.
-  * @param string $text
-  * @param string $placeholder
-  * @param string $value
-  */
-  public function addInput(string $text, string $placeholder = '', string $value = ''): void {
-    $this->appendElements(new Input($text, $placeholder, $value));
-  }
-
-  /**
-  * Add a slider element to the form.
-  * @param string $text
-  * @param int $min
-  * @param int $max
-  * @param int $step
-  * @param int $default
-  */
-  public function addSlider(string $text, int $min, int $max, int $step = -1, int $default = -1): void {
-    $this->appendElements(new Slider($text, $min, $max, $step, $default));
-  }
-
-  /**
-  * Add a step slider element to the form.
-  * @param string $text
-  * @param string[] $steps
-  * @param int $index
-  */
-  public function addStepSlider(string $text, array $steps, int $index = -1): void {
-    $this->appendElements(new StepSlider($text, $steps, $index));
-  }
-
-  /**
-  * Add a toggle element to the form.
-  * @param string $text
-  * @param bool $default
-  */
-  public function addToggle(string $text, bool $default = false): void {
-    $this->appendElements(new Toggle($text, $default));
-  }
-
-  /**
-  * Add a label element to the form.
-  *
-  * @param string $text
-  */
-  public function addLabel(string $text): void {
-    $this->appendElements(new Label($text));
-  }
-
-  /**
-  * Handle the response from the form.
-  * @param Player $player
-  * @param mixed $data
-  * @throws FormValidationException
-  */
-  final public function handleResponse(Player $player, mixed $data): void {
-    if (is_null($data)) {
-      if ($this->onClose !== null) {
-        ($this->onClose)($player);
-      }
-    } elseif (is_array($data)) {
-      $this->validateElements($player, $data);
-    } else {
-      throw new FormValidationException('Expected array or null, got ' . gettype($data));
-    }
-  }
-
-  /**
-  * Validate the elements in the form.
-  * @param Player $player
-  * @param array<int, mixed> $data
-  * @throws FormValidationException
-  */
-  private function validateElements(Player $player, array $data): void {
-    if (($actual = count($data)) !== ($expected = count($this->elements))) {
-      throw new FormValidationException('Expected ' . $expected . ' result data, got ' . $actual);
-    }
-
-    foreach ($data as $index => $value) {
-      $element = $this->elements[$index] ?? throw new FormValidationException("Element at offset $index does not exist");
-      try {
-        $element->setValue($value);
-      } catch (FormValidationException $e) {
-        throw new FormValidationException('Validation failed for element ' . $element::class . ': ' . $e->getMessage(), 0, $e);
-      }
-    }
-
-    if ($this->onSubmit !== null) {
-      ($this->onSubmit)($player, new CustomElementsResponse($this->elements));
-    }
-  }
-
-  /**
-  * Get the type of the form.
-  * @return string
-  */
-  protected function getType(): string {
-    return 'custom_form';
-  }
-
-  /**
-  * Serialize the form data for transmission.
-  * @return array
-  */
-  protected function serializeFormData(): array {
-    return [
-      'content' => $this->elements,
-    ];
-  }
-  
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/types/LongForm.php b/src/imperazim/vendor/libform/types/LongForm.php
deleted file mode 100644
index 9c32cb6..0000000
--- a/src/imperazim/vendor/libform/types/LongForm.php
+++ /dev/null
@@ -1,141 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\types;
-
-use Closure;
-use pocketmine\player\Player;
-use pocketmine\form\FormValidationException;
-
-use imperazim\vendor\libform\Form;
-use imperazim\vendor\libform\elements\Title;
-use imperazim\vendor\libform\elements\Image;
-use imperazim\vendor\libform\elements\Button;
-use imperazim\vendor\libform\elements\Content;
-use imperazim\vendor\libform\interaction\ButtonResponse;
-
-/**
-* Class LongForm
-* @package imperazim\vendor\libform\types
-*/
-final class LongForm extends Form {
-
-  /**
-  * LongForm constructor.
-  * @param Title $title
-  * @param Content $content
-  * @param Button[] $buttons
-  * @param (Closure(Player): mixed)|null $onClose
-  */
-  public function __construct(
-    public ?Title $title = new Title(''),
-    protected ?Content $content = new Content(''),
-    private ?array $buttons = [],
-    private ?Closure $onClose = null,
-  ) {
-    parent::__construct($title);
-  }
-
-  /**
-  * Set a callback to be executed when the form is closed.
-  * @param Closure(Player): void $closure
-  */
-  public function onClose(Closure $closure): void {
-    $this->onClose = $closure;
-  }
-
-  /**
-  * Get the content of the form.
-  * @return Content|null
-  */
-  public function getContent(): ?Content {
-    return $this->content;
-  }
-
-  /**
-  * Set the content of the form.
-  * @param Content $content
-  * @return self
-  */
-  public function setContent(?Content $content = new Content('')): self {
-    $this->content = $content;
-    return $this;
-  }
-  
-   /**
-  * Get the buttons of the form.
-  * @return array
-  */
-  public function getButtons(): array {
-    return $this->buttons;
-  }
-  
-  /**
-  * Get a button by its index.
-  * @param int $identifier
-  * @return Button
-  * @throws FormValidationException
-  */
-  private function getButton(int $identifier): Button {
-    if (!isset($this->buttons[$identifier])) {
-      throw new FormValidationException("Button at index $identifier does not exist.");
-    }
-    return $this->buttons[$identifier];
-  }
-
-  /**
-  * Add a button to the form.
-  * @param string $text
-  * @param Image|null $image
-  * @param string|null $identifier
-  * @return self
-  */
-  public function addButton(string $text, ?Image $image = null, ?string $identifier = null, ?ButtonResponse $response = null): self {
-    $button = new Button($text, $image, $identifier, $response);
-    $this->buttons[] = $button;
-    return $this;
-  }
-
-  /**
-  * Handle the response from the form.
-  * @param Player $player
-  * @param mixed $data
-  */
-  final public function handleResponse(Player $player, mixed $data): void {
-    if (is_null($data)) {
-      if ($this->onClose !== null) {
-        ($this->onClose)($player);
-      }
-    } else {
-      $button = $this->getButton($data);
-      $buttonResponse = $button->getResponse();
-      if ($buttonResponse !== null) {
-        $buttonResponse->runAt($player, $button);
-      }
-      if ($button->getShouldReopen()) {
-        $this->sendTo($player);
-      }
-    }
-  }
-
-  /**
-  * Get the type of the form.
-  * @return string
-  */
-  protected function getType(): string {
-    return 'form';
-  }
-
-  /**
-  * Serialize the form data for transmission.
-  * @return array
-  */
-  protected function serializeFormData(): array {
-    return [
-      'buttons' => $this->getButtons(),
-      'content' => $this->getContent()->getText(),
-    ];
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/libform/types/ModalForm.php b/src/imperazim/vendor/libform/types/ModalForm.php
deleted file mode 100644
index d438460..0000000
--- a/src/imperazim/vendor/libform/types/ModalForm.php
+++ /dev/null
@@ -1,138 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\libform\types;
-
-use Closure;
-use imperazim\vendor\libform\Form;
-use pocketmine\utils\Utils;
-use pocketmine\player\Player;
-use imperazim\vendor\libform\elements\Title;
-use imperazim\vendor\libform\elements\Content;
-use imperazim\vendor\libform\elements\ModalButton;
-use pocketmine\form\FormValidationException;
-/**
-* Class ModalForm
-* @package imperazim\vendor\libform\types
-*/
-final class ModalForm extends Form {
-
-  /**
-  * ModalForm constructor.
-  * @param Title $title
-  * @param Content $content
-  * @param ModalButton $buttonYes
-  * @param ModalButton $buttonNo
-  */
-  public function __construct(
-    public ?Title $title = new Title(''),
-    protected ?Content $content = new Content(''),
-    public ModalButton $buttonYes = new ModalButton('gui.yes'),
-    public ModalButton $buttonNo = new ModalButton('gui.no')
-  ) {
-    parent::__construct($title);
-  }
-
-  /**
-  * Get the content of the form.
-  * @return Content|null
-  */
-  public function getContent(): ?Content {
-    return $this->content;
-  }
-
-  /**
-  * Set the content of the form.
-  * @param Content|null $content
-  * @return self
-  */
-  public function setContent(?Content $content = new Content('')): self {
-    $this->content = $content;
-    return $this;
-  }
-
-  /**
-  * Get the button Yes.
-  * @return ModalButton
-  */
-  public function getButtonYes(): ModalButton {
-    return $this->buttonYes;
-  }
-
-  /**
-  * Set the button Yes.
-  * @param ModalButton $buttonYes
-  * @return self
-  */
-  public function setButtonYes(?ModalButton $buttonYes = new ModalButton('gui.yes')): self {
-    $this->buttonYes = $buttonYes;
-    return $this;
-  }
-
-  /**
-  * Get the button No.
-  * @return ModalButton
-  */
-  public function getButtonNo(): ModalButton {
-    return $this->buttonNo;
-  }
-  
-  /**
-  * Set the button No.
-  * @param ModalButton $buttself
-  * @return self
-  */
-  public function setButtonNo(?ModalButton $buttonNo = new ModalButton('gui.no')): self {
-    $this->buttonNo = $buttonNo;
-    return $this;
-  }
-
-  /**
-  * Handle the response from the form.
-  * @param Player $player
-  * @param mixed $data
-  * @throws FormValidationException
-  */
-  final public function handleResponse(Player $player,
-    mixed $data): void {
-    if (!is_bool($data)) {
-      // It is possible to separate the callback from onClose here but it made me lazy. :)
-      return; 
-    }
-    if ($data) {
-      $button = $this->getButtonYes();
-      $buttonResponse = $button->getResponse();
-      if ($buttonResponse !== null) {
-        $buttonResponse->runAt($player);
-      }
-    } else {
-      $button = $this->getButtonNo();
-      $buttonResponse = $button->getResponse();
-      if ($buttonResponse !== null) {
-        $buttonResponse->runAt($player);
-      }
-    }
-  }
-
-  /**
-  * Get the type of the form.
-  * @return 
-  */
-  protected function getType(): string {
-    return 'modal';
-  }
-
-  /**
-  * Serialize the form data for transmission.
-  * @return array
-  */
-  protected function serializeFormData(): array {
-    return [
-      'content' => $this->getContent()->getText(),
-      'button1' => $this->getButtonYes()->getText(),
-      'button2' => $this->getButtonNo()->getText(),
-    ];
-  }
-
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/SimplePacketHandler.php b/src/imperazim/vendor/simplepackethandler/SimplePacketHandler.php
deleted file mode 100644
index 43c92f7..0000000
--- a/src/imperazim/vendor/simplepackethandler/SimplePacketHandler.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler;
-
-use InvalidArgumentException;
-use pocketmine\plugin\Plugin;
-use pocketmine\event\EventPriority;
-
-use imperazim\vendor\simplepackethandler\monitor\PacketMonitor;
-use imperazim\vendor\simplepackethandler\monitor\IPacketMonitor;
-use imperazim\vendor\simplepackethandler\interceptor\PacketInterceptor;
-use imperazim\vendor\simplepackethandler\interceptor\IPacketInterceptor;
-
-final class SimplePacketHandler {
-
-  public static function createInterceptor(Plugin $registerer, int $priority = EventPriority::NORMAL, bool $handle_cancelled = false) : IPacketInterceptor {
-    if ($priority === EventPriority::MONITOR) {
-      throw new InvalidArgumentException("Cannot intercept packets at MONITOR priority");
-    }
-    return new PacketInterceptor($registerer, $priority, $handle_cancelled);
-  }
-
-  public static function createMonitor(Plugin $registerer, bool $handle_cancelled = false) : IPacketMonitor {
-    return new PacketMonitor($registerer, $handle_cancelled);
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/interceptor/IPacketInterceptor.php b/src/imperazim/vendor/simplepackethandler/interceptor/IPacketInterceptor.php
deleted file mode 100644
index 4e7a50f..0000000
--- a/src/imperazim/vendor/simplepackethandler/interceptor/IPacketInterceptor.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\interceptor;
-
-use Closure;
-use pocketmine\network\mcpe\NetworkSession;
-use pocketmine\network\mcpe\protocol\ClientboundPacket;
-use pocketmine\network\mcpe\protocol\ServerboundPacket;
-
-interface IPacketInterceptor {
-
-  /**
-  * @template TServerboundPacket of ServerboundPacket
-  * @param Closure(TServerboundPacket, NetworkSession) : bool $handler
-  * @return IPacketInterceptor
-  */
-  public function interceptIncoming(Closure $handler) : IPacketInterceptor;
-
-  /**
-  * @template TClientboundPacket of ClientboundPacket
-  * @param Closure(TClientboundPacket, NetworkSession) : bool $handler
-  * @return IPacketInterceptor
-  */
-  public function interceptOutgoing(Closure $handler) : IPacketInterceptor;
-
-  /**
-  * @template TServerboundPacket of ServerboundPacket
-  * @param Closure(TServerboundPacket, NetworkSession) : bool $handler
-  * @return IPacketInterceptor
-  */
-  public function unregisterIncomingInterceptor(Closure $handler) : IPacketInterceptor;
-
-  /**
-  * @template TClientboundPacket of ClientboundPacket
-  * @param Closure(TClientboundPacket, NetworkSession) : bool $handler
-  * @return IPacketInterceptor
-  */
-  public function unregisterOutgoingInterceptor(Closure $handler) : IPacketInterceptor;
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptor.php b/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptor.php
deleted file mode 100644
index d45f922..0000000
--- a/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptor.php
+++ /dev/null
@@ -1,37 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\interceptor;
-
-use Closure;
-use pocketmine\plugin\Plugin;
-
-final class PacketInterceptor implements IPacketInterceptor {
-
-  readonly private PacketInterceptorListener $listener;
-
-  public function __construct(Plugin $register, int $priority, bool $handle_cancelled) {
-    $this->listener = new PacketInterceptorListener($register, $priority, $handle_cancelled);
-  }
-
-  public function interceptIncoming(Closure $handler) : IPacketInterceptor {
-    $this->listener->interceptIncoming($handler);
-    return $this;
-  }
-
-  public function interceptOutgoing(Closure $handler) : IPacketInterceptor {
-    $this->listener->interceptOutgoing($handler);
-    return $this;
-  }
-
-  public function unregisterIncomingInterceptor(Closure $handler) : IPacketInterceptor {
-    $this->listener->unregisterIncomingInterceptor($handler);
-    return $this;
-  }
-
-  public function unregisterOutgoingInterceptor(Closure $handler) : IPacketInterceptor {
-    $this->listener->unregisterOutgoingInterceptor($handler);
-    return $this;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptorListener.php b/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptorListener.php
deleted file mode 100644
index 28cb7a3..0000000
--- a/src/imperazim/vendor/simplepackethandler/interceptor/PacketInterceptorListener.php
+++ /dev/null
@@ -1,148 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\interceptor;
-
-use Closure;
-use pocketmine\Server;
-use pocketmine\plugin\Plugin;
-use pocketmine\event\HandlerListManager;
-use pocketmine\event\RegisteredListener;
-use pocketmine\network\mcpe\NetworkSession;
-use pocketmine\network\mcpe\protocol\Packet;
-use pocketmine\network\mcpe\protocol\DataPacket;
-use pocketmine\event\server\DataPacketSendEvent;
-use pocketmine\network\mcpe\NetworkBroadcastUtils;
-use pocketmine\event\server\DataPacketReceiveEvent;
-use pocketmine\network\mcpe\protocol\ClientboundPacket;
-use pocketmine\network\mcpe\protocol\ServerboundPacket;
-
-use imperazim\vendor\simplepackethandler\utils\Utils;
-
-final class PacketInterceptorListener implements IPacketInterceptor {
-
-  /**
-  * @template TPacket of Packet
-  * @template UPacket of TPacket
-  * @param Closure(UPacket, NetworkSession) : bool $handler
-  * @param class-string<TPacket> $class
-  * @return int
-  */
-  private static function getPidFromHandler(Closure $handler, string $class) : int {
-    $classes = Utils::parseClosureSignature($handler, [$class, NetworkSession::class], "bool");
-    assert(is_a($classes[0], DataPacket::class, true));
-    return $classes[0]::NETWORK_ID;
-  }
-
-  private ?RegisteredListener $incoming_event_handler = null;
-  private ?RegisteredListener $outgoing_event_handler = null;
-
-  /** @var array<int, array<int, Closure(ServerboundPacket, NetworkSession) : bool>> */
-  private array $incoming_handlers = [];
-
-  /** @var array<int, array<int, Closure(ClientboundPacket, NetworkSession) : bool>> */
-  private array $outgoing_handlers = [];
-
-  public function __construct(
-    readonly private Plugin $register,
-    readonly private int $priority,
-    readonly private bool $handle_cancelled
-  ) {}
-
-  public function interceptIncoming(Closure $handler) : IPacketInterceptor {
-    $this->incoming_handlers[self::getPidFromHandler($handler, ServerboundPacket::class)][spl_object_id($handler)] = $handler;
-    $this->incoming_event_handler ??= Server::getInstance()->getPluginManager()->registerEvent(DataPacketReceiveEvent::class, function(DataPacketReceiveEvent $event) : void {
-      /** @var DataPacket&ServerboundPacket $packet */
-      $packet = $event->getPacket();
-      if (isset($this->incoming_handlers[$pid = $packet::NETWORK_ID])) {
-        $origin = $event->getOrigin();
-        foreach ($this->incoming_handlers[$pid] as $handler) {
-          if (!$handler($packet, $origin)) {
-            $event->cancel();
-            break;
-          }
-        }
-      }
-    },
-      $this->priority,
-      $this->register,
-      $this->handle_cancelled);
-    return $this;
-  }
-
-  public function interceptOutgoing(Closure $handler) : IPacketInterceptor {
-    $this->outgoing_handlers[self::getPidFromHandler($handler,
-      ClientboundPacket::class)][spl_object_id($handler)] = $handler;
-    $this->outgoing_event_handler ??= Server::getInstance()->getPluginManager()->registerEvent(DataPacketSendEvent::class,
-      function(DataPacketSendEvent $event) : void {
-        $original_targets = $event->getTargets();
-        $packets = $event->getPackets();
-
-        /** @var DataPacket&ClientboundPacket $packet */
-        foreach ($packets as $packet) {
-          if (isset($this->outgoing_handlers[$pid = $packet::NETWORK_ID])) {
-            $remaining_targets = $original_targets;
-
-            foreach ($remaining_targets as $i => $target) {
-              foreach ($this->outgoing_handlers[$pid] as $handler) {
-                if (!$handler($packet, $target)) {
-                  unset($remaining_targets[$i]);
-                  break;
-                }
-              }
-            }
-
-            $remaining_targets_c = count($remaining_targets);
-            if ($remaining_targets_c !== count($original_targets)) {
-              $event->cancel();
-              if ($remaining_targets_c > 0) {
-                $new_target_players = [];
-                foreach ($remaining_targets as $new_target) {
-                  $new_target_player = $new_target->getPlayer();
-                  if ($new_target_player !== null) {
-                    $new_target_players[] = $new_target_player;
-                  }
-                }
-
-                NetworkBroadcastUtils::broadcastPackets($new_target_players, $packets);
-              }
-              break;
-            }
-          }
-        }
-      },
-      $this->priority,
-      $this->register,
-      $this->handle_cancelled);
-    return $this;
-  }
-
-  public function unregisterIncomingInterceptor(Closure $handler) : IPacketInterceptor {
-    if (isset($this->incoming_handlers[$pid = self::getPidFromHandler($handler, ServerboundPacket::class)][$hid = spl_object_id($handler)])) {
-      unset($this->incoming_handlers[$pid][$hid]);
-      if (count($this->incoming_handlers[$pid]) === 0) {
-        unset($this->incoming_handlers[$pid]);
-        if (count($this->incoming_handlers) === 0) {
-          HandlerListManager::global()->getListFor(DataPacketReceiveEvent::class)->unregister($this->incoming_event_handler);
-          $this->incoming_event_handler = null;
-        }
-      }
-    }
-    return $this;
-  }
-
-  public function unregisterOutgoingInterceptor(Closure $handler) : IPacketInterceptor {
-    if (isset($this->outgoing_handlers[$pid = self::getPidFromHandler($handler, ClientboundPacket::class)][$hid = spl_object_id($handler)])) {
-      unset($this->outgoing_handlers[$pid][$hid]);
-      if (count($this->outgoing_handlers[$pid]) === 0) {
-        unset($this->outgoing_handlers[$pid]);
-        if (count($this->outgoing_handlers) === 0) {
-          HandlerListManager::global()->getListFor(DataPacketSendEvent::class)->unregister($this->outgoing_event_handler);
-          $this->outgoing_event_handler = null;
-        }
-      }
-    }
-    return $this;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/monitor/IPacketMonitor.php b/src/imperazim/vendor/simplepackethandler/monitor/IPacketMonitor.php
deleted file mode 100644
index bfff60e..0000000
--- a/src/imperazim/vendor/simplepackethandler/monitor/IPacketMonitor.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\monitor;
-
-use Closure;
-use pocketmine\network\mcpe\NetworkSession;
-use pocketmine\network\mcpe\protocol\ClientboundPacket;
-use pocketmine\network\mcpe\protocol\ServerboundPacket;
-
-interface IPacketMonitor {
-
-  /**
-  * @template TServerboundPacket of ServerboundPacket
-  * @param Closure(TServerboundPacket, NetworkSession) : void $handler
-  * @return IPacketMonitor
-  */
-  public function monitorIncoming(Closure $handler) : IPacketMonitor;
-
-  /**
-  * @template TClientboundPacket of ClientboundPacket
-  * @param Closure(TClientboundPacket, NetworkSession) : void $handler
-  * @return IPacketMonitor
-  */
-  public function monitorOutgoing(Closure $handler) : IPacketMonitor;
-
-  /**
-  * @template TServerboundPacket of ServerboundPacket
-  * @param Closure(TServerboundPacket, NetworkSession) : void $handler
-  * @return IPacketMonitor
-  */
-  public function unregisterIncomingMonitor(Closure $handler) : IPacketMonitor;
-
-  /**
-  * @template TClientboundPacket of ClientboundPacket
-  * @param Closure(TClientboundPacket, NetworkSession) : void $handler
-  * @return IPacketMonitor
-  */
-  public function unregisterOutgoingMonitor(Closure $handler) : IPacketMonitor;
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitor.php b/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitor.php
deleted file mode 100644
index 7c72f7e..0000000
--- a/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitor.php
+++ /dev/null
@@ -1,37 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\monitor;
-
-use Closure;
-use pocketmine\plugin\Plugin;
-
-final class PacketMonitor implements IPacketMonitor {
-
-  private PacketMonitorListener $listener;
-
-  public function __construct(Plugin $register, bool $handle_cancelled) {
-    $this->listener = new PacketMonitorListener($register, $handle_cancelled);
-  }
-
-  public function monitorIncoming(Closure $handler) : IPacketMonitor {
-    $this->listener->monitorIncoming($handler);
-    return $this;
-  }
-
-  public function monitorOutgoing(Closure $handler) : IPacketMonitor {
-    $this->listener->monitorOutgoing($handler);
-    return $this;
-  }
-
-  public function unregisterIncomingMonitor(Closure $handler) : IPacketMonitor {
-    $this->listener->unregisterIncomingMonitor($handler);
-    return $this;
-  }
-
-  public function unregisterOutgoingMonitor(Closure $handler) : IPacketMonitor {
-    $this->listener->unregisterOutgoingMonitor($handler);
-    return $this;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitorListener.php b/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitorListener.php
deleted file mode 100644
index 8bfb2ea..0000000
--- a/src/imperazim/vendor/simplepackethandler/monitor/PacketMonitorListener.php
+++ /dev/null
@@ -1,119 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\monitor;
-
-use Closure;
-use pocketmine\Server;
-use pocketmine\plugin\Plugin;
-use pocketmine\event\EventPriority;
-use pocketmine\event\HandlerListManager;
-use pocketmine\event\RegisteredListener;
-use pocketmine\network\mcpe\NetworkSession;
-use pocketmine\network\mcpe\protocol\Packet;
-use pocketmine\network\mcpe\protocol\DataPacket;
-use pocketmine\event\server\DataPacketSendEvent;
-use pocketmine\event\server\DataPacketReceiveEvent;
-use pocketmine\network\mcpe\protocol\ClientboundPacket;
-use pocketmine\network\mcpe\protocol\ServerboundPacket;
-
-use imperazim\vendor\simplepackethandler\utils\Utils;
-
-final class PacketMonitorListener implements IPacketMonitor {
-
-  /**
-  * @template TPacket of Packet
-  * @template UPacket of TPacket
-  * @param Closure(UPacket, NetworkSession) : void $handler
-  * @param class-string<TPacket> $class
-  * @return int
-  */
-  private static function getPidFromHandler(Closure $handler, string $class) : int {
-    $classes = Utils::parseClosureSignature($handler, [$class, NetworkSession::class], "void");
-    assert(is_a($classes[0], DataPacket::class, true));
-    return $classes[0]::NETWORK_ID;
-  }
-
-  private ?RegisteredListener $incoming_event_handler = null;
-  private ?RegisteredListener $outgoing_event_handler = null;
-
-  /** @var array<int, array<int, Closure(ServerboundPacket, NetworkSession) : void>> */
-  private array $incoming_handlers = [];
-
-  /** @var array<int, array<int, Closure(ClientboundPacket, NetworkSession) : void>> */
-  private array $outgoing_handlers = [];
-
-  public function __construct(
-    readonly private Plugin $register,
-    readonly private bool $handle_cancelled
-  ) {}
-
-  public function monitorIncoming(Closure $handler) : IPacketMonitor {
-    $this->incoming_handlers[self::getPidFromHandler($handler, ServerboundPacket::class)][spl_object_id($handler)] = $handler;
-    $this->incoming_event_handler ?? = Server::getInstance()->getPluginManager()->registerEvent(DataPacketReceiveEvent::class, function(DataPacketReceiveEvent $event) : void {
-      /** @var DataPacket&ServerboundPacket $packet */
-      $packet = $event->getPacket();
-      if (isset($this->incoming_handlers[$pid = $packet::NETWORK_ID])) {
-        $origin = $event->getOrigin();
-        foreach ($this->incoming_handlers[$pid] as $handler) {
-          $handler($packet, $origin);
-        }
-      }
-    },
-      EventPriority::MONITOR,
-      $this->register,
-      $this->handle_cancelled);
-    return $this;
-  }
-
-  public function monitorOutgoing(Closure $handler) : IPacketMonitor {
-    $this->outgoing_handlers[self::getPidFromHandler($handler,
-      ClientboundPacket::class)][spl_object_id($handler)] = $handler;
-    $this->outgoing_event_handler ?? = Server::getInstance()->getPluginManager()->registerEvent(DataPacketSendEvent::class,
-      function(DataPacketSendEvent $event) : void {
-        /** @var DataPacket&ClientboundPacket $packet */
-        foreach ($event->getPackets() as $packet) {
-          if (isset($this->outgoing_handlers[$pid = $packet::NETWORK_ID])) {
-            foreach ($event->getTargets() as $target) {
-              foreach ($this->outgoing_handlers[$pid] as $handler) {
-                $handler($packet, $target);
-              }
-            }
-          }
-        }
-      },
-      EventPriority::MONITOR,
-      $this->register,
-      $this->handle_cancelled);
-    return $this;
-  }
-
-  public function unregisterIncomingMonitor(Closure $handler) : IPacketMonitor {
-    if (isset($this->incoming_handlers[$pid = self::getPidFromHandler($handler, ServerboundPacket::class)][$hid = spl_object_id($handler)])) {
-      unset($this->incoming_handlers[$pid][$hid]);
-      if (count($this->incoming_handlers[$pid]) === 0) {
-        unset($this->incoming_handlers[$pid]);
-        if (count($this->incoming_handlers) === 0) {
-          HandlerListManager::global()->getListFor(DataPacketReceiveEvent::class)->unregister($this->incoming_event_handler);
-          $this->incoming_event_handler = null;
-        }
-      }
-    }
-    return $this;
-  }
-
-  public function unregisterOutgoingMonitor(Closure $handler) : IPacketMonitor {
-    if (isset($this->outgoing_handlers[$pid = self::getPidFromHandler($handler, ClientboundPacket::class)][$hid = spl_object_id($handler)])) {
-      unset($this->outgoing_handlers[$pid][$hid]);
-      if (count($this->outgoing_handlers[$pid]) === 0) {
-        unset($this->outgoing_handlers[$pid]);
-        if (count($this->outgoing_handlers) === 0) {
-          HandlerListManager::global()->getListFor(DataPacketSendEvent::class)->unregister($this->outgoing_event_handler);
-          $this->outgoing_event_handler = null;
-        }
-      }
-    }
-    return $this;
-  }
-}
\ No newline at end of file
diff --git a/src/imperazim/vendor/simplepackethandler/utils/Utils.php b/src/imperazim/vendor/simplepackethandler/utils/Utils.php
deleted file mode 100644
index 7163fae..0000000
--- a/src/imperazim/vendor/simplepackethandler/utils/Utils.php
+++ /dev/null
@@ -1,49 +0,0 @@
-<?php
-
-declare(strict_types = 1);
-
-namespace imperazim\vendor\simplepackethandler\utils;
-
-use Closure;
-use ReflectionFunction;
-use ReflectionNamedType;
-use InvalidArgumentException;
-
-final class Utils {
-
-  /**
-  * @param Closure $closure
-  * @param string[] $params
-  * @param string $return_type
-  * @return string[]
-  */
-  public static function parseClosureSignature(Closure $closure, array $params, string $return_type) : array {
-    /** @noinspection PhpUnhandledExceptionInspection */
-    $method = new ReflectionFunction($closure);
-    $type = $method->getReturnType();
-    if (!($type instanceof ReflectionNamedType) || $type->allowsNull() || $type->getName() !== $return_type) {
-      throw new InvalidArgumentException("Return value of {$method->getName()} must be {$return_type}");
-    }
-
-    $parsed_params = [];
-    $parameters = $method->getParameters();
-    if (count($parameters) === count($params)) {
-      $parameter_index = 0;
-      foreach ($parameters as $parameter) {
-        $parameter_type = $parameter->getType();
-        $parameter_compare = $params[$parameter_index++];
-        if ($parameter_type instanceof ReflectionNamedType && !$parameter_type->allowsNull() && is_a($parameter_type->getName(), $parameter_compare, true)) {
-          $parsed_params[] = $parameter_type->getName();
-          continue;
-        }
-        break;
-      }
-
-      if (count($parsed_params) === count($params)) {
-        return $parsed_params;
-      }
-    }
-
-    throw new InvalidArgumentException("Closure must satisfy signature (" . implode(", ", $params) . ") : {$return_type}");
-  }
-}
\ No newline at end of file