From 15483c97238f4d9a5e0ce27b12b05aa6491fabb2 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Sun, 2 Jul 2023 01:57:46 +0200
Subject: [PATCH 1/8] adding build script for translation api classes

---
 build/generate-translation-api.php            |  109 +
 .../language/KnownTranslationFactory.php      | 2541 +++++++++++++++++
 .../CPlot/language/KnownTranslationKeys.php   |  554 ++++
 3 files changed, 3204 insertions(+)
 create mode 100644 build/generate-translation-api.php
 create mode 100644 src/ColinHDev/CPlot/language/KnownTranslationFactory.php
 create mode 100644 src/ColinHDev/CPlot/language/KnownTranslationKeys.php

diff --git a/build/generate-translation-api.php b/build/generate-translation-api.php
new file mode 100644
index 0000000..93feb21
--- /dev/null
+++ b/build/generate-translation-api.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+use pocketmine\lang\Translatable;
+
+require dirname(__DIR__) . '/vendor/autoload.php';
+
+const SHARED_HEADER = <<<'HEADER'
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\language;
+
+HEADER;
+
+const FACTORY_HEADER = SHARED_HEADER . <<<'HEADER'
+
+use pocketmine\lang\Translatable;
+
+/**
+ * This class contains factory methods for all the translations known to CPlot.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationFactory {
+
+
+HEADER;
+
+const KEY_HEADER = SHARED_HEADER . <<<'HEADER'
+
+/**
+ * This class contains constants for all the translations known to CPlot.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationKeys {
+
+
+HEADER;
+
+$fileContents = file(dirname(__DIR__) . "/resources/language/en_us.ini", FILE_SKIP_EMPTY_LINES);
+if ($fileContents === false) {
+    fwrite(STDERR, "Missing language files!\n");
+    exit(1);
+}
+
+generateClasses($fileContents);
+
+/**
+ * @param array<string, string> $fileContents
+ * @return void
+ */
+function generateClasses(array $fileContents) : void {
+    $factoryClass = FACTORY_HEADER;
+    $keyClass = KEY_HEADER;
+    $translatableClassName = (new ReflectionClass(Translatable::class))->getShortName();
+    $parameters = [];
+    foreach ($fileContents as $line) {
+        if (str_starts_with($line, ";")) {
+            preg_match_all("/{%(?P<digit>\d+)}\s=\s(?P<name>[^,()]+)/", $line, $matches);
+            foreach ($matches["name"] as $index => $name) {
+                $parameters[$matches["digit"][$index]] = parameterify($name);
+            }
+            continue;
+        }
+        preg_match("/^(.+?)\s*=\s*(.+)$/", $line, $matches);
+        if (!isset($matches[1])) {
+            continue;
+        }
+        $key = $matches[1];
+        $constantName = constantify($key);
+        ksort($parameters, SORT_NUMERIC);
+        $factoryClass .= "    public static function " . 
+            functionify($key) . 
+            "(" . implode(", ", array_map(fn(string $paramName) => "$translatableClassName|string \$$paramName", $parameters)) . ") : $translatableClassName {\n" .
+            "        return new $translatableClassName(KnownTranslationKeys::$constantName, [";
+        foreach($parameters as $parameterKey => $parameterName){
+            $factoryClass .= "\n            $parameterKey => \$$parameterName,";
+        }
+        if(count($parameters) > 0){
+            $factoryClass .= "\n        ";
+            $parameters = [];
+        }
+        $factoryClass .= "]);\n    }\n\n";
+        
+        $keyClass .= "    public const " . $constantName . " = \"" . $key . "\";\n";
+    }
+    $factoryClass .= "}";
+    $keyClass .= "}";
+    file_put_contents(dirname(__DIR__) . "/src/ColinHDev/CPlot/language/KnownTranslationFactory.php", $factoryClass);
+    file_put_contents(dirname(__DIR__) . "/src/ColinHDev/CPlot/language/KnownTranslationKeys.php", $keyClass);
+}
+
+function constantify(string $name) : string {
+    return strtoupper(str_replace([".", "-"], "_", $name));
+}
+
+function functionify(string $name) : string {
+    return str_replace([".", "-"], "_", $name);
+}
+
+function parameterify(string $name) : string {
+    return str_replace([" ", ".", "-"], "_", trim($name));
+}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/language/KnownTranslationFactory.php b/src/ColinHDev/CPlot/language/KnownTranslationFactory.php
new file mode 100644
index 0000000..d5de508
--- /dev/null
+++ b/src/ColinHDev/CPlot/language/KnownTranslationFactory.php
@@ -0,0 +1,2541 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\language;
+
+use pocketmine\lang\Translatable;
+
+/**
+ * This class contains factory methods for all the translations known to CPlot.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationFactory {
+
+    public static function prefix() : Translatable {
+        return new Translatable(KnownTranslationKeys::PREFIX, []);
+    }
+
+    public static function flag_type_greeting() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_GREETING, []);
+    }
+
+    public static function flag_category_greeting() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_GREETING, []);
+    }
+
+    public static function flag_description_greeting() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_GREETING, []);
+    }
+
+    public static function flag_type_farewell() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_FAREWELL, []);
+    }
+
+    public static function flag_category_farewell() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_FAREWELL, []);
+    }
+
+    public static function flag_description_farewell() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_FAREWELL, []);
+    }
+
+    public static function flag_type_item_drop() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_ITEM_DROP, []);
+    }
+
+    public static function flag_category_item_drop() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_ITEM_DROP, []);
+    }
+
+    public static function flag_description_item_drop() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_ITEM_DROP, []);
+    }
+
+    public static function flag_type_item_pickup() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_ITEM_PICKUP, []);
+    }
+
+    public static function flag_category_item_pickup() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_ITEM_PICKUP, []);
+    }
+
+    public static function flag_description_item_pickup() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_ITEM_PICKUP, []);
+    }
+
+    public static function flag_type_pvp() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_PVP, []);
+    }
+
+    public static function flag_category_pvp() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_PVP, []);
+    }
+
+    public static function flag_description_pvp() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_PVP, []);
+    }
+
+    public static function flag_type_pve() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_PVE, []);
+    }
+
+    public static function flag_category_pve() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_PVE, []);
+    }
+
+    public static function flag_description_pve() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_PVE, []);
+    }
+
+    public static function flag_type_explosion() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_EXPLOSION, []);
+    }
+
+    public static function flag_category_explosion() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_EXPLOSION, []);
+    }
+
+    public static function flag_description_explosion() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_EXPLOSION, []);
+    }
+
+    public static function flag_type_burning() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_BURNING, []);
+    }
+
+    public static function flag_category_burning() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_BURNING, []);
+    }
+
+    public static function flag_description_burning() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_BURNING, []);
+    }
+
+    public static function flag_type_flowing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_FLOWING, []);
+    }
+
+    public static function flag_category_flowing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_FLOWING, []);
+    }
+
+    public static function flag_description_flowing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_FLOWING, []);
+    }
+
+    public static function flag_type_growing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_GROWING, []);
+    }
+
+    public static function flag_category_growing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_GROWING, []);
+    }
+
+    public static function flag_description_growing() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_GROWING, []);
+    }
+
+    public static function flag_type_player_interact() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_PLAYER_INTERACT, []);
+    }
+
+    public static function flag_category_player_interact() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_PLAYER_INTERACT, []);
+    }
+
+    public static function flag_description_player_interact() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_PLAYER_INTERACT, []);
+    }
+
+    public static function flag_type_place() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_PLACE, []);
+    }
+
+    public static function flag_category_place() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_PLACE, []);
+    }
+
+    public static function flag_description_place() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_PLACE, []);
+    }
+
+    public static function flag_type_break() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_BREAK, []);
+    }
+
+    public static function flag_category_break() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_BREAK, []);
+    }
+
+    public static function flag_description_break() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_BREAK, []);
+    }
+
+    public static function flag_type_use() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_TYPE_USE, []);
+    }
+
+    public static function flag_category_use() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_CATEGORY_USE, []);
+    }
+
+    public static function flag_description_use() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION_USE, []);
+    }
+
+    public static function setting_type_inform_trusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_TRUSTED, []);
+    }
+
+    public static function setting_description_inform_trusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_TRUSTED, []);
+    }
+
+    public static function setting_category_inform_trusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_TRUSTED, []);
+    }
+
+    public static function setting_type_inform_untrusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_UNTRUSTED, []);
+    }
+
+    public static function setting_description_inform_untrusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_UNTRUSTED, []);
+    }
+
+    public static function setting_category_inform_untrusted() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_UNTRUSTED, []);
+    }
+
+    public static function setting_type_inform_added() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_ADDED, []);
+    }
+
+    public static function setting_description_inform_added() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_ADDED, []);
+    }
+
+    public static function setting_category_inform_added() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_ADDED, []);
+    }
+
+    public static function setting_type_inform_removed() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_REMOVED, []);
+    }
+
+    public static function setting_description_inform_removed() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_REMOVED, []);
+    }
+
+    public static function setting_category_inform_removed() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_REMOVED, []);
+    }
+
+    public static function setting_type_inform_denied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_DENIED, []);
+    }
+
+    public static function setting_description_inform_denied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_DENIED, []);
+    }
+
+    public static function setting_category_inform_denied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_DENIED, []);
+    }
+
+    public static function setting_type_inform_undenied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_UNDENIED, []);
+    }
+
+    public static function setting_description_inform_undenied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_UNDENIED, []);
+    }
+
+    public static function setting_category_inform_undenied() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_UNDENIED, []);
+    }
+
+    public static function setting_type_inform_rate_add() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_INFORM_RATE_ADD, []);
+    }
+
+    public static function setting_description_inform_rate_add() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_INFORM_RATE_ADD, []);
+    }
+
+    public static function setting_category_inform_rate_add() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_INFORM_RATE_ADD, []);
+    }
+
+    public static function setting_type_warn_flag() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_WARN_FLAG, []);
+    }
+
+    public static function setting_description_warn_flag() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_WARN_FLAG, []);
+    }
+
+    public static function setting_category_warn_flag() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_WARN_FLAG, []);
+    }
+
+    public static function setting_type_warn_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_WARN_FLAG_CHANGE, []);
+    }
+
+    public static function setting_description_warn_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_WARN_FLAG_CHANGE, []);
+    }
+
+    public static function setting_category_warn_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_WARN_FLAG_CHANGE, []);
+    }
+
+    public static function setting_type_teleport_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_TYPE_TELEPORT_FLAG_CHANGE, []);
+    }
+
+    public static function setting_description_teleport_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION_TELEPORT_FLAG_CHANGE, []);
+    }
+
+    public static function setting_category_teleport_flag_change() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_CATEGORY_TELEPORT_FLAG_CHANGE, []);
+    }
+
+    public static function format_time(Translatable|string $year, Translatable|string $month, Translatable|string $day, Translatable|string $hour, Translatable|string $minute, Translatable|string $second) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_TIME, [
+            0 => $year,
+            1 => $month,
+            2 => $day,
+            3 => $hour,
+            4 => $minute,
+            5 => $second,
+        ]);
+    }
+
+    public static function format_list_playerWithTime(Translatable|string $player_name, Translatable|string $time) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_PLAYERWITHTIME, [
+            0 => $player_name,
+            1 => $time,
+        ]);
+    }
+
+    public static function format_list_playerWithTime_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_PLAYERWITHTIME_SEPARATOR, []);
+    }
+
+    public static function format_list_player(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_PLAYER, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function format_list_player_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_PLAYER_SEPARATOR, []);
+    }
+
+    public static function format_list_category(Translatable|string $category, Translatable|string $list_of_elements) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_CATEGORY, [
+            0 => $category,
+            1 => $list_of_elements,
+        ]);
+    }
+
+    public static function format_list_category_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_CATEGORY_SEPARATOR, []);
+    }
+
+    public static function format_list_attribute(Translatable|string $attribute_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_ATTRIBUTE, [
+            0 => $attribute_ID,
+        ]);
+    }
+
+    public static function format_list_attribute_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_ATTRIBUTE_SEPARATOR, []);
+    }
+
+    public static function format_list_attributeWithValue(Translatable|string $attribute_ID, Translatable|string $attribute_value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_ATTRIBUTEWITHVALUE, [
+            0 => $attribute_ID,
+            1 => $attribute_value,
+        ]);
+    }
+
+    public static function format_list_attributeWithValue_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_ATTRIBUTEWITHVALUE_SEPARATOR, []);
+    }
+
+    public static function format_list_commandWithDescription(Translatable|string $command, Translatable|string $description) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_COMMANDWITHDESCRIPTION, [
+            0 => $command,
+            1 => $description,
+        ]);
+    }
+
+    public static function format_list_commandWithDescription_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_COMMANDWITHDESCRIPTION_SEPARATOR, []);
+    }
+
+    public static function format_list_schematic(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_SCHEMATIC, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function format_list_schematic_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::FORMAT_LIST_SCHEMATIC_SEPARATOR, []);
+    }
+
+    public static function economy_error_unknown() : Translatable {
+        return new Translatable(KnownTranslationKeys::ECONOMY_ERROR_UNKNOWN, []);
+    }
+
+    public static function economy_error_eventCancelled() : Translatable {
+        return new Translatable(KnownTranslationKeys::ECONOMY_ERROR_EVENTCANCELLED, []);
+    }
+
+    public static function economy_error_sourceNonExistent() : Translatable {
+        return new Translatable(KnownTranslationKeys::ECONOMY_ERROR_SOURCENONEXISTENT, []);
+    }
+
+    public static function economy_error_sourceUnderflow() : Translatable {
+        return new Translatable(KnownTranslationKeys::ECONOMY_ERROR_SOURCEUNDERFLOW, []);
+    }
+
+    public static function playerLogin_savePlayerDataError() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERLOGIN_SAVEPLAYERDATAERROR, []);
+    }
+
+    public static function playerMove_plotEnter_tip_coordinates(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTENTER_TIP_COORDINATES, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+        ]);
+    }
+
+    public static function playerMove_plotEnter_tip_owner(Translatable|string $list_of_owners) : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTENTER_TIP_OWNER, [
+            0 => $list_of_owners,
+        ]);
+    }
+
+    public static function playerMove_plotEnter_tip_owner_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTENTER_TIP_OWNER_SEPARATOR, []);
+    }
+
+    public static function playerMove_plotEnter_tip_claimable() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTENTER_TIP_CLAIMABLE, []);
+    }
+
+    public static function playerMove_plotEnter_tip_flag_greeting(Translatable|string $greeting_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTENTER_TIP_FLAG_GREETING, [
+            0 => $greeting_message,
+        ]);
+    }
+
+    public static function playerMove_plotLeave_tip_flag_farewell(Translatable|string $farewell_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_PLOTLEAVE_TIP_FLAG_FAREWELL, [
+            0 => $farewell_message,
+        ]);
+    }
+
+    public static function playerMove_setting_warn_flag(Translatable|string $flag_ID, Translatable|string $flag_value) : Translatable {
+        return new Translatable(KnownTranslationKeys::PLAYERMOVE_SETTING_WARN_FLAG, [
+            0 => $flag_ID,
+            1 => $flag_value,
+        ]);
+    }
+
+    public static function plot_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_NAME, []);
+    }
+
+    public static function plot_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_ALIAS, []);
+    }
+
+    public static function plot_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_DESCRIPTION, []);
+    }
+
+    public static function plot_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_USAGE, []);
+    }
+
+    public static function plot_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_PERMISSIONMESSAGE, []);
+    }
+
+    public static function plot_unknownSubcommand() : Translatable {
+        return new Translatable(KnownTranslationKeys::PLOT_UNKNOWNSUBCOMMAND, []);
+    }
+
+    public static function add_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_NAME, []);
+    }
+
+    public static function add_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_ALIAS, []);
+    }
+
+    public static function add_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_DESCRIPTION, []);
+    }
+
+    public static function add_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_USAGE, []);
+    }
+
+    public static function add_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_PERMISSIONMESSAGE, []);
+    }
+
+    public static function add_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_SENDERNOTONLINE, []);
+    }
+
+    public static function add_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function add_senderIsPlayer() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_SENDERISPLAYER, []);
+    }
+
+    public static function add_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_NOPLOTWORLD, []);
+    }
+
+    public static function add_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_NOPLOT, []);
+    }
+
+    public static function add_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_NOPLOTOWNER, []);
+    }
+
+    public static function add_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_NOTPLOTOWNER, []);
+    }
+
+    public static function add_playerAlreadyHelper(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_PLAYERALREADYHELPER, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function add_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_PLOTLOCKED, []);
+    }
+
+    public static function add_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_SAVEERROR, []);
+    }
+
+    public static function add_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function add_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::ADD_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function auto_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_NAME, []);
+    }
+
+    public static function auto_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_ALIAS, []);
+    }
+
+    public static function auto_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_DESCRIPTION, []);
+    }
+
+    public static function auto_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_USAGE, []);
+    }
+
+    public static function auto_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_PERMISSIONMESSAGE, []);
+    }
+
+    public static function auto_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_SENDERNOTONLINE, []);
+    }
+
+    public static function auto_plotLimitReached(Translatable|string $number_of_plots, Translatable|string $maximum_number_of_plots) : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_PLOTLIMITREACHED, [
+            0 => $number_of_plots,
+            1 => $maximum_number_of_plots,
+        ]);
+    }
+
+    public static function auto_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_NOPLOTWORLD, []);
+    }
+
+    public static function auto_noPlotFound() : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_NOPLOTFOUND, []);
+    }
+
+    public static function auto_teleportError(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_TELEPORTERROR, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+        ]);
+    }
+
+    public static function auto_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::AUTO_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+        ]);
+    }
+
+    public static function biome_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_NAME, []);
+    }
+
+    public static function biome_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_ALIAS, []);
+    }
+
+    public static function biome_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_DESCRIPTION, []);
+    }
+
+    public static function biome_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_USAGE, []);
+    }
+
+    public static function biome_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_PERMISSIONMESSAGE, []);
+    }
+
+    public static function biome_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_SENDERNOTONLINE, []);
+    }
+
+    public static function biome_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_NOPLOTWORLD, []);
+    }
+
+    public static function biome_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_NOPLOT, []);
+    }
+
+    public static function biome_plotBiome(Translatable|string $biome_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_PLOTBIOME, [
+            0 => $biome_name,
+        ]);
+    }
+
+    public static function biome_invalidBiome(Translatable|string $provided_biome_name, Translatable|string $list_of_all_known_biomes) : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_INVALIDBIOME, [
+            0 => $provided_biome_name,
+            1 => $list_of_all_known_biomes,
+        ]);
+    }
+
+    public static function biome_list(Translatable|string $biome_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_LIST, [
+            0 => $biome_name,
+        ]);
+    }
+
+    public static function biome_list_separator() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_LIST_SEPARATOR, []);
+    }
+
+    public static function biome_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_NOPLOTOWNER, []);
+    }
+
+    public static function biome_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_NOTPLOTOWNER, []);
+    }
+
+    public static function biome_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_PLOTLOCKED, []);
+    }
+
+    public static function biome_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_START, []);
+    }
+
+    public static function biome_finish(Translatable|string $duration, Translatable|string $biome_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::BIOME_FINISH, [
+            0 => $duration,
+            1 => $biome_name,
+        ]);
+    }
+
+    public static function border_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_NAME, []);
+    }
+
+    public static function border_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_ALIAS, []);
+    }
+
+    public static function border_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_DESCRIPTION, []);
+    }
+
+    public static function border_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_USAGE, []);
+    }
+
+    public static function border_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_PERMISSIONMESSAGE, []);
+    }
+
+    public static function border_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_SENDERNOTONLINE, []);
+    }
+
+    public static function border_invalidBlock(Translatable|string $block_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_INVALIDBLOCK, [
+            0 => $block_name,
+        ]);
+    }
+
+    public static function border_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_NOPLOTWORLD, []);
+    }
+
+    public static function border_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_NOPLOT, []);
+    }
+
+    public static function border_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_NOPLOTOWNER, []);
+    }
+
+    public static function border_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_NOTPLOTOWNER, []);
+    }
+
+    public static function border_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_PLOTLOCKED, []);
+    }
+
+    public static function border_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_START, []);
+    }
+
+    public static function border_finish(Translatable|string $duration, Translatable|string $block_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::BORDER_FINISH, [
+            0 => $duration,
+            1 => $block_name,
+        ]);
+    }
+
+    public static function claim_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_NAME, []);
+    }
+
+    public static function claim_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_ALIAS, []);
+    }
+
+    public static function claim_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_DESCRIPTION, []);
+    }
+
+    public static function claim_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_USAGE, []);
+    }
+
+    public static function claim_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_PERMISSIONMESSAGE, []);
+    }
+
+    public static function claim_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_SENDERNOTONLINE, []);
+    }
+
+    public static function claim_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_NOPLOTWORLD, []);
+    }
+
+    public static function claim_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_NOPLOT, []);
+    }
+
+    public static function claim_plotClaimed() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_PLOTCLAIMED, []);
+    }
+
+    public static function claim_plotClaimedBySender() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_PLOTCLAIMEDBYSENDER, []);
+    }
+
+    public static function claim_plotLimitReached(Translatable|string $number_of_plots, Translatable|string $maximum_number_of_plots) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_PLOTLIMITREACHED, [
+            0 => $number_of_plots,
+            1 => $maximum_number_of_plots,
+        ]);
+    }
+
+    public static function claim_chargeMoneyError(Translatable|string $price, Translatable|string $currency, Translatable|string $error_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_CHARGEMONEYERROR, [
+            0 => $price,
+            1 => $currency,
+            2 => $error_message,
+        ]);
+    }
+
+    public static function claim_chargedMoney(Translatable|string $price, Translatable|string $currency) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_CHARGEDMONEY, [
+            0 => $price,
+            1 => $currency,
+        ]);
+    }
+
+    public static function claim_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_SAVEERROR, []);
+    }
+
+    public static function claim_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLAIM_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+        ]);
+    }
+
+    public static function clear_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_NAME, []);
+    }
+
+    public static function clear_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_ALIAS, []);
+    }
+
+    public static function clear_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_DESCRIPTION, []);
+    }
+
+    public static function clear_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_USAGE, []);
+    }
+
+    public static function clear_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_PERMISSIONMESSAGE, []);
+    }
+
+    public static function clear_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_SENDERNOTONLINE, []);
+    }
+
+    public static function clear_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_NOPLOTWORLD, []);
+    }
+
+    public static function clear_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_NOPLOT, []);
+    }
+
+    public static function clear_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_NOPLOTOWNER, []);
+    }
+
+    public static function clear_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_NOTPLOTOWNER, []);
+    }
+
+    public static function clear_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_PLOTLOCKED, []);
+    }
+
+    public static function clear_chargeMoneyError(Translatable|string $price, Translatable|string $currency, Translatable|string $error_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_CHARGEMONEYERROR, [
+            0 => $price,
+            1 => $currency,
+            2 => $error_message,
+        ]);
+    }
+
+    public static function clear_chargedMoney(Translatable|string $price, Translatable|string $currency) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_CHARGEDMONEY, [
+            0 => $price,
+            1 => $currency,
+        ]);
+    }
+
+    public static function clear_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_START, []);
+    }
+
+    public static function clear_finish(Translatable|string $duration) : Translatable {
+        return new Translatable(KnownTranslationKeys::CLEAR_FINISH, [
+            0 => $duration,
+        ]);
+    }
+
+    public static function denied_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_NAME, []);
+    }
+
+    public static function denied_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_ALIAS, []);
+    }
+
+    public static function denied_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_DESCRIPTION, []);
+    }
+
+    public static function denied_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_USAGE, []);
+    }
+
+    public static function denied_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_PERMISSIONMESSAGE, []);
+    }
+
+    public static function denied_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_SENDERNOTONLINE, []);
+    }
+
+    public static function denied_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_NOPLOTWORLD, []);
+    }
+
+    public static function denied_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_NOPLOT, []);
+    }
+
+    public static function denied_noDeniedPlayers() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_NODENIEDPLAYERS, []);
+    }
+
+    public static function denied_success(Translatable|string $list_of_denied_players) : Translatable {
+        return new Translatable(KnownTranslationKeys::DENIED_SUCCESS, [
+            0 => $list_of_denied_players,
+        ]);
+    }
+
+    public static function deny_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_NAME, []);
+    }
+
+    public static function deny_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_ALIAS, []);
+    }
+
+    public static function deny_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_DESCRIPTION, []);
+    }
+
+    public static function deny_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_USAGE, []);
+    }
+
+    public static function deny_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_PERMISSIONMESSAGE, []);
+    }
+
+    public static function deny_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_SENDERNOTONLINE, []);
+    }
+
+    public static function deny_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function deny_senderIsPlayer() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_SENDERISPLAYER, []);
+    }
+
+    public static function deny_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_NOPLOTWORLD, []);
+    }
+
+    public static function deny_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_NOPLOT, []);
+    }
+
+    public static function deny_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_NOPLOTOWNER, []);
+    }
+
+    public static function deny_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_NOTPLOTOWNER, []);
+    }
+
+    public static function deny_playerAlreadyDenied(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_PLAYERALREADYDENIED, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function deny_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_PLOTLOCKED, []);
+    }
+
+    public static function deny_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_SAVEERROR, []);
+    }
+
+    public static function deny_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function deny_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::DENY_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function flag_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_NAME, []);
+    }
+
+    public static function flag_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_ALIAS, []);
+    }
+
+    public static function flag_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_DESCRIPTION, []);
+    }
+
+    public static function flag_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_USAGE, []);
+    }
+
+    public static function flag_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_PERMISSIONMESSAGE, []);
+    }
+
+    public static function flag_list_success(Translatable|string $list_of_flags) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_LIST_SUCCESS, [
+            0 => $list_of_flags,
+        ]);
+    }
+
+    public static function flag_info_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_INFO_USAGE, []);
+    }
+
+    public static function flag_info_flagNotFound(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_INFO_FLAGNOTFOUND, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function flag_info_success(Translatable|string $flag_ID, Translatable|string $category, Translatable|string $description, Translatable|string $type, Translatable|string $example_value, Translatable|string $default_value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_INFO_SUCCESS, [
+            0 => $flag_ID,
+            1 => $category,
+            2 => $description,
+            3 => $type,
+            4 => $example_value,
+            5 => $default_value,
+        ]);
+    }
+
+    public static function flag_here_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_HERE_SENDERNOTONLINE, []);
+    }
+
+    public static function flag_here_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_HERE_NOPLOTWORLD, []);
+    }
+
+    public static function flag_here_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_HERE_NOPLOT, []);
+    }
+
+    public static function flag_here_noFlags() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_HERE_NOFLAGS, []);
+    }
+
+    public static function flag_here_success(Translatable|string $list_of_flags) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_HERE_SUCCESS, [
+            0 => $list_of_flags,
+        ]);
+    }
+
+    public static function flag_set_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_USAGE, []);
+    }
+
+    public static function flag_set_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_SENDERNOTONLINE, []);
+    }
+
+    public static function flag_set_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_NOPLOTWORLD, []);
+    }
+
+    public static function flag_set_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_NOPLOT, []);
+    }
+
+    public static function flag_set_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_NOPLOTOWNER, []);
+    }
+
+    public static function flag_set_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_NOTPLOTOWNER, []);
+    }
+
+    public static function flag_set_flagNotFound(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_FLAGNOTFOUND, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function flag_set_permissionMessageForFlag(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_PERMISSIONMESSAGEFORFLAG, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function flag_set_parseError(Translatable|string $flag_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_PARSEERROR, [
+            0 => $flag_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function flag_set_success(Translatable|string $flag_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_SUCCESS, [
+            0 => $flag_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function flag_set_setting_warn_change_flag(Translatable|string $flag_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_SET_SETTING_WARN_CHANGE_FLAG, [
+            0 => $flag_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function flag_remove_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_USAGE, []);
+    }
+
+    public static function flag_remove_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_SENDERNOTONLINE, []);
+    }
+
+    public static function flag_remove_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_NOPLOTWORLD, []);
+    }
+
+    public static function flag_remove_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_NOPLOT, []);
+    }
+
+    public static function flag_remove_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_NOPLOTOWNER, []);
+    }
+
+    public static function flag_remove_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_NOTPLOTOWNER, []);
+    }
+
+    public static function flag_remove_flagNotSet(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_FLAGNOTSET, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function flag_remove_permissionMessageForFlag(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_PERMISSIONMESSAGEFORFLAG, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function flag_remove_parseError(Translatable|string $flag_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_PARSEERROR, [
+            0 => $flag_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function flag_remove_success_value(Translatable|string $flag_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_SUCCESS_VALUE, [
+            0 => $flag_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function flag_remove_success_flag(Translatable|string $flag_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::FLAG_REMOVE_SUCCESS_FLAG, [
+            0 => $flag_ID,
+        ]);
+    }
+
+    public static function generate_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_NAME, []);
+    }
+
+    public static function generate_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_ALIAS, []);
+    }
+
+    public static function generate_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_DESCRIPTION, []);
+    }
+
+    public static function generate_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_USAGE, []);
+    }
+
+    public static function generate_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_PERMISSIONMESSAGE, []);
+    }
+
+    public static function generate_worldExists(Translatable|string $world_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_WORLDEXISTS, [
+            0 => $world_name,
+        ]);
+    }
+
+    public static function generate_generateError() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_GENERATEERROR, []);
+    }
+
+    public static function generate_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_SAVEERROR, []);
+    }
+
+    public static function generate_success(Translatable|string $world_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::GENERATE_SUCCESS, [
+            0 => $world_name,
+        ]);
+    }
+
+    public static function helpers_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_NAME, []);
+    }
+
+    public static function helpers_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_ALIAS, []);
+    }
+
+    public static function helpers_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_DESCRIPTION, []);
+    }
+
+    public static function helpers_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_USAGE, []);
+    }
+
+    public static function helpers_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_PERMISSIONMESSAGE, []);
+    }
+
+    public static function helpers_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_SENDERNOTONLINE, []);
+    }
+
+    public static function helpers_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_NOPLOTWORLD, []);
+    }
+
+    public static function helpers_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_NOPLOT, []);
+    }
+
+    public static function helpers_noHelpers() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_NOHELPERS, []);
+    }
+
+    public static function helpers_success(Translatable|string $list_of_helpers) : Translatable {
+        return new Translatable(KnownTranslationKeys::HELPERS_SUCCESS, [
+            0 => $list_of_helpers,
+        ]);
+    }
+
+    public static function help_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_NAME, []);
+    }
+
+    public static function help_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_ALIAS, []);
+    }
+
+    public static function help_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_DESCRIPTION, []);
+    }
+
+    public static function help_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_USAGE, []);
+    }
+
+    public static function help_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_PERMISSIONMESSAGE, []);
+    }
+
+    public static function help_success(Translatable|string $current_page, Translatable|string $maximum_number_of_pages, Translatable|string $list_of_subcommands) : Translatable {
+        return new Translatable(KnownTranslationKeys::HELP_SUCCESS, [
+            0 => $current_page,
+            1 => $maximum_number_of_pages,
+            2 => $list_of_subcommands,
+        ]);
+    }
+
+    public static function info_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_NAME, []);
+    }
+
+    public static function info_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_ALIAS, []);
+    }
+
+    public static function info_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_DESCRIPTION, []);
+    }
+
+    public static function info_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_USAGE, []);
+    }
+
+    public static function info_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_PERMISSIONMESSAGE, []);
+    }
+
+    public static function info_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_SENDERNOTONLINE, []);
+    }
+
+    public static function info_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_NOPLOTWORLD, []);
+    }
+
+    public static function info_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_NOPLOT, []);
+    }
+
+    public static function info_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $list_of_owners, Translatable|string $alias, Translatable|string $biome_name, Translatable|string $list_of_trusted_players, Translatable|string $list_of_helpers, Translatable|string $list_of_denied_players, Translatable|string $list_of_flags) : Translatable {
+        return new Translatable(KnownTranslationKeys::INFO_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $list_of_owners,
+            4 => $alias,
+            5 => $biome_name,
+            6 => $list_of_trusted_players,
+            7 => $list_of_helpers,
+            8 => $list_of_denied_players,
+            9 => $list_of_flags,
+        ]);
+    }
+
+    public static function kick_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NAME, []);
+    }
+
+    public static function kick_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_ALIAS, []);
+    }
+
+    public static function kick_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_DESCRIPTION, []);
+    }
+
+    public static function kick_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_USAGE, []);
+    }
+
+    public static function kick_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_PERMISSIONMESSAGE, []);
+    }
+
+    public static function kick_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_SENDERNOTONLINE, []);
+    }
+
+    public static function kick_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NOPLOTWORLD, []);
+    }
+
+    public static function kick_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NOPLOT, []);
+    }
+
+    public static function kick_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NOPLOTOWNER, []);
+    }
+
+    public static function kick_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NOTPLOTOWNER, []);
+    }
+
+    public static function kick_targetNotOnline(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_TARGETNOTONLINE, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function kick_senderIsTarget() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_SENDERISTARGET, []);
+    }
+
+    public static function kick_targetNotOnPlot(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_TARGETNOTONPLOT, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function kick_kickError(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_KICKERROR, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function kick_targetMessage(Translatable|string $name_of_command_executor) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_TARGETMESSAGE, [
+            0 => $name_of_command_executor,
+        ]);
+    }
+
+    public static function kick_noneToKick() : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_NONETOKICK, []);
+    }
+
+    public static function kick_success_playerCount(Translatable|string $player_count) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_SUCCESS_PLAYERCOUNT, [
+            0 => $player_count,
+        ]);
+    }
+
+    public static function kick_success_playerName(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::KICK_SUCCESS_PLAYERNAME, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function merge_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NAME, []);
+    }
+
+    public static function merge_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_ALIAS, []);
+    }
+
+    public static function merge_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_DESCRIPTION, []);
+    }
+
+    public static function merge_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_USAGE, []);
+    }
+
+    public static function merge_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_PERMISSIONMESSAGE, []);
+    }
+
+    public static function merge_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_SENDERNOTONLINE, []);
+    }
+
+    public static function merge_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NOPLOTWORLD, []);
+    }
+
+    public static function merge_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NOPLOT, []);
+    }
+
+    public static function merge_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NOPLOTOWNER, []);
+    }
+
+    public static function merge_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NOTPLOTOWNER, []);
+    }
+
+    public static function merge_processDirectionError() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_PROCESSDIRECTIONERROR, []);
+    }
+
+    public static function merge_invalidSecondPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_INVALIDSECONDPLOT, []);
+    }
+
+    public static function merge_alreadyMerged() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_ALREADYMERGED, []);
+    }
+
+    public static function merge_notSamePlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_NOTSAMEPLOTOWNER, []);
+    }
+
+    public static function merge_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_PLOTLOCKED, []);
+    }
+
+    public static function merge_chargeMoneyError(Translatable|string $price, Translatable|string $currency, Translatable|string $error_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_CHARGEMONEYERROR, [
+            0 => $price,
+            1 => $currency,
+            2 => $error_message,
+        ]);
+    }
+
+    public static function merge_chargedMoney(Translatable|string $price, Translatable|string $currency) : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_CHARGEDMONEY, [
+            0 => $price,
+            1 => $currency,
+        ]);
+    }
+
+    public static function merge_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_START, []);
+    }
+
+    public static function merge_finish(Translatable|string $duration) : Translatable {
+        return new Translatable(KnownTranslationKeys::MERGE_FINISH, [
+            0 => $duration,
+        ]);
+    }
+
+    public static function middle_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_NAME, []);
+    }
+
+    public static function middle_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_ALIAS, []);
+    }
+
+    public static function middle_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_DESCRIPTION, []);
+    }
+
+    public static function middle_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_USAGE, []);
+    }
+
+    public static function middle_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_PERMISSIONMESSAGE, []);
+    }
+
+    public static function middle_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_SENDERNOTONLINE, []);
+    }
+
+    public static function middle_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_NOPLOTWORLD, []);
+    }
+
+    public static function middle_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_NOPLOT, []);
+    }
+
+    public static function middle_teleportError() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_TELEPORTERROR, []);
+    }
+
+    public static function middle_success() : Translatable {
+        return new Translatable(KnownTranslationKeys::MIDDLE_SUCCESS, []);
+    }
+
+    public static function remove_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_NAME, []);
+    }
+
+    public static function remove_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_ALIAS, []);
+    }
+
+    public static function remove_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_DESCRIPTION, []);
+    }
+
+    public static function remove_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_USAGE, []);
+    }
+
+    public static function remove_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_PERMISSIONMESSAGE, []);
+    }
+
+    public static function remove_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_SENDERNOTONLINE, []);
+    }
+
+    public static function remove_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function remove_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_NOPLOTWORLD, []);
+    }
+
+    public static function remove_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_NOPLOT, []);
+    }
+
+    public static function remove_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_NOPLOTOWNER, []);
+    }
+
+    public static function remove_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_NOTPLOTOWNER, []);
+    }
+
+    public static function remove_playerNotHelper(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_PLAYERNOTHELPER, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function remove_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_PLOTLOCKED, []);
+    }
+
+    public static function remove_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_SAVEERROR, []);
+    }
+
+    public static function remove_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function remove_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::REMOVE_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function reset_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_NAME, []);
+    }
+
+    public static function reset_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_ALIAS, []);
+    }
+
+    public static function reset_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_DESCRIPTION, []);
+    }
+
+    public static function reset_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_USAGE, []);
+    }
+
+    public static function reset_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_PERMISSIONMESSAGE, []);
+    }
+
+    public static function reset_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_SENDERNOTONLINE, []);
+    }
+
+    public static function reset_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_NOPLOTWORLD, []);
+    }
+
+    public static function reset_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_NOPLOT, []);
+    }
+
+    public static function reset_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_NOPLOTOWNER, []);
+    }
+
+    public static function reset_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_NOTPLOTOWNER, []);
+    }
+
+    public static function reset_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_PLOTLOCKED, []);
+    }
+
+    public static function reset_chargeMoneyError(Translatable|string $price, Translatable|string $currency, Translatable|string $error_message) : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_CHARGEMONEYERROR, [
+            0 => $price,
+            1 => $currency,
+            2 => $error_message,
+        ]);
+    }
+
+    public static function reset_chargedMoney(Translatable|string $price, Translatable|string $currency) : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_CHARGEDMONEY, [
+            0 => $price,
+            1 => $currency,
+        ]);
+    }
+
+    public static function reset_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_START, []);
+    }
+
+    public static function reset_finish(Translatable|string $duration) : Translatable {
+        return new Translatable(KnownTranslationKeys::RESET_FINISH, [
+            0 => $duration,
+        ]);
+    }
+
+    public static function schematic_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_NAME, []);
+    }
+
+    public static function schematic_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_ALIAS, []);
+    }
+
+    public static function schematic_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_DESCRIPTION, []);
+    }
+
+    public static function schematic_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_USAGE, []);
+    }
+
+    public static function schematic_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_PERMISSIONMESSAGE, []);
+    }
+
+    public static function schematic_list_noSchematics() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_LIST_NOSCHEMATICS, []);
+    }
+
+    public static function schematic_list_success(Translatable|string $list_of_schematics) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_LIST_SUCCESS, [
+            0 => $list_of_schematics,
+        ]);
+    }
+
+    public static function schematic_info_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_INFO_USAGE, []);
+    }
+
+    public static function schematic_info_schematicNotFound(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_INFO_SCHEMATICNOTFOUND, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_info_loadError(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_INFO_LOADERROR, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_info_success(Translatable|string $schematic_name, Translatable|string $creation_time, Translatable|string $type, Translatable|string $road_size, Translatable|string $plot_size) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_INFO_SUCCESS, [
+            0 => $schematic_name,
+            1 => $creation_time,
+            2 => $type,
+            3 => $road_size,
+            4 => $plot_size,
+        ]);
+    }
+
+    public static function schematic_save_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_USAGE, []);
+    }
+
+    public static function schematic_save_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_SENDERNOTONLINE, []);
+    }
+
+    public static function schematic_save_directoryNotFound() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_DIRECTORYNOTFOUND, []);
+    }
+
+    public static function schematic_save_schematicExists(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_SCHEMATICEXISTS, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_save_invalidType(Translatable|string $schematic_type) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_INVALIDTYPE, [
+            0 => $schematic_type,
+        ]);
+    }
+
+    public static function schematic_save_start(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_START, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_save_finish(Translatable|string $schematic_name, Translatable|string $duration) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_SAVE_FINISH, [
+            0 => $schematic_name,
+            1 => $duration,
+        ]);
+    }
+
+    public static function schematic_generate_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_USAGE, []);
+    }
+
+    public static function schematic_generate_worldExists(Translatable|string $world_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_WORLDEXISTS, [
+            0 => $world_name,
+        ]);
+    }
+
+    public static function schematic_generate_directoryNotFound() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_DIRECTORYNOTFOUND, []);
+    }
+
+    public static function schematic_generate_schematicNotFound(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_SCHEMATICNOTFOUND, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_generate_loadError(Translatable|string $schematic_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_LOADERROR, [
+            0 => $schematic_name,
+        ]);
+    }
+
+    public static function schematic_generate_generateError() : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_GENERATEERROR, []);
+    }
+
+    public static function schematic_generate_success(Translatable|string $world_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::SCHEMATIC_GENERATE_SUCCESS, [
+            0 => $world_name,
+        ]);
+    }
+
+    public static function setting_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_NAME, []);
+    }
+
+    public static function setting_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_ALIAS, []);
+    }
+
+    public static function setting_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_DESCRIPTION, []);
+    }
+
+    public static function setting_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_USAGE, []);
+    }
+
+    public static function setting_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_PERMISSIONMESSAGE, []);
+    }
+
+    public static function setting_list_success(Translatable|string $list_of_settings) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_LIST_SUCCESS, [
+            0 => $list_of_settings,
+        ]);
+    }
+
+    public static function setting_info_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_INFO_USAGE, []);
+    }
+
+    public static function setting_info_settingNotFound(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_INFO_SETTINGNOTFOUND, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function setting_info_success(Translatable|string $setting_ID, Translatable|string $category, Translatable|string $description, Translatable|string $type, Translatable|string $example_value, Translatable|string $default_value) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_INFO_SUCCESS, [
+            0 => $setting_ID,
+            1 => $category,
+            2 => $description,
+            3 => $type,
+            4 => $example_value,
+            5 => $default_value,
+        ]);
+    }
+
+    public static function setting_my_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_MY_SENDERNOTONLINE, []);
+    }
+
+    public static function setting_my_loadError() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_MY_LOADERROR, []);
+    }
+
+    public static function setting_my_noSettings() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_MY_NOSETTINGS, []);
+    }
+
+    public static function setting_my_success(Translatable|string $list_of_settings) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_MY_SUCCESS, [
+            0 => $list_of_settings,
+        ]);
+    }
+
+    public static function setting_set_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_USAGE, []);
+    }
+
+    public static function setting_set_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_SENDERNOTONLINE, []);
+    }
+
+    public static function setting_set_loadError() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_LOADERROR, []);
+    }
+
+    public static function setting_set_settingNotFound(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_SETTINGNOTFOUND, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function setting_set_permissionMessageForSetting(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_PERMISSIONMESSAGEFORSETTING, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function setting_set_parseError(Translatable|string $setting_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_PARSEERROR, [
+            0 => $setting_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function setting_set_success(Translatable|string $setting_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_SET_SUCCESS, [
+            0 => $setting_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function setting_remove_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_USAGE, []);
+    }
+
+    public static function setting_remove_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_SENDERNOTONLINE, []);
+    }
+
+    public static function setting_remove_loadError() : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_LOADERROR, []);
+    }
+
+    public static function setting_remove_settingNotSet(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_SETTINGNOTSET, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function setting_remove_permissionMessageForSetting(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_PERMISSIONMESSAGEFORSETTING, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function setting_remove_parseError(Translatable|string $setting_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_PARSEERROR, [
+            0 => $setting_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function setting_remove_success_value(Translatable|string $setting_ID, Translatable|string $value) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_SUCCESS_VALUE, [
+            0 => $setting_ID,
+            1 => $value,
+        ]);
+    }
+
+    public static function setting_remove_success_setting(Translatable|string $setting_ID) : Translatable {
+        return new Translatable(KnownTranslationKeys::SETTING_REMOVE_SUCCESS_SETTING, [
+            0 => $setting_ID,
+        ]);
+    }
+
+    public static function spawn_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_NAME, []);
+    }
+
+    public static function spawn_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_ALIAS, []);
+    }
+
+    public static function spawn_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_DESCRIPTION, []);
+    }
+
+    public static function spawn_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_USAGE, []);
+    }
+
+    public static function spawn_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_PERMISSIONMESSAGE, []);
+    }
+
+    public static function spawn_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_SENDERNOTONLINE, []);
+    }
+
+    public static function spawn_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_NOPLOTWORLD, []);
+    }
+
+    public static function spawn_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_NOPLOT, []);
+    }
+
+    public static function spawn_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_NOPLOTOWNER, []);
+    }
+
+    public static function spawn_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_NOTPLOTOWNER, []);
+    }
+
+    public static function spawn_success() : Translatable {
+        return new Translatable(KnownTranslationKeys::SPAWN_SUCCESS, []);
+    }
+
+    public static function trusted_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_NAME, []);
+    }
+
+    public static function trusted_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_ALIAS, []);
+    }
+
+    public static function trusted_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_DESCRIPTION, []);
+    }
+
+    public static function trusted_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_USAGE, []);
+    }
+
+    public static function trusted_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_PERMISSIONMESSAGE, []);
+    }
+
+    public static function trusted_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_SENDERNOTONLINE, []);
+    }
+
+    public static function trusted_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_NOPLOTWORLD, []);
+    }
+
+    public static function trusted_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_NOPLOT, []);
+    }
+
+    public static function trusted_noTrustedPlayers() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_NOTRUSTEDPLAYERS, []);
+    }
+
+    public static function trusted_success(Translatable|string $list_of_trusted_players) : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUSTED_SUCCESS, [
+            0 => $list_of_trusted_players,
+        ]);
+    }
+
+    public static function trust_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_NAME, []);
+    }
+
+    public static function trust_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_ALIAS, []);
+    }
+
+    public static function trust_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_DESCRIPTION, []);
+    }
+
+    public static function trust_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_USAGE, []);
+    }
+
+    public static function trust_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_PERMISSIONMESSAGE, []);
+    }
+
+    public static function trust_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_SENDERNOTONLINE, []);
+    }
+
+    public static function trust_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function trust_senderIsPlayer() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_SENDERISPLAYER, []);
+    }
+
+    public static function trust_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_NOPLOTWORLD, []);
+    }
+
+    public static function trust_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_NOPLOT, []);
+    }
+
+    public static function trust_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_NOPLOTOWNER, []);
+    }
+
+    public static function trust_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_NOTPLOTOWNER, []);
+    }
+
+    public static function trust_playerAlreadyTrusted(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_PLAYERALREADYTRUSTED, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function trust_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_PLOTLOCKED, []);
+    }
+
+    public static function trust_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_SAVEERROR, []);
+    }
+
+    public static function trust_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function trust_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::TRUST_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function undeny_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_NAME, []);
+    }
+
+    public static function undeny_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_ALIAS, []);
+    }
+
+    public static function undeny_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_DESCRIPTION, []);
+    }
+
+    public static function undeny_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_USAGE, []);
+    }
+
+    public static function undeny_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_PERMISSIONMESSAGE, []);
+    }
+
+    public static function undeny_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_SENDERNOTONLINE, []);
+    }
+
+    public static function undeny_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function undeny_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_NOPLOTWORLD, []);
+    }
+
+    public static function undeny_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_NOPLOT, []);
+    }
+
+    public static function undeny_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_NOPLOTOWNER, []);
+    }
+
+    public static function undeny_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_NOTPLOTOWNER, []);
+    }
+
+    public static function undeny_playerNotDenied(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_PLAYERNOTDENIED, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function undeny_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_PLOTLOCKED, []);
+    }
+
+    public static function undeny_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_SAVEERROR, []);
+    }
+
+    public static function undeny_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function undeny_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNDENY_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function untrust_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_NAME, []);
+    }
+
+    public static function untrust_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_ALIAS, []);
+    }
+
+    public static function untrust_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_DESCRIPTION, []);
+    }
+
+    public static function untrust_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_USAGE, []);
+    }
+
+    public static function untrust_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_PERMISSIONMESSAGE, []);
+    }
+
+    public static function untrust_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_SENDERNOTONLINE, []);
+    }
+
+    public static function untrust_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function untrust_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_NOPLOTWORLD, []);
+    }
+
+    public static function untrust_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_NOPLOT, []);
+    }
+
+    public static function untrust_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_NOPLOTOWNER, []);
+    }
+
+    public static function untrust_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_NOTPLOTOWNER, []);
+    }
+
+    public static function untrust_playerNotTrusted(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_PLAYERNOTTRUSTED, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function untrust_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_PLOTLOCKED, []);
+    }
+
+    public static function untrust_saveError() : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_SAVEERROR, []);
+    }
+
+    public static function untrust_success(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_SUCCESS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function untrust_success_player(Translatable|string $command_executor_name, Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::UNTRUST_SUCCESS_PLAYER, [
+            0 => $command_executor_name,
+            1 => $world_name,
+            2 => $x_coordinate,
+            3 => $z_coordinate,
+        ]);
+    }
+
+    public static function visit_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_NAME, []);
+    }
+
+    public static function visit_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_ALIAS, []);
+    }
+
+    public static function visit_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_DESCRIPTION, []);
+    }
+
+    public static function visit_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_USAGE, []);
+    }
+
+    public static function visit_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_PERMISSIONMESSAGE, []);
+    }
+
+    public static function visit_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_SENDERNOTONLINE, []);
+    }
+
+    public static function visit_loadPlotsError() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_LOADPLOTSERROR, []);
+    }
+
+    public static function visit_self_noPlots() : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_SELF_NOPLOTS, []);
+    }
+
+    public static function visit_self_noPlot(Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_SELF_NOPLOT, [
+            0 => $plot_number,
+        ]);
+    }
+
+    public static function visit_self_teleportError(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_SELF_TELEPORTERROR, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $plot_number,
+        ]);
+    }
+
+    public static function visit_self_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_SELF_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $plot_number,
+        ]);
+    }
+
+    public static function visit_other_playerNotFound(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_OTHER_PLAYERNOTFOUND, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function visit_other_noPlots(Translatable|string $player_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_OTHER_NOPLOTS, [
+            0 => $player_name,
+        ]);
+    }
+
+    public static function visit_other_noPlot(Translatable|string $player_name, Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_OTHER_NOPLOT, [
+            0 => $player_name,
+            1 => $plot_number,
+        ]);
+    }
+
+    public static function visit_other_teleportError(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $player_name, Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_OTHER_TELEPORTERROR, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $player_name,
+            4 => $plot_number,
+        ]);
+    }
+
+    public static function visit_other_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $player_name, Translatable|string $plot_number) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_OTHER_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $player_name,
+            4 => $plot_number,
+        ]);
+    }
+
+    public static function visit_alias_noPlot(Translatable|string $alias) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_ALIAS_NOPLOT, [
+            0 => $alias,
+        ]);
+    }
+
+    public static function visit_alias_teleportError(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $alias) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_ALIAS_TELEPORTERROR, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $alias,
+        ]);
+    }
+
+    public static function visit_alias_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate, Translatable|string $alias) : Translatable {
+        return new Translatable(KnownTranslationKeys::VISIT_ALIAS_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+            3 => $alias,
+        ]);
+    }
+
+    public static function wall_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_NAME, []);
+    }
+
+    public static function wall_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_ALIAS, []);
+    }
+
+    public static function wall_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_DESCRIPTION, []);
+    }
+
+    public static function wall_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_USAGE, []);
+    }
+
+    public static function wall_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_PERMISSIONMESSAGE, []);
+    }
+
+    public static function wall_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_SENDERNOTONLINE, []);
+    }
+
+    public static function wall_invalidBlock(Translatable|string $block_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_INVALIDBLOCK, [
+            0 => $block_name,
+        ]);
+    }
+
+    public static function wall_noPlotWorld() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_NOPLOTWORLD, []);
+    }
+
+    public static function wall_noPlot() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_NOPLOT, []);
+    }
+
+    public static function wall_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_NOPLOTOWNER, []);
+    }
+
+    public static function wall_notPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_NOTPLOTOWNER, []);
+    }
+
+    public static function wall_plotLocked() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_PLOTLOCKED, []);
+    }
+
+    public static function wall_start() : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_START, []);
+    }
+
+    public static function wall_finish(Translatable|string $duration, Translatable|string $block_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::WALL_FINISH, [
+            0 => $duration,
+            1 => $block_name,
+        ]);
+    }
+
+    public static function warp_name() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_NAME, []);
+    }
+
+    public static function warp_alias() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_ALIAS, []);
+    }
+
+    public static function warp_description() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_DESCRIPTION, []);
+    }
+
+    public static function warp_usage() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_USAGE, []);
+    }
+
+    public static function warp_permissionMessage() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_PERMISSIONMESSAGE, []);
+    }
+
+    public static function warp_senderNotOnline() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_SENDERNOTONLINE, []);
+    }
+
+    public static function warp_invalidPlotWorld(Translatable|string $world_name) : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_INVALIDPLOTWORLD, [
+            0 => $world_name,
+        ]);
+    }
+
+    public static function warp_invalidXCoordinate(Translatable|string $x_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_INVALIDXCOORDINATE, [
+            0 => $x_coordinate,
+        ]);
+    }
+
+    public static function warp_invalidZCoordinate(Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_INVALIDZCOORDINATE, [
+            0 => $z_coordinate,
+        ]);
+    }
+
+    public static function warp_loadPlotError() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_LOADPLOTERROR, []);
+    }
+
+    public static function warp_noPlotOwner() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_NOPLOTOWNER, []);
+    }
+
+    public static function warp_teleportError() : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_TELEPORTERROR, []);
+    }
+
+    public static function warp_success(Translatable|string $world_name, Translatable|string $x_coordinate, Translatable|string $z_coordinate) : Translatable {
+        return new Translatable(KnownTranslationKeys::WARP_SUCCESS, [
+            0 => $world_name,
+            1 => $x_coordinate,
+            2 => $z_coordinate,
+        ]);
+    }
+
+}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/language/KnownTranslationKeys.php b/src/ColinHDev/CPlot/language/KnownTranslationKeys.php
new file mode 100644
index 0000000..e2baf38
--- /dev/null
+++ b/src/ColinHDev/CPlot/language/KnownTranslationKeys.php
@@ -0,0 +1,554 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\language;
+
+/**
+ * This class contains constants for all the translations known to CPlot.
+ * This class is generated automatically, do NOT modify it by hand.
+ *
+ * @internal
+ */
+final class KnownTranslationKeys {
+
+    public const PREFIX = "prefix";
+    public const FLAG_TYPE_GREETING = "flag.type.greeting";
+    public const FLAG_CATEGORY_GREETING = "flag.category.greeting";
+    public const FLAG_DESCRIPTION_GREETING = "flag.description.greeting";
+    public const FLAG_TYPE_FAREWELL = "flag.type.farewell";
+    public const FLAG_CATEGORY_FAREWELL = "flag.category.farewell";
+    public const FLAG_DESCRIPTION_FAREWELL = "flag.description.farewell";
+    public const FLAG_TYPE_ITEM_DROP = "flag.type.item_drop";
+    public const FLAG_CATEGORY_ITEM_DROP = "flag.category.item_drop";
+    public const FLAG_DESCRIPTION_ITEM_DROP = "flag.description.item_drop";
+    public const FLAG_TYPE_ITEM_PICKUP = "flag.type.item_pickup";
+    public const FLAG_CATEGORY_ITEM_PICKUP = "flag.category.item_pickup";
+    public const FLAG_DESCRIPTION_ITEM_PICKUP = "flag.description.item_pickup";
+    public const FLAG_TYPE_PVP = "flag.type.pvp";
+    public const FLAG_CATEGORY_PVP = "flag.category.pvp";
+    public const FLAG_DESCRIPTION_PVP = "flag.description.pvp";
+    public const FLAG_TYPE_PVE = "flag.type.pve";
+    public const FLAG_CATEGORY_PVE = "flag.category.pve";
+    public const FLAG_DESCRIPTION_PVE = "flag.description.pve";
+    public const FLAG_TYPE_EXPLOSION = "flag.type.explosion";
+    public const FLAG_CATEGORY_EXPLOSION = "flag.category.explosion";
+    public const FLAG_DESCRIPTION_EXPLOSION = "flag.description.explosion";
+    public const FLAG_TYPE_BURNING = "flag.type.burning";
+    public const FLAG_CATEGORY_BURNING = "flag.category.burning";
+    public const FLAG_DESCRIPTION_BURNING = "flag.description.burning";
+    public const FLAG_TYPE_FLOWING = "flag.type.flowing";
+    public const FLAG_CATEGORY_FLOWING = "flag.category.flowing";
+    public const FLAG_DESCRIPTION_FLOWING = "flag.description.flowing";
+    public const FLAG_TYPE_GROWING = "flag.type.growing";
+    public const FLAG_CATEGORY_GROWING = "flag.category.growing";
+    public const FLAG_DESCRIPTION_GROWING = "flag.description.growing";
+    public const FLAG_TYPE_PLAYER_INTERACT = "flag.type.player_interact";
+    public const FLAG_CATEGORY_PLAYER_INTERACT = "flag.category.player_interact";
+    public const FLAG_DESCRIPTION_PLAYER_INTERACT = "flag.description.player_interact";
+    public const FLAG_TYPE_PLACE = "flag.type.place";
+    public const FLAG_CATEGORY_PLACE = "flag.category.place";
+    public const FLAG_DESCRIPTION_PLACE = "flag.description.place";
+    public const FLAG_TYPE_BREAK = "flag.type.break";
+    public const FLAG_CATEGORY_BREAK = "flag.category.break";
+    public const FLAG_DESCRIPTION_BREAK = "flag.description.break";
+    public const FLAG_TYPE_USE = "flag.type.use";
+    public const FLAG_CATEGORY_USE = "flag.category.use";
+    public const FLAG_DESCRIPTION_USE = "flag.description.use";
+    public const SETTING_TYPE_INFORM_TRUSTED = "setting.type.inform_trusted";
+    public const SETTING_DESCRIPTION_INFORM_TRUSTED = "setting.description.inform_trusted";
+    public const SETTING_CATEGORY_INFORM_TRUSTED = "setting.category.inform_trusted";
+    public const SETTING_TYPE_INFORM_UNTRUSTED = "setting.type.inform_untrusted";
+    public const SETTING_DESCRIPTION_INFORM_UNTRUSTED = "setting.description.inform_untrusted";
+    public const SETTING_CATEGORY_INFORM_UNTRUSTED = "setting.category.inform_untrusted";
+    public const SETTING_TYPE_INFORM_ADDED = "setting.type.inform_added";
+    public const SETTING_DESCRIPTION_INFORM_ADDED = "setting.description.inform_added";
+    public const SETTING_CATEGORY_INFORM_ADDED = "setting.category.inform_added";
+    public const SETTING_TYPE_INFORM_REMOVED = "setting.type.inform_removed";
+    public const SETTING_DESCRIPTION_INFORM_REMOVED = "setting.description.inform_removed";
+    public const SETTING_CATEGORY_INFORM_REMOVED = "setting.category.inform_removed";
+    public const SETTING_TYPE_INFORM_DENIED = "setting.type.inform_denied";
+    public const SETTING_DESCRIPTION_INFORM_DENIED = "setting.description.inform_denied";
+    public const SETTING_CATEGORY_INFORM_DENIED = "setting.category.inform_denied";
+    public const SETTING_TYPE_INFORM_UNDENIED = "setting.type.inform_undenied";
+    public const SETTING_DESCRIPTION_INFORM_UNDENIED = "setting.description.inform_undenied";
+    public const SETTING_CATEGORY_INFORM_UNDENIED = "setting.category.inform_undenied";
+    public const SETTING_TYPE_INFORM_RATE_ADD = "setting.type.inform_rate_add";
+    public const SETTING_DESCRIPTION_INFORM_RATE_ADD = "setting.description.inform_rate_add";
+    public const SETTING_CATEGORY_INFORM_RATE_ADD = "setting.category.inform_rate_add";
+    public const SETTING_TYPE_WARN_FLAG = "setting.type.warn_flag";
+    public const SETTING_DESCRIPTION_WARN_FLAG = "setting.description.warn_flag";
+    public const SETTING_CATEGORY_WARN_FLAG = "setting.category.warn_flag";
+    public const SETTING_TYPE_WARN_FLAG_CHANGE = "setting.type.warn_flag_change";
+    public const SETTING_DESCRIPTION_WARN_FLAG_CHANGE = "setting.description.warn_flag_change";
+    public const SETTING_CATEGORY_WARN_FLAG_CHANGE = "setting.category.warn_flag_change";
+    public const SETTING_TYPE_TELEPORT_FLAG_CHANGE = "setting.type.teleport_flag_change";
+    public const SETTING_DESCRIPTION_TELEPORT_FLAG_CHANGE = "setting.description.teleport_flag_change";
+    public const SETTING_CATEGORY_TELEPORT_FLAG_CHANGE = "setting.category.teleport_flag_change";
+    public const FORMAT_TIME = "format.time";
+    public const FORMAT_LIST_PLAYERWITHTIME = "format.list.playerWithTime";
+    public const FORMAT_LIST_PLAYERWITHTIME_SEPARATOR = "format.list.playerWithTime.separator";
+    public const FORMAT_LIST_PLAYER = "format.list.player";
+    public const FORMAT_LIST_PLAYER_SEPARATOR = "format.list.player.separator";
+    public const FORMAT_LIST_CATEGORY = "format.list.category";
+    public const FORMAT_LIST_CATEGORY_SEPARATOR = "format.list.category.separator";
+    public const FORMAT_LIST_ATTRIBUTE = "format.list.attribute";
+    public const FORMAT_LIST_ATTRIBUTE_SEPARATOR = "format.list.attribute.separator";
+    public const FORMAT_LIST_ATTRIBUTEWITHVALUE = "format.list.attributeWithValue";
+    public const FORMAT_LIST_ATTRIBUTEWITHVALUE_SEPARATOR = "format.list.attributeWithValue.separator";
+    public const FORMAT_LIST_COMMANDWITHDESCRIPTION = "format.list.commandWithDescription";
+    public const FORMAT_LIST_COMMANDWITHDESCRIPTION_SEPARATOR = "format.list.commandWithDescription.separator";
+    public const FORMAT_LIST_SCHEMATIC = "format.list.schematic";
+    public const FORMAT_LIST_SCHEMATIC_SEPARATOR = "format.list.schematic.separator";
+    public const ECONOMY_ERROR_UNKNOWN = "economy.error.unknown";
+    public const ECONOMY_ERROR_EVENTCANCELLED = "economy.error.eventCancelled";
+    public const ECONOMY_ERROR_SOURCENONEXISTENT = "economy.error.sourceNonExistent";
+    public const ECONOMY_ERROR_SOURCEUNDERFLOW = "economy.error.sourceUnderflow";
+    public const PLAYERLOGIN_SAVEPLAYERDATAERROR = "playerLogin.savePlayerDataError";
+    public const PLAYERMOVE_PLOTENTER_TIP_COORDINATES = "playerMove.plotEnter.tip.coordinates";
+    public const PLAYERMOVE_PLOTENTER_TIP_OWNER = "playerMove.plotEnter.tip.owner";
+    public const PLAYERMOVE_PLOTENTER_TIP_OWNER_SEPARATOR = "playerMove.plotEnter.tip.owner.separator";
+    public const PLAYERMOVE_PLOTENTER_TIP_CLAIMABLE = "playerMove.plotEnter.tip.claimable";
+    public const PLAYERMOVE_PLOTENTER_TIP_FLAG_GREETING = "playerMove.plotEnter.tip.flag.greeting";
+    public const PLAYERMOVE_PLOTLEAVE_TIP_FLAG_FAREWELL = "playerMove.plotLeave.tip.flag.farewell";
+    public const PLAYERMOVE_SETTING_WARN_FLAG = "playerMove.setting.warn_flag";
+    public const PLOT_NAME = "plot.name";
+    public const PLOT_ALIAS = "plot.alias";
+    public const PLOT_DESCRIPTION = "plot.description";
+    public const PLOT_USAGE = "plot.usage";
+    public const PLOT_PERMISSIONMESSAGE = "plot.permissionMessage";
+    public const PLOT_UNKNOWNSUBCOMMAND = "plot.unknownSubcommand";
+    public const ADD_NAME = "add.name";
+    public const ADD_ALIAS = "add.alias";
+    public const ADD_DESCRIPTION = "add.description";
+    public const ADD_USAGE = "add.usage";
+    public const ADD_PERMISSIONMESSAGE = "add.permissionMessage";
+    public const ADD_SENDERNOTONLINE = "add.senderNotOnline";
+    public const ADD_PLAYERNOTFOUND = "add.playerNotFound";
+    public const ADD_SENDERISPLAYER = "add.senderIsPlayer";
+    public const ADD_NOPLOTWORLD = "add.noPlotWorld";
+    public const ADD_NOPLOT = "add.noPlot";
+    public const ADD_NOPLOTOWNER = "add.noPlotOwner";
+    public const ADD_NOTPLOTOWNER = "add.notPlotOwner";
+    public const ADD_PLAYERALREADYHELPER = "add.playerAlreadyHelper";
+    public const ADD_PLOTLOCKED = "add.plotLocked";
+    public const ADD_SAVEERROR = "add.saveError";
+    public const ADD_SUCCESS = "add.success";
+    public const ADD_SUCCESS_PLAYER = "add.success.player";
+    public const AUTO_NAME = "auto.name";
+    public const AUTO_ALIAS = "auto.alias";
+    public const AUTO_DESCRIPTION = "auto.description";
+    public const AUTO_USAGE = "auto.usage";
+    public const AUTO_PERMISSIONMESSAGE = "auto.permissionMessage";
+    public const AUTO_SENDERNOTONLINE = "auto.senderNotOnline";
+    public const AUTO_PLOTLIMITREACHED = "auto.plotLimitReached";
+    public const AUTO_NOPLOTWORLD = "auto.noPlotWorld";
+    public const AUTO_NOPLOTFOUND = "auto.noPlotFound";
+    public const AUTO_TELEPORTERROR = "auto.teleportError";
+    public const AUTO_SUCCESS = "auto.success";
+    public const BIOME_NAME = "biome.name";
+    public const BIOME_ALIAS = "biome.alias";
+    public const BIOME_DESCRIPTION = "biome.description";
+    public const BIOME_USAGE = "biome.usage";
+    public const BIOME_PERMISSIONMESSAGE = "biome.permissionMessage";
+    public const BIOME_SENDERNOTONLINE = "biome.senderNotOnline";
+    public const BIOME_NOPLOTWORLD = "biome.noPlotWorld";
+    public const BIOME_NOPLOT = "biome.noPlot";
+    public const BIOME_PLOTBIOME = "biome.plotBiome";
+    public const BIOME_INVALIDBIOME = "biome.invalidBiome";
+    public const BIOME_LIST = "biome.list";
+    public const BIOME_LIST_SEPARATOR = "biome.list.separator";
+    public const BIOME_NOPLOTOWNER = "biome.noPlotOwner";
+    public const BIOME_NOTPLOTOWNER = "biome.notPlotOwner";
+    public const BIOME_PLOTLOCKED = "biome.plotLocked";
+    public const BIOME_START = "biome.start";
+    public const BIOME_FINISH = "biome.finish";
+    public const BORDER_NAME = "border.name";
+    public const BORDER_ALIAS = "border.alias";
+    public const BORDER_DESCRIPTION = "border.description";
+    public const BORDER_USAGE = "border.usage";
+    public const BORDER_PERMISSIONMESSAGE = "border.permissionMessage";
+    public const BORDER_SENDERNOTONLINE = "border.senderNotOnline";
+    public const BORDER_INVALIDBLOCK = "border.invalidBlock";
+    public const BORDER_NOPLOTWORLD = "border.noPlotWorld";
+    public const BORDER_NOPLOT = "border.noPlot";
+    public const BORDER_NOPLOTOWNER = "border.noPlotOwner";
+    public const BORDER_NOTPLOTOWNER = "border.notPlotOwner";
+    public const BORDER_PLOTLOCKED = "border.plotLocked";
+    public const BORDER_START = "border.start";
+    public const BORDER_FINISH = "border.finish";
+    public const CLAIM_NAME = "claim.name";
+    public const CLAIM_ALIAS = "claim.alias";
+    public const CLAIM_DESCRIPTION = "claim.description";
+    public const CLAIM_USAGE = "claim.usage";
+    public const CLAIM_PERMISSIONMESSAGE = "claim.permissionMessage";
+    public const CLAIM_SENDERNOTONLINE = "claim.senderNotOnline";
+    public const CLAIM_NOPLOTWORLD = "claim.noPlotWorld";
+    public const CLAIM_NOPLOT = "claim.noPlot";
+    public const CLAIM_PLOTCLAIMED = "claim.plotClaimed";
+    public const CLAIM_PLOTCLAIMEDBYSENDER = "claim.plotClaimedBySender";
+    public const CLAIM_PLOTLIMITREACHED = "claim.plotLimitReached";
+    public const CLAIM_CHARGEMONEYERROR = "claim.chargeMoneyError";
+    public const CLAIM_CHARGEDMONEY = "claim.chargedMoney";
+    public const CLAIM_SAVEERROR = "claim.saveError";
+    public const CLAIM_SUCCESS = "claim.success";
+    public const CLEAR_NAME = "clear.name";
+    public const CLEAR_ALIAS = "clear.alias";
+    public const CLEAR_DESCRIPTION = "clear.description";
+    public const CLEAR_USAGE = "clear.usage";
+    public const CLEAR_PERMISSIONMESSAGE = "clear.permissionMessage";
+    public const CLEAR_SENDERNOTONLINE = "clear.senderNotOnline";
+    public const CLEAR_NOPLOTWORLD = "clear.noPlotWorld";
+    public const CLEAR_NOPLOT = "clear.noPlot";
+    public const CLEAR_NOPLOTOWNER = "clear.noPlotOwner";
+    public const CLEAR_NOTPLOTOWNER = "clear.notPlotOwner";
+    public const CLEAR_PLOTLOCKED = "clear.plotLocked";
+    public const CLEAR_CHARGEMONEYERROR = "clear.chargeMoneyError";
+    public const CLEAR_CHARGEDMONEY = "clear.chargedMoney";
+    public const CLEAR_START = "clear.start";
+    public const CLEAR_FINISH = "clear.finish";
+    public const DENIED_NAME = "denied.name";
+    public const DENIED_ALIAS = "denied.alias";
+    public const DENIED_DESCRIPTION = "denied.description";
+    public const DENIED_USAGE = "denied.usage";
+    public const DENIED_PERMISSIONMESSAGE = "denied.permissionMessage";
+    public const DENIED_SENDERNOTONLINE = "denied.senderNotOnline";
+    public const DENIED_NOPLOTWORLD = "denied.noPlotWorld";
+    public const DENIED_NOPLOT = "denied.noPlot";
+    public const DENIED_NODENIEDPLAYERS = "denied.noDeniedPlayers";
+    public const DENIED_SUCCESS = "denied.success";
+    public const DENY_NAME = "deny.name";
+    public const DENY_ALIAS = "deny.alias";
+    public const DENY_DESCRIPTION = "deny.description";
+    public const DENY_USAGE = "deny.usage";
+    public const DENY_PERMISSIONMESSAGE = "deny.permissionMessage";
+    public const DENY_SENDERNOTONLINE = "deny.senderNotOnline";
+    public const DENY_PLAYERNOTFOUND = "deny.playerNotFound";
+    public const DENY_SENDERISPLAYER = "deny.senderIsPlayer";
+    public const DENY_NOPLOTWORLD = "deny.noPlotWorld";
+    public const DENY_NOPLOT = "deny.noPlot";
+    public const DENY_NOPLOTOWNER = "deny.noPlotOwner";
+    public const DENY_NOTPLOTOWNER = "deny.notPlotOwner";
+    public const DENY_PLAYERALREADYDENIED = "deny.playerAlreadyDenied";
+    public const DENY_PLOTLOCKED = "deny.plotLocked";
+    public const DENY_SAVEERROR = "deny.saveError";
+    public const DENY_SUCCESS = "deny.success";
+    public const DENY_SUCCESS_PLAYER = "deny.success.player";
+    public const FLAG_NAME = "flag.name";
+    public const FLAG_ALIAS = "flag.alias";
+    public const FLAG_DESCRIPTION = "flag.description";
+    public const FLAG_USAGE = "flag.usage";
+    public const FLAG_PERMISSIONMESSAGE = "flag.permissionMessage";
+    public const FLAG_LIST_SUCCESS = "flag.list.success";
+    public const FLAG_INFO_USAGE = "flag.info.usage";
+    public const FLAG_INFO_FLAGNOTFOUND = "flag.info.flagNotFound";
+    public const FLAG_INFO_SUCCESS = "flag.info.success";
+    public const FLAG_HERE_SENDERNOTONLINE = "flag.here.senderNotOnline";
+    public const FLAG_HERE_NOPLOTWORLD = "flag.here.noPlotWorld";
+    public const FLAG_HERE_NOPLOT = "flag.here.noPlot";
+    public const FLAG_HERE_NOFLAGS = "flag.here.noFlags";
+    public const FLAG_HERE_SUCCESS = "flag.here.success";
+    public const FLAG_SET_USAGE = "flag.set.usage";
+    public const FLAG_SET_SENDERNOTONLINE = "flag.set.senderNotOnline";
+    public const FLAG_SET_NOPLOTWORLD = "flag.set.noPlotWorld";
+    public const FLAG_SET_NOPLOT = "flag.set.noPlot";
+    public const FLAG_SET_NOPLOTOWNER = "flag.set.noPlotOwner";
+    public const FLAG_SET_NOTPLOTOWNER = "flag.set.notPlotOwner";
+    public const FLAG_SET_FLAGNOTFOUND = "flag.set.flagNotFound";
+    public const FLAG_SET_PERMISSIONMESSAGEFORFLAG = "flag.set.permissionMessageForFlag";
+    public const FLAG_SET_PARSEERROR = "flag.set.parseError";
+    public const FLAG_SET_SUCCESS = "flag.set.success";
+    public const FLAG_SET_SETTING_WARN_CHANGE_FLAG = "flag.set.setting.warn_change_flag";
+    public const FLAG_REMOVE_USAGE = "flag.remove.usage";
+    public const FLAG_REMOVE_SENDERNOTONLINE = "flag.remove.senderNotOnline";
+    public const FLAG_REMOVE_NOPLOTWORLD = "flag.remove.noPlotWorld";
+    public const FLAG_REMOVE_NOPLOT = "flag.remove.noPlot";
+    public const FLAG_REMOVE_NOPLOTOWNER = "flag.remove.noPlotOwner";
+    public const FLAG_REMOVE_NOTPLOTOWNER = "flag.remove.notPlotOwner";
+    public const FLAG_REMOVE_FLAGNOTSET = "flag.remove.flagNotSet";
+    public const FLAG_REMOVE_PERMISSIONMESSAGEFORFLAG = "flag.remove.permissionMessageForFlag";
+    public const FLAG_REMOVE_PARSEERROR = "flag.remove.parseError";
+    public const FLAG_REMOVE_SUCCESS_VALUE = "flag.remove.success.value";
+    public const FLAG_REMOVE_SUCCESS_FLAG = "flag.remove.success.flag";
+    public const GENERATE_NAME = "generate.name";
+    public const GENERATE_ALIAS = "generate.alias";
+    public const GENERATE_DESCRIPTION = "generate.description";
+    public const GENERATE_USAGE = "generate.usage";
+    public const GENERATE_PERMISSIONMESSAGE = "generate.permissionMessage";
+    public const GENERATE_WORLDEXISTS = "generate.worldExists";
+    public const GENERATE_GENERATEERROR = "generate.generateError";
+    public const GENERATE_SAVEERROR = "generate.saveError";
+    public const GENERATE_SUCCESS = "generate.success";
+    public const HELPERS_NAME = "helpers.name";
+    public const HELPERS_ALIAS = "helpers.alias";
+    public const HELPERS_DESCRIPTION = "helpers.description";
+    public const HELPERS_USAGE = "helpers.usage";
+    public const HELPERS_PERMISSIONMESSAGE = "helpers.permissionMessage";
+    public const HELPERS_SENDERNOTONLINE = "helpers.senderNotOnline";
+    public const HELPERS_NOPLOTWORLD = "helpers.noPlotWorld";
+    public const HELPERS_NOPLOT = "helpers.noPlot";
+    public const HELPERS_NOHELPERS = "helpers.noHelpers";
+    public const HELPERS_SUCCESS = "helpers.success";
+    public const HELP_NAME = "help.name";
+    public const HELP_ALIAS = "help.alias";
+    public const HELP_DESCRIPTION = "help.description";
+    public const HELP_USAGE = "help.usage";
+    public const HELP_PERMISSIONMESSAGE = "help.permissionMessage";
+    public const HELP_SUCCESS = "help.success";
+    public const INFO_NAME = "info.name";
+    public const INFO_ALIAS = "info.alias";
+    public const INFO_DESCRIPTION = "info.description";
+    public const INFO_USAGE = "info.usage";
+    public const INFO_PERMISSIONMESSAGE = "info.permissionMessage";
+    public const INFO_SENDERNOTONLINE = "info.senderNotOnline";
+    public const INFO_NOPLOTWORLD = "info.noPlotWorld";
+    public const INFO_NOPLOT = "info.noPlot";
+    public const INFO_SUCCESS = "info.success";
+    public const KICK_NAME = "kick.name";
+    public const KICK_ALIAS = "kick.alias";
+    public const KICK_DESCRIPTION = "kick.description";
+    public const KICK_USAGE = "kick.usage";
+    public const KICK_PERMISSIONMESSAGE = "kick.permissionMessage";
+    public const KICK_SENDERNOTONLINE = "kick.senderNotOnline";
+    public const KICK_NOPLOTWORLD = "kick.noPlotWorld";
+    public const KICK_NOPLOT = "kick.noPlot";
+    public const KICK_NOPLOTOWNER = "kick.noPlotOwner";
+    public const KICK_NOTPLOTOWNER = "kick.notPlotOwner";
+    public const KICK_TARGETNOTONLINE = "kick.targetNotOnline";
+    public const KICK_SENDERISTARGET = "kick.senderIsTarget";
+    public const KICK_TARGETNOTONPLOT = "kick.targetNotOnPlot";
+    public const KICK_KICKERROR = "kick.kickError";
+    public const KICK_TARGETMESSAGE = "kick.targetMessage";
+    public const KICK_NONETOKICK = "kick.noneToKick";
+    public const KICK_SUCCESS_PLAYERCOUNT = "kick.success.playerCount";
+    public const KICK_SUCCESS_PLAYERNAME = "kick.success.playerName";
+    public const MERGE_NAME = "merge.name";
+    public const MERGE_ALIAS = "merge.alias";
+    public const MERGE_DESCRIPTION = "merge.description";
+    public const MERGE_USAGE = "merge.usage";
+    public const MERGE_PERMISSIONMESSAGE = "merge.permissionMessage";
+    public const MERGE_SENDERNOTONLINE = "merge.senderNotOnline";
+    public const MERGE_NOPLOTWORLD = "merge.noPlotWorld";
+    public const MERGE_NOPLOT = "merge.noPlot";
+    public const MERGE_NOPLOTOWNER = "merge.noPlotOwner";
+    public const MERGE_NOTPLOTOWNER = "merge.notPlotOwner";
+    public const MERGE_PROCESSDIRECTIONERROR = "merge.processDirectionError";
+    public const MERGE_INVALIDSECONDPLOT = "merge.invalidSecondPlot";
+    public const MERGE_ALREADYMERGED = "merge.alreadyMerged";
+    public const MERGE_NOTSAMEPLOTOWNER = "merge.notSamePlotOwner";
+    public const MERGE_PLOTLOCKED = "merge.plotLocked";
+    public const MERGE_CHARGEMONEYERROR = "merge.chargeMoneyError";
+    public const MERGE_CHARGEDMONEY = "merge.chargedMoney";
+    public const MERGE_START = "merge.start";
+    public const MERGE_FINISH = "merge.finish";
+    public const MIDDLE_NAME = "middle.name";
+    public const MIDDLE_ALIAS = "middle.alias";
+    public const MIDDLE_DESCRIPTION = "middle.description";
+    public const MIDDLE_USAGE = "middle.usage";
+    public const MIDDLE_PERMISSIONMESSAGE = "middle.permissionMessage";
+    public const MIDDLE_SENDERNOTONLINE = "middle.senderNotOnline";
+    public const MIDDLE_NOPLOTWORLD = "middle.noPlotWorld";
+    public const MIDDLE_NOPLOT = "middle.noPlot";
+    public const MIDDLE_TELEPORTERROR = "middle.teleportError";
+    public const MIDDLE_SUCCESS = "middle.success";
+    public const REMOVE_NAME = "remove.name";
+    public const REMOVE_ALIAS = "remove.alias";
+    public const REMOVE_DESCRIPTION = "remove.description";
+    public const REMOVE_USAGE = "remove.usage";
+    public const REMOVE_PERMISSIONMESSAGE = "remove.permissionMessage";
+    public const REMOVE_SENDERNOTONLINE = "remove.senderNotOnline";
+    public const REMOVE_PLAYERNOTFOUND = "remove.playerNotFound";
+    public const REMOVE_NOPLOTWORLD = "remove.noPlotWorld";
+    public const REMOVE_NOPLOT = "remove.noPlot";
+    public const REMOVE_NOPLOTOWNER = "remove.noPlotOwner";
+    public const REMOVE_NOTPLOTOWNER = "remove.notPlotOwner";
+    public const REMOVE_PLAYERNOTHELPER = "remove.playerNotHelper";
+    public const REMOVE_PLOTLOCKED = "remove.plotLocked";
+    public const REMOVE_SAVEERROR = "remove.saveError";
+    public const REMOVE_SUCCESS = "remove.success";
+    public const REMOVE_SUCCESS_PLAYER = "remove.success.player";
+    public const RESET_NAME = "reset.name";
+    public const RESET_ALIAS = "reset.alias";
+    public const RESET_DESCRIPTION = "reset.description";
+    public const RESET_USAGE = "reset.usage";
+    public const RESET_PERMISSIONMESSAGE = "reset.permissionMessage";
+    public const RESET_SENDERNOTONLINE = "reset.senderNotOnline";
+    public const RESET_NOPLOTWORLD = "reset.noPlotWorld";
+    public const RESET_NOPLOT = "reset.noPlot";
+    public const RESET_NOPLOTOWNER = "reset.noPlotOwner";
+    public const RESET_NOTPLOTOWNER = "reset.notPlotOwner";
+    public const RESET_PLOTLOCKED = "reset.plotLocked";
+    public const RESET_CHARGEMONEYERROR = "reset.chargeMoneyError";
+    public const RESET_CHARGEDMONEY = "reset.chargedMoney";
+    public const RESET_START = "reset.start";
+    public const RESET_FINISH = "reset.finish";
+    public const SCHEMATIC_NAME = "schematic.name";
+    public const SCHEMATIC_ALIAS = "schematic.alias";
+    public const SCHEMATIC_DESCRIPTION = "schematic.description";
+    public const SCHEMATIC_USAGE = "schematic.usage";
+    public const SCHEMATIC_PERMISSIONMESSAGE = "schematic.permissionMessage";
+    public const SCHEMATIC_LIST_NOSCHEMATICS = "schematic.list.noSchematics";
+    public const SCHEMATIC_LIST_SUCCESS = "schematic.list.success";
+    public const SCHEMATIC_INFO_USAGE = "schematic.info.usage";
+    public const SCHEMATIC_INFO_SCHEMATICNOTFOUND = "schematic.info.schematicNotFound";
+    public const SCHEMATIC_INFO_LOADERROR = "schematic.info.loadError";
+    public const SCHEMATIC_INFO_SUCCESS = "schematic.info.success";
+    public const SCHEMATIC_SAVE_USAGE = "schematic.save.usage";
+    public const SCHEMATIC_SAVE_SENDERNOTONLINE = "schematic.save.senderNotOnline";
+    public const SCHEMATIC_SAVE_DIRECTORYNOTFOUND = "schematic.save.directoryNotFound";
+    public const SCHEMATIC_SAVE_SCHEMATICEXISTS = "schematic.save.schematicExists";
+    public const SCHEMATIC_SAVE_INVALIDTYPE = "schematic.save.invalidType";
+    public const SCHEMATIC_SAVE_START = "schematic.save.start";
+    public const SCHEMATIC_SAVE_FINISH = "schematic.save.finish";
+    public const SCHEMATIC_GENERATE_USAGE = "schematic.generate.usage";
+    public const SCHEMATIC_GENERATE_WORLDEXISTS = "schematic.generate.worldExists";
+    public const SCHEMATIC_GENERATE_DIRECTORYNOTFOUND = "schematic.generate.directoryNotFound";
+    public const SCHEMATIC_GENERATE_SCHEMATICNOTFOUND = "schematic.generate.schematicNotFound";
+    public const SCHEMATIC_GENERATE_LOADERROR = "schematic.generate.loadError";
+    public const SCHEMATIC_GENERATE_GENERATEERROR = "schematic.generate.generateError";
+    public const SCHEMATIC_GENERATE_SUCCESS = "schematic.generate.success";
+    public const SETTING_NAME = "setting.name";
+    public const SETTING_ALIAS = "setting.alias";
+    public const SETTING_DESCRIPTION = "setting.description";
+    public const SETTING_USAGE = "setting.usage";
+    public const SETTING_PERMISSIONMESSAGE = "setting.permissionMessage";
+    public const SETTING_LIST_SUCCESS = "setting.list.success";
+    public const SETTING_INFO_USAGE = "setting.info.usage";
+    public const SETTING_INFO_SETTINGNOTFOUND = "setting.info.settingNotFound";
+    public const SETTING_INFO_SUCCESS = "setting.info.success";
+    public const SETTING_MY_SENDERNOTONLINE = "setting.my.senderNotOnline";
+    public const SETTING_MY_LOADERROR = "setting.my.loadError";
+    public const SETTING_MY_NOSETTINGS = "setting.my.noSettings";
+    public const SETTING_MY_SUCCESS = "setting.my.success";
+    public const SETTING_SET_USAGE = "setting.set.usage";
+    public const SETTING_SET_SENDERNOTONLINE = "setting.set.senderNotOnline";
+    public const SETTING_SET_LOADERROR = "setting.set.loadError";
+    public const SETTING_SET_SETTINGNOTFOUND = "setting.set.settingNotFound";
+    public const SETTING_SET_PERMISSIONMESSAGEFORSETTING = "setting.set.permissionMessageForSetting";
+    public const SETTING_SET_PARSEERROR = "setting.set.parseError";
+    public const SETTING_SET_SUCCESS = "setting.set.success";
+    public const SETTING_REMOVE_USAGE = "setting.remove.usage";
+    public const SETTING_REMOVE_SENDERNOTONLINE = "setting.remove.senderNotOnline";
+    public const SETTING_REMOVE_LOADERROR = "setting.remove.loadError";
+    public const SETTING_REMOVE_SETTINGNOTSET = "setting.remove.settingNotSet";
+    public const SETTING_REMOVE_PERMISSIONMESSAGEFORSETTING = "setting.remove.permissionMessageForSetting";
+    public const SETTING_REMOVE_PARSEERROR = "setting.remove.parseError";
+    public const SETTING_REMOVE_SUCCESS_VALUE = "setting.remove.success.value";
+    public const SETTING_REMOVE_SUCCESS_SETTING = "setting.remove.success.setting";
+    public const SPAWN_NAME = "spawn.name";
+    public const SPAWN_ALIAS = "spawn.alias";
+    public const SPAWN_DESCRIPTION = "spawn.description";
+    public const SPAWN_USAGE = "spawn.usage";
+    public const SPAWN_PERMISSIONMESSAGE = "spawn.permissionMessage";
+    public const SPAWN_SENDERNOTONLINE = "spawn.senderNotOnline";
+    public const SPAWN_NOPLOTWORLD = "spawn.noPlotWorld";
+    public const SPAWN_NOPLOT = "spawn.noPlot";
+    public const SPAWN_NOPLOTOWNER = "spawn.noPlotOwner";
+    public const SPAWN_NOTPLOTOWNER = "spawn.notPlotOwner";
+    public const SPAWN_SUCCESS = "spawn.success";
+    public const TRUSTED_NAME = "trusted.name";
+    public const TRUSTED_ALIAS = "trusted.alias";
+    public const TRUSTED_DESCRIPTION = "trusted.description";
+    public const TRUSTED_USAGE = "trusted.usage";
+    public const TRUSTED_PERMISSIONMESSAGE = "trusted.permissionMessage";
+    public const TRUSTED_SENDERNOTONLINE = "trusted.senderNotOnline";
+    public const TRUSTED_NOPLOTWORLD = "trusted.noPlotWorld";
+    public const TRUSTED_NOPLOT = "trusted.noPlot";
+    public const TRUSTED_NOTRUSTEDPLAYERS = "trusted.noTrustedPlayers";
+    public const TRUSTED_SUCCESS = "trusted.success";
+    public const TRUST_NAME = "trust.name";
+    public const TRUST_ALIAS = "trust.alias";
+    public const TRUST_DESCRIPTION = "trust.description";
+    public const TRUST_USAGE = "trust.usage";
+    public const TRUST_PERMISSIONMESSAGE = "trust.permissionMessage";
+    public const TRUST_SENDERNOTONLINE = "trust.senderNotOnline";
+    public const TRUST_PLAYERNOTFOUND = "trust.playerNotFound";
+    public const TRUST_SENDERISPLAYER = "trust.senderIsPlayer";
+    public const TRUST_NOPLOTWORLD = "trust.noPlotWorld";
+    public const TRUST_NOPLOT = "trust.noPlot";
+    public const TRUST_NOPLOTOWNER = "trust.noPlotOwner";
+    public const TRUST_NOTPLOTOWNER = "trust.notPlotOwner";
+    public const TRUST_PLAYERALREADYTRUSTED = "trust.playerAlreadyTrusted";
+    public const TRUST_PLOTLOCKED = "trust.plotLocked";
+    public const TRUST_SAVEERROR = "trust.saveError";
+    public const TRUST_SUCCESS = "trust.success";
+    public const TRUST_SUCCESS_PLAYER = "trust.success.player";
+    public const UNDENY_NAME = "undeny.name";
+    public const UNDENY_ALIAS = "undeny.alias";
+    public const UNDENY_DESCRIPTION = "undeny.description";
+    public const UNDENY_USAGE = "undeny.usage";
+    public const UNDENY_PERMISSIONMESSAGE = "undeny.permissionMessage";
+    public const UNDENY_SENDERNOTONLINE = "undeny.senderNotOnline";
+    public const UNDENY_PLAYERNOTFOUND = "undeny.playerNotFound";
+    public const UNDENY_NOPLOTWORLD = "undeny.noPlotWorld";
+    public const UNDENY_NOPLOT = "undeny.noPlot";
+    public const UNDENY_NOPLOTOWNER = "undeny.noPlotOwner";
+    public const UNDENY_NOTPLOTOWNER = "undeny.notPlotOwner";
+    public const UNDENY_PLAYERNOTDENIED = "undeny.playerNotDenied";
+    public const UNDENY_PLOTLOCKED = "undeny.plotLocked";
+    public const UNDENY_SAVEERROR = "undeny.saveError";
+    public const UNDENY_SUCCESS = "undeny.success";
+    public const UNDENY_SUCCESS_PLAYER = "undeny.success.player";
+    public const UNTRUST_NAME = "untrust.name";
+    public const UNTRUST_ALIAS = "untrust.alias";
+    public const UNTRUST_DESCRIPTION = "untrust.description";
+    public const UNTRUST_USAGE = "untrust.usage";
+    public const UNTRUST_PERMISSIONMESSAGE = "untrust.permissionMessage";
+    public const UNTRUST_SENDERNOTONLINE = "untrust.senderNotOnline";
+    public const UNTRUST_PLAYERNOTFOUND = "untrust.playerNotFound";
+    public const UNTRUST_NOPLOTWORLD = "untrust.noPlotWorld";
+    public const UNTRUST_NOPLOT = "untrust.noPlot";
+    public const UNTRUST_NOPLOTOWNER = "untrust.noPlotOwner";
+    public const UNTRUST_NOTPLOTOWNER = "untrust.notPlotOwner";
+    public const UNTRUST_PLAYERNOTTRUSTED = "untrust.playerNotTrusted";
+    public const UNTRUST_PLOTLOCKED = "untrust.plotLocked";
+    public const UNTRUST_SAVEERROR = "untrust.saveError";
+    public const UNTRUST_SUCCESS = "untrust.success";
+    public const UNTRUST_SUCCESS_PLAYER = "untrust.success.player";
+    public const VISIT_NAME = "visit.name";
+    public const VISIT_ALIAS = "visit.alias";
+    public const VISIT_DESCRIPTION = "visit.description";
+    public const VISIT_USAGE = "visit.usage";
+    public const VISIT_PERMISSIONMESSAGE = "visit.permissionMessage";
+    public const VISIT_SENDERNOTONLINE = "visit.senderNotOnline";
+    public const VISIT_LOADPLOTSERROR = "visit.loadPlotsError";
+    public const VISIT_SELF_NOPLOTS = "visit.self.noPlots";
+    public const VISIT_SELF_NOPLOT = "visit.self.noPlot";
+    public const VISIT_SELF_TELEPORTERROR = "visit.self.teleportError";
+    public const VISIT_SELF_SUCCESS = "visit.self.success";
+    public const VISIT_OTHER_PLAYERNOTFOUND = "visit.other.playerNotFound";
+    public const VISIT_OTHER_NOPLOTS = "visit.other.noPlots";
+    public const VISIT_OTHER_NOPLOT = "visit.other.noPlot";
+    public const VISIT_OTHER_TELEPORTERROR = "visit.other.teleportError";
+    public const VISIT_OTHER_SUCCESS = "visit.other.success";
+    public const VISIT_ALIAS_NOPLOT = "visit.alias.noPlot";
+    public const VISIT_ALIAS_TELEPORTERROR = "visit.alias.teleportError";
+    public const VISIT_ALIAS_SUCCESS = "visit.alias.success";
+    public const WALL_NAME = "wall.name";
+    public const WALL_ALIAS = "wall.alias";
+    public const WALL_DESCRIPTION = "wall.description";
+    public const WALL_USAGE = "wall.usage";
+    public const WALL_PERMISSIONMESSAGE = "wall.permissionMessage";
+    public const WALL_SENDERNOTONLINE = "wall.senderNotOnline";
+    public const WALL_INVALIDBLOCK = "wall.invalidBlock";
+    public const WALL_NOPLOTWORLD = "wall.noPlotWorld";
+    public const WALL_NOPLOT = "wall.noPlot";
+    public const WALL_NOPLOTOWNER = "wall.noPlotOwner";
+    public const WALL_NOTPLOTOWNER = "wall.notPlotOwner";
+    public const WALL_PLOTLOCKED = "wall.plotLocked";
+    public const WALL_START = "wall.start";
+    public const WALL_FINISH = "wall.finish";
+    public const WARP_NAME = "warp.name";
+    public const WARP_ALIAS = "warp.alias";
+    public const WARP_DESCRIPTION = "warp.description";
+    public const WARP_USAGE = "warp.usage";
+    public const WARP_PERMISSIONMESSAGE = "warp.permissionMessage";
+    public const WARP_SENDERNOTONLINE = "warp.senderNotOnline";
+    public const WARP_INVALIDPLOTWORLD = "warp.invalidPlotWorld";
+    public const WARP_INVALIDXCOORDINATE = "warp.invalidXCoordinate";
+    public const WARP_INVALIDZCOORDINATE = "warp.invalidZCoordinate";
+    public const WARP_LOADPLOTERROR = "warp.loadPlotError";
+    public const WARP_NOPLOTOWNER = "warp.noPlotOwner";
+    public const WARP_TELEPORTERROR = "warp.teleportError";
+    public const WARP_SUCCESS = "warp.success";
+}
\ No newline at end of file

From b50d63cdff49049d0c8a234c9e795d66a6df7249 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Fri, 7 Jul 2023 01:24:20 +0200
Subject: [PATCH 2/8] DataProvider: updatePlayerData() now returns the final
 PlayerData instance

---
 .../CPlot/listener/PlayerLoginListener.php    | 16 +++++++++-
 src/ColinHDev/CPlot/provider/DataProvider.php | 32 ++++++++-----------
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
index 76acd70..9c0fe24 100644
--- a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
+++ b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
@@ -4,6 +4,7 @@
 
 namespace ColinHDev\CPlot\listener;
 
+use ColinHDev\CPlot\player\PlayerData;
 use ColinHDev\CPlot\provider\DataProvider;
 use ColinHDev\CPlot\provider\LanguageManager;
 use pocketmine\event\Listener;
@@ -23,7 +24,20 @@ public function onPlayerLogin(PlayerLoginEvent $event) : void {
                 $player->getXuid(),
                 $player->getName()
             ),
-            null,
+            static function(?PlayerData $playerData) use ($player) : void {
+                if (!$player->isConnected()) {
+                    return;
+                }
+                if ($playerData === null) {
+                    $player->kick(
+                        LanguageManager::getInstance()->getProvider()->translateForCommandSender(
+                            $player,
+                            ["prefix", "playerLogin.savePlayerDataError"]
+                        )
+                    );
+                    return;
+                }
+            },
             static function() use ($player) : void {
                 if (!$player->isConnected()) {
                     return;
diff --git a/src/ColinHDev/CPlot/provider/DataProvider.php b/src/ColinHDev/CPlot/provider/DataProvider.php
index ec54b6b..637affb 100644
--- a/src/ColinHDev/CPlot/provider/DataProvider.php
+++ b/src/ColinHDev/CPlot/provider/DataProvider.php
@@ -492,40 +492,39 @@ private function awaitPlayerSettings(int $playerID) : Generator {
     }
 
     /**
-     * @phpstan-return Generator<mixed, mixed, mixed, void>
+     * @phpstan-return Generator<mixed, mixed, mixed, PlayerData|null>
      */
     public function updatePlayerData(?string $playerUUID, ?string $playerXUID, ?string $playerName) : Generator {
         $playerUUID = ($playerUUID === "" ? null : $playerUUID);
         $playerXUID = ($playerXUID === "" ? null : $playerXUID);
         $playerName = ($playerName === "" ? null : $playerName);
-        $playerData = yield $this->awaitPlayerDataByData($playerUUID, $playerXUID, $playerName);
+        $lastJoin = time();
+        $playerData = yield from $this->awaitPlayerDataByData($playerUUID, $playerXUID, $playerName);
         if (!($playerData instanceof PlayerData)) {
-            yield $this->database->asyncInsert(
+            yield from $this->database->asyncInsert(
                 self::SET_NEW_PLAYERDATA,
                 [
                     "playerUUID" => $playerUUID,
                     "playerXUID" => $playerXUID,
                     "playerName" => $playerName,
-                    "lastJoin" => date("d.m.Y H:i:s")
+                    "lastJoin" => date("d.m.Y H:i:s", $lastJoin)
                 ]
             );
-            return;
+            return yield from $this->awaitPlayerDataByData($playerUUID, $playerXUID, $playerName);
         }
         $playerID = $playerData->getPlayerID();
-        yield $this->database->asyncInsert(
+        yield from $this->database->asyncInsert(
             self::SET_PLAYERDATA,
             [
                 "playerID" => $playerID,
                 "playerUUID" => $playerUUID,
                 "playerXUID" => $playerXUID,
                 "playerName" => $playerName,
-                "lastJoin" => date("d.m.Y H:i:s")
+                "lastJoin" => date("d.m.Y H:i:s", $lastJoin)
             ]
         );
-        $this->caches[CacheIDs::CACHE_PLAYER]->cacheObject(
-            $playerID,
-            new PlayerData($playerID, $playerUUID, $playerXUID, $playerName, time(), $playerData->getSettings())
-        );
+        $updatedPlayerData = new PlayerData($playerID, $playerUUID, $playerXUID, $playerName, $lastJoin, $playerData->getSettings());
+        $this->caches[CacheIDs::CACHE_PLAYER]->cacheObject($playerID, $updatedPlayerData);
         if (is_string($playerUUID)) {
             $this->caches[CacheIDs::CACHE_PLAYER_UUID]->cacheObject($playerUUID, $playerID);
         }
@@ -535,6 +534,7 @@ public function updatePlayerData(?string $playerUUID, ?string $playerXUID, ?stri
         if (is_string($playerName)) {
             $this->caches[CacheIDs::CACHE_PLAYER_NAME]->cacheObject($playerName, $playerID);
         }
+        return $updatedPlayerData;
     }
 
     /**
@@ -1533,15 +1533,9 @@ private function createPlayerDataEntry(string $playerName) : Generator {
         }
 
         // register filler player data
-        yield from $this->updatePlayerData(
-            null, // doesn't matter what is input at this point. will overwrite on login
-            $XUID,
-            $playerName
-        );
-        // queriying now that player data updated
         /** @var PlayerData|null $playerData */
-        $playerData = yield from $this->awaitPlayerDataByData(
-            null,
+        $playerData = yield from $this->updatePlayerData(
+            null, // doesn't matter what is input at this point. will overwrite on login
             $XUID,
             $playerName
         );

From e0bfce7c88a41241cbf1e9bad3b0a1e6d6e98ff8 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Mon, 10 Jul 2023 00:51:15 +0200
Subject: [PATCH 3/8] language manager changes

---
 src/ColinHDev/CPlot/commands/PlotCommand.php  |   2 +-
 src/ColinHDev/CPlot/commands/Subcommand.php   |   2 +-
 .../CPlot/language/LanguageManager.php        |  63 ++++++++++
 .../CPlot/listener/PlayerLoginListener.php    |   2 +-
 .../CPlot/listener/PlayerMoveListener.php     |   9 +-
 .../CPlot/provider/CPlotLanguageProvider.php  | 117 ------------------
 .../CPlot/provider/LanguageManager.php        |  33 -----
 .../CPlot/provider/LanguageProvider.php       |  41 ------
 8 files changed, 71 insertions(+), 198 deletions(-)
 create mode 100644 src/ColinHDev/CPlot/language/LanguageManager.php
 delete mode 100644 src/ColinHDev/CPlot/provider/CPlotLanguageProvider.php
 delete mode 100644 src/ColinHDev/CPlot/provider/LanguageManager.php
 delete mode 100644 src/ColinHDev/CPlot/provider/LanguageProvider.php

diff --git a/src/ColinHDev/CPlot/commands/PlotCommand.php b/src/ColinHDev/CPlot/commands/PlotCommand.php
index 52d70ed..4514f20 100644
--- a/src/ColinHDev/CPlot/commands/PlotCommand.php
+++ b/src/ColinHDev/CPlot/commands/PlotCommand.php
@@ -33,7 +33,7 @@
 use ColinHDev\CPlot\commands\subcommands\WallSubcommand;
 use ColinHDev\CPlot\commands\subcommands\WarpSubcommand;
 use ColinHDev\CPlot\CPlot;
-use ColinHDev\CPlot\provider\LanguageManager;
+use ColinHDev\CPlot\language\LanguageManager;
 use ColinHDev\CPlot\utils\ParseUtils;
 use InvalidArgumentException;
 use pocketmine\command\Command;
diff --git a/src/ColinHDev/CPlot/commands/Subcommand.php b/src/ColinHDev/CPlot/commands/Subcommand.php
index 40f50c1..466d3b7 100644
--- a/src/ColinHDev/CPlot/commands/Subcommand.php
+++ b/src/ColinHDev/CPlot/commands/Subcommand.php
@@ -4,7 +4,7 @@
 
 namespace ColinHDev\CPlot\commands;
 
-use ColinHDev\CPlot\provider\LanguageManager;
+use ColinHDev\CPlot\language\LanguageManager;
 use ColinHDev\CPlot\provider\LanguageProvider;
 use ColinHDev\CPlot\utils\APIHolder;
 use ColinHDev\CPlot\utils\ParseUtils;
diff --git a/src/ColinHDev/CPlot/language/LanguageManager.php b/src/ColinHDev/CPlot/language/LanguageManager.php
new file mode 100644
index 0000000..229be8b
--- /dev/null
+++ b/src/ColinHDev/CPlot/language/LanguageManager.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\language;
+
+use ColinHDev\CPlot\CPlot;
+use ColinHDev\CPlot\ResourceManager;
+use pocketmine\lang\Language;
+use pocketmine\utils\SingletonTrait;
+use function pathinfo;
+use function scandir;
+use function strtolower;
+
+/**
+ * @phpstan-type LanguageIdentifier string
+ */
+final class LanguageManager {
+    use SingletonTrait;
+
+    /** @phpstan-var LanguageIdentifier */
+    private string $fallbackLanguage;
+    /** @phpstan-var array<LanguageIdentifier, Language> */
+    private array $languages;
+
+    public function __construct() {
+        /** @phpstan-var array{fallback: LanguageIdentifier, aliases: array<LanguageIdentifier, LanguageIdentifier>} $languageSettings */
+        $languageSettings = ResourceManager::getInstance()->getConfig()->get("language", []);
+        $this->fallbackLanguage = strtolower($languageSettings["fallback"]);
+        $languageAliases = $languageSettings["aliases"];
+
+        $dir = scandir(CPlot::getInstance()->getDataFolder() . "language");
+        if ($dir !== false) {
+            foreach ($dir as $file) {
+                /** @phpstan-var array{dirname: string, basename: string, extension?: string, filename: string} $fileData */
+                $fileData = pathinfo($file);
+                if (!isset($fileData["extension"]) || $fileData["extension"] !== "ini") {
+                    continue;
+                }
+                $languageName = strtolower($fileData["filename"]);
+                $language = new Language(
+                    $languageName,
+                    CPlot::getInstance()->getDataFolder() . "language",
+                    $this->fallbackLanguage
+                );
+                $this->languages[$languageName] = $language;
+                foreach ($languageAliases as $languageAlias => $alias) {
+                    if (strtolower($alias) === $languageName) {
+                        $this->languages[strtolower($languageAlias)] = $language;
+                        unset($languageAliases[$languageAlias]);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the language for the given identifier. If the language does not exist, the fallback language is returned.
+     */
+    public function getLanguage(string $language) : Language {
+        return $this->languages[$language] ?? $this->languages[$this->fallbackLanguage];
+    }
+}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
index 9c0fe24..16e711f 100644
--- a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
+++ b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
@@ -4,9 +4,9 @@
 
 namespace ColinHDev\CPlot\listener;
 
+use ColinHDev\CPlot\language\LanguageManager;
 use ColinHDev\CPlot\player\PlayerData;
 use ColinHDev\CPlot\provider\DataProvider;
-use ColinHDev\CPlot\provider\LanguageManager;
 use pocketmine\event\Listener;
 use pocketmine\event\player\PlayerLoginEvent;
 use SOFe\AwaitGenerator\Await;
diff --git a/src/ColinHDev/CPlot/listener/PlayerMoveListener.php b/src/ColinHDev/CPlot/listener/PlayerMoveListener.php
index 4ffa813..d938881 100644
--- a/src/ColinHDev/CPlot/listener/PlayerMoveListener.php
+++ b/src/ColinHDev/CPlot/listener/PlayerMoveListener.php
@@ -9,6 +9,7 @@
 use ColinHDev\CPlot\event\PlayerEnterPlotEvent;
 use ColinHDev\CPlot\event\PlayerLeavePlotEvent;
 use ColinHDev\CPlot\event\PlayerLeftPlotEvent;
+use ColinHDev\CPlot\language\LanguageManager;
 use ColinHDev\CPlot\player\PlayerData;
 use ColinHDev\CPlot\player\settings\Settings;
 use ColinHDev\CPlot\plots\flags\Flags;
@@ -17,8 +18,8 @@
 use ColinHDev\CPlot\plots\Plot;
 use ColinHDev\CPlot\plots\TeleportDestination;
 use ColinHDev\CPlot\provider\DataProvider;
-use ColinHDev\CPlot\provider\LanguageManager;
 use ColinHDev\CPlot\utils\APIHolder;
+use Generator;
 use pocketmine\event\Listener;
 use pocketmine\event\player\PlayerMoveEvent;
 use pocketmine\player\Player;
@@ -85,9 +86,9 @@ public function onPlayerMove(PlayerMoveEvent $event) : void {
      * could not be synchronously loaded.
      * So we call this method to at least process the player's movement, although we no longer can cancel the
      * {@see PlayerMoveEvent} itself.
-     * @phpstan-return \Generator<mixed, mixed, mixed, void>
+     * @phpstan-return Generator<mixed, mixed, mixed, void>
      */
-    private function onPlayerAsyncMove(PlayerMoveEvent $event) : \Generator {
+    private function onPlayerAsyncMove(PlayerMoveEvent $event) : Generator {
         /** @var Plot|false $fromPlot */
         $fromPlot = yield from Await::promise(
             fn(Closure $resolve, Closure $reject) => $this->getAPI()->getOrLoadPlotAtPosition($event->getFrom())->onCompletion($resolve, $reject)
@@ -128,7 +129,7 @@ private function onPlayerAsyncMove(PlayerMoveEvent $event) : \Generator {
      * @param Player $player The player that entered the plot.
      */
     private function onPlotEnter(Plot $plot, Player $player) : void {
-        Await::f2c(static function() use($plot, $player) : \Generator {
+        Await::f2c(static function() use($plot, $player) : Generator {
             $languageProvider = LanguageManager::getInstance()->getProvider();
             // settings on plot enter
             $playerData = yield from DataProvider::getInstance()->awaitPlayerDataByPlayer($player);
diff --git a/src/ColinHDev/CPlot/provider/CPlotLanguageProvider.php b/src/ColinHDev/CPlot/provider/CPlotLanguageProvider.php
deleted file mode 100644
index 22226c1..0000000
--- a/src/ColinHDev/CPlot/provider/CPlotLanguageProvider.php
+++ /dev/null
@@ -1,117 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace ColinHDev\CPlot\provider;
-
-use ColinHDev\CPlot\CPlot;
-use ColinHDev\CPlot\ResourceManager;
-use pocketmine\command\CommandSender;
-use pocketmine\lang\Language;
-use pocketmine\player\Player;
-use function strtolower;
-
-/**
- * @phpstan-type LanguageIdentifier string
- * @phpstan-import-type MessageKey from LanguageProvider
- * @phpstan-import-type MessageParam from LanguageProvider
- */
-class CPlotLanguageProvider extends LanguageProvider {
-
-    /** @phpstan-var LanguageIdentifier */
-    private string $fallbackLanguage;
-    /** @phpstan-var array<LanguageIdentifier, Language> */
-    private array $languages;
-
-    public function __construct() {
-        /** @phpstan-var array{fallback: LanguageIdentifier, aliases: array<LanguageIdentifier, LanguageIdentifier>} $languageSettings */
-        $languageSettings = ResourceManager::getInstance()->getConfig()->get("language", []);
-        $this->fallbackLanguage = strtolower($languageSettings["fallback"]);
-        $languageAliases = $languageSettings["aliases"];
-
-        $dir = scandir(CPlot::getInstance()->getDataFolder() . "language");
-        if ($dir !== false) {
-            foreach ($dir as $file) {
-                /** @phpstan-var array{dirname: string, basename: string, extension?: string, filename: string} $fileData */
-                $fileData = pathinfo($file);
-                if (!isset($fileData["extension"]) || $fileData["extension"] !== "ini") {
-                    continue;
-                }
-                $languageName = strtolower($fileData["filename"]);
-                $language = new Language(
-                    $languageName,
-                    CPlot::getInstance()->getDataFolder() . "language",
-                    $this->fallbackLanguage
-                );
-                $this->languages[$languageName] = $language;
-                foreach ($languageAliases as $languageAlias => $alias) {
-                    if (strtolower($alias) === $languageName) {
-                        $this->languages[strtolower($languageAlias)] = $language;
-                        unset($languageAliases[$languageAlias]);
-                    }
-                }
-            }
-        }
-    }
-
-    public function translateString(array|string $keys) : string {
-        return $this->buildMessage($this->languages[$this->fallbackLanguage], $keys);
-    }
-
-    public function translateForCommandSender(CommandSender $sender, array|string $keys) : string {
-        return $this->buildMessage($this->getLanguage($sender), $keys);
-    }
-
-    public function sendMessage(CommandSender $sender, array|string $keys) : void {
-        if (!($sender instanceof Player)) {
-            $message = $this->translateString($keys);
-        } else {
-            if (!$sender->isOnline()) {
-                return;
-            }
-            $message = $this->buildMessage($this->getLanguage($sender), $keys);
-        }
-        $sender->sendMessage($message);
-    }
-
-    public function sendTip(Player $player, array|string $keys) : void {
-        if (!$player->isOnline()) {
-            return;
-        }
-        $player->sendTip(
-            $this->buildMessage($this->getLanguage($player), $keys)
-        );
-    }
-
-    private function getLanguage(CommandSender $sender) : Language {
-        if (!($sender instanceof Player)) {
-            $language = $this->languages[$this->fallbackLanguage];
-        } else {
-            $locale = strtolower($sender->getLocale());
-            $language = $this->languages[$locale] ?? $this->languages[$this->fallbackLanguage];
-        }
-        return $language;
-    }
-
-    /**
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    private function buildMessage(Language $language, array|string $keys) : string {
-        if (is_string($keys)) {
-            $keys = [$keys];
-        }
-        $message = "";
-        foreach ($keys as $key => $value) {
-            if (is_string($key)) {
-                if (!is_array($value)) {
-                    $value = [$value];
-                }
-                $message .= $language->translateString($key, $value);
-            } else {
-                /** @phpstan-var string $value */
-                $message .= $language->get($value);
-            }
-        }
-        return $message;
-    }
-}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/provider/LanguageManager.php b/src/ColinHDev/CPlot/provider/LanguageManager.php
deleted file mode 100644
index 8fd7b09..0000000
--- a/src/ColinHDev/CPlot/provider/LanguageManager.php
+++ /dev/null
@@ -1,33 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace ColinHDev\CPlot\provider;
-
-use pocketmine\utils\SingletonTrait;
-
-final class LanguageManager {
-    use SingletonTrait;
-
-    private LanguageProvider $provider;
-
-    public function __construct() {
-        $this->provider = new CPlotLanguageProvider();
-    }
-
-    /**
-     * Returns the {@see LanguageProvider} instance that is currently used for CPlot's language integration and
-     * can be used to interact with the specific language provider.
-     */
-    public function getProvider() : LanguageProvider {
-        return $this->provider;
-    }
-
-    /**
-     * Change the current {@see LanguageProvider} instance.
-     * This method can be used to make CPlot compatible with your own, (maybe closed-source) language manager.
-     */
-    public function setProvider(LanguageProvider $provider) : void {
-        $this->provider = $provider;
-    }
-}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/provider/LanguageProvider.php b/src/ColinHDev/CPlot/provider/LanguageProvider.php
deleted file mode 100644
index 5fe24a1..0000000
--- a/src/ColinHDev/CPlot/provider/LanguageProvider.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace ColinHDev\CPlot\provider;
-
-use pocketmine\command\CommandSender;
-use pocketmine\lang\Translatable;
-use pocketmine\player\Player;
-use SOFe\AwaitGenerator\Await;
-
-/**
- * @phpstan-type MessageKey string
- * @phpstan-type MessageParam float|int|string|Translatable
- */
-abstract class LanguageProvider {
-
-    /**
-     * This method is used to translate a message using the fallback language.
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    abstract public function translateString(array|string $keys) : string;
-
-    /**
-     * This method is used to translate a message for the given {@see CommandSender}.
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    abstract public function translateForCommandSender(CommandSender $sender, array|string $keys) : string;
-
-    /**
-     * This method is used to send a message to the given {@see CommandSender} (e.g. a player or the console).
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    abstract public function sendMessage(CommandSender $sender, array|string $keys) : void;
-
-    /**
-     * This method is used to send a tip to the given {@see Player}.
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    abstract public function sendTip(Player $player, array|string $keys) : void;
-}
\ No newline at end of file

From d2d033acc91e17c66b1363f08069877198fba7fb Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Mon, 10 Jul 2023 00:59:37 +0200
Subject: [PATCH 4/8] LanguageManager: Fixed some doc comments and added
 getDefaultLanguage() method

---
 .../CPlot/language/LanguageManager.php        | 20 ++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/ColinHDev/CPlot/language/LanguageManager.php b/src/ColinHDev/CPlot/language/LanguageManager.php
index 229be8b..1644f39 100644
--- a/src/ColinHDev/CPlot/language/LanguageManager.php
+++ b/src/ColinHDev/CPlot/language/LanguageManager.php
@@ -12,19 +12,15 @@
 use function scandir;
 use function strtolower;
 
-/**
- * @phpstan-type LanguageIdentifier string
- */
 final class LanguageManager {
     use SingletonTrait;
 
-    /** @phpstan-var LanguageIdentifier */
     private string $fallbackLanguage;
-    /** @phpstan-var array<LanguageIdentifier, Language> */
+    /** @var array<string, Language> */
     private array $languages;
 
     public function __construct() {
-        /** @phpstan-var array{fallback: LanguageIdentifier, aliases: array<LanguageIdentifier, LanguageIdentifier>} $languageSettings */
+        /** @phpstan-var array{fallback: string, aliases: array<string, string>} $languageSettings */
         $languageSettings = ResourceManager::getInstance()->getConfig()->get("language", []);
         $this->fallbackLanguage = strtolower($languageSettings["fallback"]);
         $languageAliases = $languageSettings["aliases"];
@@ -54,10 +50,20 @@ public function __construct() {
         }
     }
 
+    /**
+     * Returns the default language.
+     * @return Language The default language.
+     */
+    public function getDefaultLanguage() : Language {
+        return $this->languages[$this->fallbackLanguage];
+    }
+
     /**
      * Returns the language for the given identifier. If the language does not exist, the fallback language is returned.
+     * @param string $language The language identifier.
+     * @return Language The language matching the identifier or the default language.
      */
     public function getLanguage(string $language) : Language {
-        return $this->languages[$language] ?? $this->languages[$this->fallbackLanguage];
+        return $this->languages[$language] ?? $this->getDefaultLanguage();
     }
 }
\ No newline at end of file

From 1f37c9cdc376f0023671085bb4864fcf7d763935 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Mon, 10 Jul 2023 01:12:12 +0200
Subject: [PATCH 5/8] LanguageManager: Added getLanguageForCommandSender()
 method

---
 src/ColinHDev/CPlot/language/LanguageManager.php | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/ColinHDev/CPlot/language/LanguageManager.php b/src/ColinHDev/CPlot/language/LanguageManager.php
index 1644f39..7038941 100644
--- a/src/ColinHDev/CPlot/language/LanguageManager.php
+++ b/src/ColinHDev/CPlot/language/LanguageManager.php
@@ -6,7 +6,9 @@
 
 use ColinHDev\CPlot\CPlot;
 use ColinHDev\CPlot\ResourceManager;
+use pocketmine\command\CommandSender;
 use pocketmine\lang\Language;
+use pocketmine\player\Player;
 use pocketmine\utils\SingletonTrait;
 use function pathinfo;
 use function scandir;
@@ -66,4 +68,16 @@ public function getDefaultLanguage() : Language {
     public function getLanguage(string $language) : Language {
         return $this->languages[$language] ?? $this->getDefaultLanguage();
     }
+
+    /**
+     * Returns the language for the given command sender.
+     * @param CommandSender $sender The command sender.
+     * @return Language The language for the command sender.
+     */
+    public function getLanguageForCommandSender(CommandSender $sender) : Language {
+        if ($sender instanceof Player) {
+            return $this->getLanguage($sender->getLocale());
+        }
+        return $this->getDefaultLanguage();
+    }
 }
\ No newline at end of file

From bebab619c6a3f35bc699e489d5e6e4abe4c4e401 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Thu, 13 Jul 2023 22:14:41 +0200
Subject: [PATCH 6/8] introduced session classes

---
 .../CPlot/commands/CommandExecutor.php        | 45 +++++++++++++++++++
 .../CPlot/commands/CommandExecutorManager.php | 28 ++++++++++++
 .../CPlot/commands/PlayerSession.php          | 37 +++++++++++++++
 3 files changed, 110 insertions(+)
 create mode 100644 src/ColinHDev/CPlot/commands/CommandExecutor.php
 create mode 100644 src/ColinHDev/CPlot/commands/CommandExecutorManager.php
 create mode 100644 src/ColinHDev/CPlot/commands/PlayerSession.php

diff --git a/src/ColinHDev/CPlot/commands/CommandExecutor.php b/src/ColinHDev/CPlot/commands/CommandExecutor.php
new file mode 100644
index 0000000..065284a
--- /dev/null
+++ b/src/ColinHDev/CPlot/commands/CommandExecutor.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\commands;
+
+use ColinHDev\CPlot\language\LanguageManager;
+use pocketmine\command\CommandSender;
+use pocketmine\lang\Language;
+use pocketmine\lang\Translatable;
+
+class CommandExecutor {
+    
+    protected CommandSender $sender;
+    protected Language $language;
+    
+    public function __construct(CommandSender $sender) {
+        $this->sender = $sender;
+        $this->language = LanguageManager::getInstance()->getLanguageForCommandSender($sender);
+    }
+
+    public function getSender() : CommandSender {
+        return $this->sender;
+    }
+
+    public function getLanguage() : Language {
+        return $this->language;
+    }
+
+    public function sendMessage(Translatable|string ...$messages) : void {
+        $this->sender->sendMessage($this->translate(...$messages));
+    }
+
+    public function translate(Translatable|string ...$messages) : string {
+        $result = "";
+        foreach ($messages as $message) {
+            if ($message instanceof Translatable) {
+                $result .= $this->language->translate($message);
+            } else {
+                $result .= $message;
+            }
+        }
+        return $result;
+    }
+}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/commands/CommandExecutorManager.php b/src/ColinHDev/CPlot/commands/CommandExecutorManager.php
new file mode 100644
index 0000000..0460335
--- /dev/null
+++ b/src/ColinHDev/CPlot/commands/CommandExecutorManager.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\commands;
+
+use ColinHDev\CPlot\player\PlayerData;
+use pocketmine\player\Player;
+use pocketmine\utils\SingletonTrait;
+use WeakMap;
+
+final class CommandExecutorManager {
+    use SingletonTrait;
+
+    private WeakMap $playerSessions;
+
+    public function __construct() {
+        $this->playerSessions = new WeakMap();
+    }
+    
+    public function registerPlayerSession(Player $player, PlayerData $playerData) : void {
+        $this->playerSessions[$player] = new PlayerSession($player, $playerData);
+    }
+    
+    public function getPlayerSession(Player $player) : ?PlayerSession {
+        return $this->playerSessions[$player] ?? null;
+    }
+}
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/commands/PlayerSession.php b/src/ColinHDev/CPlot/commands/PlayerSession.php
new file mode 100644
index 0000000..b7275c0
--- /dev/null
+++ b/src/ColinHDev/CPlot/commands/PlayerSession.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ColinHDev\CPlot\commands;
+
+use ColinHDev\CPlot\player\PlayerData;
+use pocketmine\lang\Translatable;
+use pocketmine\player\Player;
+use function assert;
+
+class PlayerSession extends CommandExecutor {
+
+    protected PlayerData $playerData;
+
+    public function __construct(Player $player, PlayerData $playerData) {
+        parent::__construct($player);
+        $this->playerData = $playerData;
+    }
+
+    public function getSender() : Player {
+        assert($this->sender instanceof Player);
+        return $this->sender;
+    }
+
+    public function getPlayer() : Player {
+        return $this->getSender();
+    }
+    
+    public function getPlayerData() : PlayerData {
+        return $this->playerData;
+    }
+    
+    public function sendTip(Translatable|string ...$messages) : void {
+        $this->getPlayer()->sendTip($this->translate(...$messages));
+    }
+}
\ No newline at end of file

From 662060870f916b00d26211ed6a181292b4e5b198 Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Thu, 13 Jul 2023 22:15:12 +0200
Subject: [PATCH 7/8] introduced session classes v2

---
 .../CPlot/listener/PlayerLoginListener.php    | 29 +++++++++----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
index 16e711f..164ebad 100644
--- a/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
+++ b/src/ColinHDev/CPlot/listener/PlayerLoginListener.php
@@ -4,7 +4,9 @@
 
 namespace ColinHDev\CPlot\listener;
 
-use ColinHDev\CPlot\language\LanguageManager;
+use ColinHDev\CPlot\commands\CommandExecutor;
+use ColinHDev\CPlot\commands\CommandExecutorManager;
+use ColinHDev\CPlot\language\KnownTranslationFactory;
 use ColinHDev\CPlot\player\PlayerData;
 use ColinHDev\CPlot\provider\DataProvider;
 use pocketmine\event\Listener;
@@ -24,30 +26,27 @@ public function onPlayerLogin(PlayerLoginEvent $event) : void {
                 $player->getXuid(),
                 $player->getName()
             ),
-            static function(?PlayerData $playerData) use ($player) : void {
+            static function(?PlayerData $playerData) use($player) : void {
                 if (!$player->isConnected()) {
                     return;
                 }
                 if ($playerData === null) {
-                    $player->kick(
-                        LanguageManager::getInstance()->getProvider()->translateForCommandSender(
-                            $player,
-                            ["prefix", "playerLogin.savePlayerDataError"]
-                        )
-                    );
+                    $player->kick((new CommandExecutor($player))->translate(
+                        KnownTranslationFactory::prefix(),
+                        KnownTranslationFactory::playerLogin_savePlayerDataError()
+                    ));
                     return;
                 }
+                CommandExecutorManager::getInstance()->registerPlayerSession($player, $playerData);
             },
-            static function() use ($player) : void {
+            static function() use($player) : void {
                 if (!$player->isConnected()) {
                     return;
                 }
-                $player->kick(
-                    LanguageManager::getInstance()->getProvider()->translateForCommandSender(
-                        $player,
-                        ["prefix", "playerLogin.savePlayerDataError"]
-                    )
-                );
+                $player->kick((new CommandExecutor($player))->translate(
+                    KnownTranslationFactory::prefix(),
+                    KnownTranslationFactory::playerLogin_savePlayerDataError()
+                ));
             }
         );
     }

From 389b61a2d9e875242786e4e24e529cc1b6c2d26c Mon Sep 17 00:00:00 2001
From: ColinHDev <colinheidfeld@gmail.com>
Date: Wed, 19 Jul 2023 18:24:23 +0200
Subject: [PATCH 8/8] pushing changes

---
 .../CPlot/commands/AsyncSubcommand.php        |  6 ++---
 .../CPlot/commands/CommandExecutor.php        |  1 +
 src/ColinHDev/CPlot/commands/Subcommand.php   | 27 ++++---------------
 3 files changed, 9 insertions(+), 25 deletions(-)

diff --git a/src/ColinHDev/CPlot/commands/AsyncSubcommand.php b/src/ColinHDev/CPlot/commands/AsyncSubcommand.php
index b8c9811..5ad4273 100644
--- a/src/ColinHDev/CPlot/commands/AsyncSubcommand.php
+++ b/src/ColinHDev/CPlot/commands/AsyncSubcommand.php
@@ -3,13 +3,13 @@
 declare(strict_types=1);
 
 namespace ColinHDev\CPlot\commands;
+
 use Generator;
-use pocketmine\command\CommandSender;
 use SOFe\AwaitGenerator\Await;
 
 abstract class AsyncSubcommand extends Subcommand {
 
-    final public function execute(CommandSender $sender, array $args) : void {
+    final public function execute(CommandExecutor $sender, array $args) : void {
         Await::g2c(
             $this->executeAsync($sender, $args)
         );
@@ -21,5 +21,5 @@ final public function execute(CommandSender $sender, array $args) : void {
      * @param string[] $args
      * @phpstan-return Generator<mixed, mixed, mixed, mixed>
      */
-    abstract public function executeAsync(CommandSender $sender, array $args) : Generator;
+    abstract public function executeAsync(CommandExecutor $sender, array $args) : Generator;
 }
\ No newline at end of file
diff --git a/src/ColinHDev/CPlot/commands/CommandExecutor.php b/src/ColinHDev/CPlot/commands/CommandExecutor.php
index 065284a..513f3bc 100644
--- a/src/ColinHDev/CPlot/commands/CommandExecutor.php
+++ b/src/ColinHDev/CPlot/commands/CommandExecutor.php
@@ -37,6 +37,7 @@ public function translate(Translatable|string ...$messages) : string {
             if ($message instanceof Translatable) {
                 $result .= $this->language->translate($message);
             } else {
+                
                 $result .= $message;
             }
         }
diff --git a/src/ColinHDev/CPlot/commands/Subcommand.php b/src/ColinHDev/CPlot/commands/Subcommand.php
index 466d3b7..c8d7c15 100644
--- a/src/ColinHDev/CPlot/commands/Subcommand.php
+++ b/src/ColinHDev/CPlot/commands/Subcommand.php
@@ -4,11 +4,11 @@
 
 namespace ColinHDev\CPlot\commands;
 
+use ColinHDev\CPlot\language\KnownTranslationFactory;
 use ColinHDev\CPlot\language\LanguageManager;
 use ColinHDev\CPlot\provider\LanguageProvider;
 use ColinHDev\CPlot\utils\APIHolder;
 use ColinHDev\CPlot\utils\ParseUtils;
-use pocketmine\command\CommandSender;
 
 /**
  * @phpstan-import-type MessageKey from LanguageProvider
@@ -46,10 +46,11 @@ public function getPermission() : string {
         return $this->permission;
     }
 
-    public function testPermission(CommandSender $sender) : bool {
-        if ($sender->hasPermission($this->permission)) {
+    public function testPermission(CommandExecutor $sender) : bool {
+        if ($sender->getSender()->hasPermission($this->permission)) {
             return true;
         }
+        $sender->sendMessage(KnownTranslationFactory::prefix());
         self::sendMessage($sender, ["prefix", $this->key . ".permissionMessage"]);
         return false;
     }
@@ -58,23 +59,5 @@ public function testPermission(CommandSender $sender) : bool {
      * This method contains the code you want to be executed when the command is run.
      * @param string[] $args
      */
-    abstract public function execute(CommandSender $sender, array $args) : void;
-
-    /**
-     * Utility method to send a message to a command sender, while also removing some boilerplate code within the
-     * subcommand classes.
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    final protected static function sendMessage(CommandSender $sender, array|string $keys) : void {
-        LanguageManager::getInstance()->getProvider()->sendMessage($sender, $keys);
-    }
-
-    /**
-     * Utility method to translate a message for a command sender, while also removing some boilerplate code within the
-     * subcommand classes.
-     * @phpstan-param array<int|MessageKey, MessageKey|MessageParam|array<MessageParam>>|MessageKey $keys
-     */
-    final protected static function translateForCommandSender(CommandSender $sender, array|string $keys) : string {
-        return LanguageManager::getInstance()->getProvider()->translateForCommandSender($sender, $keys);
-    }
+    abstract public function execute(CommandExecutor $sender, array $args) : void;
 }
\ No newline at end of file