[3.3.5] ChatCommands, the other half: chat command resolution refactor (PR #25463)

(cherry picked from commit 1eca51b417678b9a48b28552925d5694105f82bb)

55 files changed, 1335 insertions, 1301 deletions

diff --git a/src/server/game/Accounts/BattlenetAccountMgr.cpp b/src/server/game/Accounts/BattlenetAccountMgr.cpp
index a726fdf5c7d..a204e99f337 100644
--- a/src/server/game/Accounts/BattlenetAccountMgr.cpp
+++ b/src/server/game/Accounts/BattlenetAccountMgr.cpp
@@ -90,7 +90,7 @@ bool Battlenet::AccountMgr::CheckPassword(uint32 accountId, std::string password
     return LoginDatabase.Query(stmt) != nullptr;
 }
 
-AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string const& email, std::string const& gameAccountName)
+AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string_view email, std::string_view gameAccountName)
 {
     uint32 bnetAccountId = GetId(email);
     if (!bnetAccountId)
@@ -111,7 +111,7 @@ AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string const& em
     return AccountOpResult::AOR_OK;
 }
 
-AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string const& gameAccountName)
+AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string_view gameAccountName)
 {
     uint32 gameAccountId = GameAccountMgr::GetId(gameAccountName);
     if (!gameAccountId)
@@ -128,10 +128,10 @@ AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string const& game
     return AccountOpResult::AOR_OK;
 }
 
-uint32 Battlenet::AccountMgr::GetId(std::string const& username)
+uint32 Battlenet::AccountMgr::GetId(std::string_view username)
 {
     LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_ACCOUNT_ID_BY_EMAIL);
-    stmt->setString(0, username);
+    stmt->setStringView(0, username);
     if (PreparedQueryResult result = LoginDatabase.Query(stmt))
         return (*result)[0].GetUInt32();
 
@@ -172,7 +172,7 @@ uint8 Battlenet::AccountMgr::GetMaxIndex(uint32 accountId)
     return 0;
 }
 
-std::string Battlenet::AccountMgr::CalculateShaPassHash(std::string const& name, std::string const& password)
+std::string Battlenet::AccountMgr::CalculateShaPassHash(std::string_view name, std::string_view password)
 {
     Trinity::Crypto::SHA256 email;
     email.UpdateData(name);
diff --git a/src/server/game/Accounts/BattlenetAccountMgr.h b/src/server/game/Accounts/BattlenetAccountMgr.h
index 8221896eb11..43c60c5b006 100644
--- a/src/server/game/Accounts/BattlenetAccountMgr.h
+++ b/src/server/game/Accounts/BattlenetAccountMgr.h
@@ -32,15 +32,15 @@ namespace Battlenet
         TC_GAME_API AccountOpResult CreateBattlenetAccount(std::string email, std::string password, bool withGameAccount, std::string* gameAccountName);
         TC_GAME_API AccountOpResult ChangePassword(uint32 accountId, std::string newPassword);
         TC_GAME_API bool CheckPassword(uint32 accountId, std::string password);
-        TC_GAME_API AccountOpResult LinkWithGameAccount(std::string const& email, std::string const& gameAccountName);
-        TC_GAME_API AccountOpResult UnlinkGameAccount(std::string const& gameAccountName);
+        TC_GAME_API AccountOpResult LinkWithGameAccount(std::string_view email, std::string_view gameAccountName);
+        TC_GAME_API AccountOpResult UnlinkGameAccount(std::string_view gameAccountName);
 
-        TC_GAME_API uint32 GetId(std::string const& username);
+        TC_GAME_API uint32 GetId(std::string_view username);
         TC_GAME_API bool GetName(uint32 accountId, std::string& name);
         TC_GAME_API uint32 GetIdByGameAccount(uint32 gameAccountId);
         TC_GAME_API uint8 GetMaxIndex(uint32 accountId);
 
-        TC_GAME_API std::string CalculateShaPassHash(std::string const& name, std::string const& password);
+        TC_GAME_API std::string CalculateShaPassHash(std::string_view name, std::string_view password);
     }
 }
 
diff --git a/src/server/game/Accounts/RBAC.h b/src/server/game/Accounts/RBAC.h
index 95f1df06e1b..408da2515dc 100644
--- a/src/server/game/Accounts/RBAC.h
+++ b/src/server/game/Accounts/RBAC.h
@@ -105,6 +105,12 @@ enum RBACPermissions
 
     // Free space for core permissions (till 149)
     // Roles (Permissions with delegated permissions) use 199 and descending
+
+    RBAC_ROLE_ADMINISTRATOR                                  = 196,
+    RBAC_ROLE_GAMEMASTER                                     = 197,
+    RBAC_ROLE_MODERATOR                                      = 198,
+    RBAC_ROLE_PLAYER                                         = 199,
+
     RBAC_PERM_COMMAND_RBAC                                   = 200,
     RBAC_PERM_COMMAND_RBAC_ACC                               = 201,
     RBAC_PERM_COMMAND_RBAC_ACC_PERM_LIST                     = 202,
@@ -117,7 +123,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY              = 209,
     RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP                   = 210,
     RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD                  = 211,
-    RBAC_PERM_COMMAND_BNET_ACCOUNT_SET                       = 212,
+    // 212 previously used, do not reuse
     RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD              = 213,
     RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK                      = 214,
     RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK                    = 215,
@@ -135,41 +141,41 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON                      = 227,
     RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL                   = 228,
     RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD                   = 229,
-    RBAC_PERM_COMMAND_ACHIEVEMENT                            = 230,
+    // 230 previously used, do not reuse
     RBAC_PERM_COMMAND_ACHIEVEMENT_ADD                        = 231,
-    RBAC_PERM_COMMAND_ARENA                                  = 232,
+    // 232 previously used, do not reuse
     RBAC_PERM_COMMAND_ARENA_CAPTAIN                          = 233,
     RBAC_PERM_COMMAND_ARENA_CREATE                           = 234,
     RBAC_PERM_COMMAND_ARENA_DISBAND                          = 235,
     RBAC_PERM_COMMAND_ARENA_INFO                             = 236,
     RBAC_PERM_COMMAND_ARENA_LOOKUP                           = 237,
     RBAC_PERM_COMMAND_ARENA_RENAME                           = 238,
-    RBAC_PERM_COMMAND_BAN                                    = 239,
+    // 239 previously used, do not reuse
     RBAC_PERM_COMMAND_BAN_ACCOUNT                            = 240,
     RBAC_PERM_COMMAND_BAN_CHARACTER                          = 241,
     RBAC_PERM_COMMAND_BAN_IP                                 = 242,
     RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT                      = 243,
-    RBAC_PERM_COMMAND_BANINFO                                = 244,
+    // 244 previously used, do not reuse
     RBAC_PERM_COMMAND_BANINFO_ACCOUNT                        = 245,
     RBAC_PERM_COMMAND_BANINFO_CHARACTER                      = 246,
     RBAC_PERM_COMMAND_BANINFO_IP                             = 247,
-    RBAC_PERM_COMMAND_BANLIST                                = 248,
+    // 248 previously used, do not reuse
     RBAC_PERM_COMMAND_BANLIST_ACCOUNT                        = 249,
     RBAC_PERM_COMMAND_BANLIST_CHARACTER                      = 250,
     RBAC_PERM_COMMAND_BANLIST_IP                             = 251,
-    RBAC_PERM_COMMAND_UNBAN                                  = 252,
+    // 252 previously used, do not reuse
     RBAC_PERM_COMMAND_UNBAN_ACCOUNT                          = 253,
     RBAC_PERM_COMMAND_UNBAN_CHARACTER                        = 254,
     RBAC_PERM_COMMAND_UNBAN_IP                               = 255,
     RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT                    = 256,
-    RBAC_PERM_COMMAND_BF                                     = 257,
+    // 257 previously used, do not reuse
     RBAC_PERM_COMMAND_BF_START                               = 258,
     RBAC_PERM_COMMAND_BF_STOP                                = 259,
     RBAC_PERM_COMMAND_BF_SWITCH                              = 260,
     RBAC_PERM_COMMAND_BF_TIMER                               = 261,
     RBAC_PERM_COMMAND_BF_ENABLE                              = 262,
     RBAC_PERM_COMMAND_ACCOUNT_EMAIL                          = 263,
-    RBAC_PERM_COMMAND_ACCOUNT_SET_SEC                        = 264,
+    // 264 previously used, do not reuse
     RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL                  = 265,
     RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL                = 266,
     RBAC_PERM_COMMAND_CAST                                   = 267,
@@ -178,11 +184,11 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_CAST_SELF                              = 270,
     RBAC_PERM_COMMAND_CAST_TARGET                            = 271,
     RBAC_PERM_COMMAND_CAST_DEST                              = 272,
-    RBAC_PERM_COMMAND_CHARACTER                              = 273,
+    // 273 previously used, do not reuse
     RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE                    = 274,
     RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION                = 275,
     RBAC_PERM_COMMAND_CHARACTER_CHANGERACE                   = 276,
-    RBAC_PERM_COMMAND_CHARACTER_DELETED                      = 277,
+    // 277 previously used, do not reuse
     RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE               = 278,
     RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST                 = 279,
     RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE              = 280,
@@ -193,10 +199,10 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_CHARACTER_REPUTATION                   = 285,
     RBAC_PERM_COMMAND_CHARACTER_TITLES                       = 286,
     RBAC_PERM_COMMAND_LEVELUP                                = 287,
-    RBAC_PERM_COMMAND_PDUMP                                  = 288,
+    // 288 previously used, do not reuse
     RBAC_PERM_COMMAND_PDUMP_LOAD                             = 289,
     RBAC_PERM_COMMAND_PDUMP_WRITE                            = 290,
-    RBAC_PERM_COMMAND_CHEAT                                  = 291,
+    // 291 previously used, do not reuse
     RBAC_PERM_COMMAND_CHEAT_CASTTIME                         = 292,
     RBAC_PERM_COMMAND_CHEAT_COOLDOWN                         = 293,
     RBAC_PERM_COMMAND_CHEAT_EXPLORE                          = 294,
@@ -206,55 +212,13 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_CHEAT_TAXI                             = 298,
     RBAC_PERM_COMMAND_CHEAT_WATERWALK                        = 299,
     RBAC_PERM_COMMAND_DEBUG                                  = 300,
-    RBAC_PERM_COMMAND_DEBUG_ANIM                             = 301,
-    RBAC_PERM_COMMAND_DEBUG_AREATRIGGERS                     = 302,
-    RBAC_PERM_COMMAND_DEBUG_ARENA                            = 303,
-    RBAC_PERM_COMMAND_DEBUG_BG                               = 304,
-    RBAC_PERM_COMMAND_DEBUG_ENTERVEHICLE                     = 305,
-    RBAC_PERM_COMMAND_DEBUG_GETITEMSTATE                     = 306,
-    RBAC_PERM_COMMAND_DEBUG_GETITEMVALUE                     = 307, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_GETVALUE                         = 308, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_COMBAT                           = 309,
-    RBAC_PERM_COMMAND_DEBUG_ITEMEXPIRE                       = 310,
-    RBAC_PERM_COMMAND_DEBUG_LOOTRECIPIENT                    = 311,
-    RBAC_PERM_COMMAND_DEBUG_LOS                              = 312,
-    RBAC_PERM_COMMAND_DEBUG_MOD32VALUE                       = 313, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_MOVEFLAGS                        = 314,
-    RBAC_PERM_COMMAND_DEBUG_PLAY                             = 315,
-    RBAC_PERM_COMMAND_DEBUG_PLAY_CINEMATIC                   = 316,
-    RBAC_PERM_COMMAND_DEBUG_PLAY_MOVIE                       = 317,
-    RBAC_PERM_COMMAND_DEBUG_PLAY_SOUND                       = 318,
-    RBAC_PERM_COMMAND_DEBUG_SEND                             = 319,
-    RBAC_PERM_COMMAND_DEBUG_SEND_BUYERROR                    = 320,
-    RBAC_PERM_COMMAND_DEBUG_SEND_CHANNELNOTIFY               = 321,
-    RBAC_PERM_COMMAND_DEBUG_SEND_CHATMESSAGE                 = 322,
-    RBAC_PERM_COMMAND_DEBUG_SEND_EQUIPERROR                  = 323,
-    RBAC_PERM_COMMAND_DEBUG_SEND_LARGEPACKET                 = 324,
-    RBAC_PERM_COMMAND_DEBUG_SEND_OPCODE                      = 325,
-    RBAC_PERM_COMMAND_DEBUG_SEND_QINVALIDMSG                 = 326,
-    RBAC_PERM_COMMAND_DEBUG_SEND_QPARTYMSG                   = 327,
-    RBAC_PERM_COMMAND_DEBUG_SEND_SELLERROR                   = 328,
-    RBAC_PERM_COMMAND_DEBUG_SEND_SETPHASESHIFT               = 329,
-    RBAC_PERM_COMMAND_DEBUG_SEND_SPELLFAIL                   = 330,
-    RBAC_PERM_COMMAND_DEBUG_SETAURASTATE                     = 331,
-    RBAC_PERM_COMMAND_DEBUG_SETBIT                           = 332, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_SETITEMVALUE                     = 333, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_SETVALUE                         = 334, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_SETVID                           = 335,
-    RBAC_PERM_COMMAND_DEBUG_SPAWNVEHICLE                     = 336,
-    RBAC_PERM_COMMAND_DEBUG_THREAT                           = 337,
-    RBAC_PERM_COMMAND_DEBUG_UPDATE                           = 338, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_WORLDSTATE                       = 339,
-    RBAC_PERM_COMMAND_WPGPS                                  = 340,
-    RBAC_PERM_COMMAND_DESERTER                               = 341,
-    RBAC_PERM_COMMAND_DESERTER_BG                            = 342,
+    // 301-342 previously used, do not reuse
     RBAC_PERM_COMMAND_DESERTER_BG_ADD                        = 343,
     RBAC_PERM_COMMAND_DESERTER_BG_REMOVE                     = 344,
-    RBAC_PERM_COMMAND_DESERTER_INSTANCE                      = 345,
+    // 345 previously used, do not reuse
     RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD                  = 346,
     RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE               = 347,
-    RBAC_PERM_COMMAND_DISABLE                                = 348,
-    RBAC_PERM_COMMAND_DISABLE_ADD                            = 349,
+    // 348-349 previously used, do not reuse
     RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA                   = 350,
     RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND               = 351,
     RBAC_PERM_COMMAND_DISABLE_ADD_MAP                        = 352,
@@ -263,7 +227,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_DISABLE_ADD_QUEST                      = 355,
     RBAC_PERM_COMMAND_DISABLE_ADD_SPELL                      = 356,
     RBAC_PERM_COMMAND_DISABLE_ADD_VMAP                       = 357,
-    RBAC_PERM_COMMAND_DISABLE_REMOVE                         = 358,
+    // 358 previously used, do not reuse
     RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA                = 359,
     RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND            = 360,
     RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP                     = 361,
@@ -272,7 +236,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST                   = 364,
     RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL                   = 365,
     RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP                    = 366,
-    RBAC_PERM_COMMAND_EVENT                                  = 367,
+    RBAC_PERM_COMMAND_EVENT_INFO                             = 367,
     RBAC_PERM_COMMAND_EVENT_ACTIVELIST                       = 368,
     RBAC_PERM_COMMAND_EVENT_START                            = 369,
     RBAC_PERM_COMMAND_EVENT_STOP                             = 370,
@@ -292,7 +256,7 @@ enum RBACPermissions
     //                                                       = 384, // DEPRECATED: DON'T REUSE
     //                                                       = 385, // DEPRECATED: DON'T REUSE
     //                                                       = 386, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_GOBJECT                                = 387,
+    // 387 previously used, do not reuse
     RBAC_PERM_COMMAND_GOBJECT_ACTIVATE                       = 388,
     RBAC_PERM_COMMAND_GOBJECT_ADD                            = 389,
     RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP                       = 390,
@@ -300,12 +264,12 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_GOBJECT_INFO                           = 392,
     RBAC_PERM_COMMAND_GOBJECT_MOVE                           = 393,
     RBAC_PERM_COMMAND_GOBJECT_NEAR                           = 394,
-    RBAC_PERM_COMMAND_GOBJECT_SET                            = 395,
+    // 395 previously used, do not reuse
     RBAC_PERM_COMMAND_GOBJECT_SET_PHASE                      = 396,
     RBAC_PERM_COMMAND_GOBJECT_SET_STATE                      = 397,
     RBAC_PERM_COMMAND_GOBJECT_TARGET                         = 398,
     RBAC_PERM_COMMAND_GOBJECT_TURN                           = 399,
-    RBAC_PERM_COMMAND_DEBUG_TRANSPORT                        = 400,
+    // 400 previously used, do not reuse
     RBAC_PERM_COMMAND_GUILD                                  = 401,
     RBAC_PERM_COMMAND_GUILD_CREATE                           = 402,
     RBAC_PERM_COMMAND_GUILD_DELETE                           = 403,
@@ -323,7 +287,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_INSTANCE_STATS                         = 415,
     RBAC_PERM_COMMAND_INSTANCE_SAVEDATA                      = 416,
     RBAC_PERM_COMMAND_LEARN                                  = 417,
-    RBAC_PERM_COMMAND_LEARN_ALL                              = 418,
+    // 418 previously used, do not reuse
     RBAC_PERM_COMMAND_LEARN_ALL_MY                           = 419,
     RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS                     = 420,
     RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS                = 421,
@@ -335,13 +299,13 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_LEARN_ALL_LANG                         = 427,
     RBAC_PERM_COMMAND_LEARN_ALL_RECIPES                      = 428,
     RBAC_PERM_COMMAND_UNLEARN                                = 429,
-    RBAC_PERM_COMMAND_LFG                                    = 430,
+    // 430 previously used, do not reuse
     RBAC_PERM_COMMAND_LFG_PLAYER                             = 431,
     RBAC_PERM_COMMAND_LFG_GROUP                              = 432,
     RBAC_PERM_COMMAND_LFG_QUEUE                              = 433,
     RBAC_PERM_COMMAND_LFG_CLEAN                              = 434,
     RBAC_PERM_COMMAND_LFG_OPTIONS                            = 435,
-    RBAC_PERM_COMMAND_LIST                                   = 436,
+    // 436 previously used, do not reuse
     RBAC_PERM_COMMAND_LIST_CREATURE                          = 437,
     RBAC_PERM_COMMAND_LIST_ITEM                              = 438,
     RBAC_PERM_COMMAND_LIST_OBJECT                            = 439,
@@ -475,7 +439,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_MODIFY_SPELL                           = 567,
     RBAC_PERM_COMMAND_MODIFY_STANDSTATE                      = 568,
     RBAC_PERM_COMMAND_MODIFY_TALENTPOINTS                    = 569,
-    RBAC_PERM_COMMAND_NPC                                    = 570,
+    // 570 previously used, do not reuse
     RBAC_PERM_COMMAND_NPC_ADD                                = 571,
     RBAC_PERM_COMMAND_NPC_ADD_FORMATION                      = 572,
     RBAC_PERM_COMMAND_NPC_ADD_ITEM                           = 573,
@@ -610,7 +574,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_RELOAD_SPELL_THREATS                   = 702,
     RBAC_PERM_COMMAND_RELOAD_SPELL_GROUP_STACK_RULES         = 703,
     RBAC_PERM_COMMAND_RELOAD_TRINITY_STRING                  = 704,
-    // 705 unused
+    // 705 previously used, do not reuse
     RBAC_PERM_COMMAND_RELOAD_WAYPOINT_SCRIPTS                = 706,
     RBAC_PERM_COMMAND_RELOAD_WAYPOINT_DATA                   = 707,
     RBAC_PERM_COMMAND_RELOAD_VEHICLE_ACCESORY                = 708,
@@ -681,9 +645,9 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_WP_RELOAD                              = 773,
     RBAC_PERM_COMMAND_WP_SHOW                                = 774,
     RBAC_PERM_COMMAND_MODIFY_CURRENCY                        = 775,
-    RBAC_PERM_COMMAND_DEBUG_PHASE                            = 776,
+    // 776 previously used, do not reuse
     RBAC_PERM_COMMAND_MAILBOX                                = 777,
-    RBAC_PERM_COMMAND_AHBOT                                  = 778,
+    // 778 previously used, do not reuse
     RBAC_PERM_COMMAND_AHBOT_ITEMS                            = 779,
     RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY                       = 780,
     RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE                      = 781,
@@ -740,8 +704,7 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_TICKET_RESET_COMPLAINT                 = 832,
     RBAC_PERM_COMMAND_TICKET_RESET_SUGGESTION                = 833,
     //                                                       = 834, // DEPRECATED: DON'T REUSE
-    RBAC_PERM_COMMAND_DEBUG_LOADCELLS                        = 835,
-    RBAC_PERM_COMMAND_DEBUG_BOUNDARY                         = 836,
+    // 835-836 previously used, do not reuse
     RBAC_PERM_COMMAND_NPC_EVADE                              = 837,
     RBAC_PERM_COMMAND_PET_LEVEL                              = 838,
     RBAC_PERM_COMMAND_SERVER_SHUTDOWN_FORCE                  = 839,
@@ -757,10 +720,9 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_LIST_SCENES                            = 849,
     RBAC_PERM_COMMAND_RELOAD_SCENE_TEMPLATE                  = 850,
     RBAC_PERM_COMMAND_RELOAD_AREATRIGGER_TEMPLATE            = 851,
-    RBAC_PERM_COMMAND_DEBUG_DUMMY                            = 852,
+    // 852 previously used, do not reuse
     RBAC_PERM_COMMAND_RELOAD_CONVERSATION_TEMPLATE           = 853,
-    RBAC_PERM_COMMAND_DEBUG_CONVERSATION                     = 854,
-    RBAC_PERM_COMMAND_DEBUG_PLAY_MUSIC                       = 855,
+    // 854-855 previously used, do not reuse
     RBAC_PERM_COMMAND_NPC_SPAWNGROUP                         = 856,
     RBAC_PERM_COMMAND_NPC_DESPAWNGROUP                       = 857,
     RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP                     = 858,
@@ -774,17 +736,15 @@ enum RBACPermissions
     RBAC_PERM_COMMAND_LIST_SPAWNPOINTS                       = 866,
     RBAC_PERM_COMMAND_RELOAD_QUEST_GREETING_LOCALE           = 867, // reserved
     RBAC_PERM_COMMAND_MODIFY_POWER                           = 868,
-    RBAC_PERM_COMMAND_DEBUG_SEND_PLAYER_CHOICE               = 869,
-    RBAC_PERM_COMMAND_DEBUG_THREATINFO                       = 870,
-    RBAC_PERM_COMMAND_DEBUG_INSTANCESPAWN                    = 871,
+    // 869 previously used, do not reuse
+    // 870-871 previously used, do not reuse
     RBAC_PERM_COMMAND_SERVER_DEBUG                           = 872,
     RBAC_PERM_COMMAND_RELOAD_CREATURE_MOVEMENT_OVERRIDE      = 873,
-    RBAC_PERM_COMMAND_DEBUG_ASAN                             = 874,
+    // 874 previously used, do not reuse
     RBAC_PERM_COMMAND_LOOKUP_MAP_ID                          = 875,
     RBAC_PERM_COMMAND_LOOKUP_ITEM_ID                         = 876,
     RBAC_PERM_COMMAND_LOOKUP_QUEST_ID                        = 877,
-    RBAC_PERM_COMMAND_DEBUG_QUESTRESET                       = 878,
-    RBAC_PERM_COMMAND_DEBUG_POOLSTATUS                       = 879,
+    // 878-879 previously used, do not reuse
     RBAC_PERM_COMMAND_PDUMP_COPY                             = 880,
     RBAC_PERM_COMMAND_RELOAD_VEHICLE_TEMPLATE                = 881,
     RBAC_PERM_COMMAND_RELOAD_SPELL_SCRIPT_NAMES              = 882,
diff --git a/src/server/game/Chat/Chat.cpp b/src/server/game/Chat/Chat.cpp
index 708178e9ab6..59487cde650 100644
--- a/src/server/game/Chat/Chat.cpp
+++ b/src/server/game/Chat/Chat.cpp
@@ -39,7 +39,7 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <sstream>
 
-Player* ChatHandler::GetPlayer() { return m_session ? m_session->GetPlayer() : nullptr; }
+Player* ChatHandler::GetPlayer() const { return m_session ? m_session->GetPlayer() : nullptr; }
 
 char* ChatHandler::LineFromMessage(char*& pos)
 {
@@ -48,56 +48,11 @@ char* ChatHandler::LineFromMessage(char*& pos)
     return start;
 }
 
-// Lazy loading of the command table cache from commands and the
-// ScriptMgr should be thread safe since the player commands,
-// cli commands and ScriptMgr updates are all dispatched one after
-// one inside the world update loop.
-static Optional<std::vector<ChatCommand>> commandTableCache;
-
-std::vector<ChatCommand> const& ChatHandler::getCommandTable()
-{
-    if (!commandTableCache)
-        InitializeCommandTable();
-
-    return *commandTableCache;
-}
-
-void ChatHandler::InitializeCommandTable()
-{
-    // We need to initialize this at top since SetDataForCommandInTable
-    // calls getCommandTable() recursively.
-    commandTableCache = sScriptMgr->GetChatCommands();
-
-    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS);
-    PreparedQueryResult result = WorldDatabase.Query(stmt);
-    if (result)
-    {
-        do
-        {
-            Field* fields = result->Fetch();
-            std::string name = fields[0].GetString();
-
-            SetDataForCommandInTable(*commandTableCache, name.c_str(), fields[1].GetUInt16(), fields[2].GetString(), name);
-        }
-        while (result->NextRow());
-    }
-}
-
-void ChatHandler::invalidateCommandTable()
-{
-    commandTableCache.reset();
-}
-
 char const* ChatHandler::GetTrinityString(uint32 entry) const
 {
     return m_session->GetTrinityString(entry);
 }
 
-bool ChatHandler::isAvailable(ChatCommand const& cmd) const
-{
-    return HasPermission(cmd.Permission);
-}
-
 bool ChatHandler::HasPermission(uint32 permission) const
 {
     return m_session->HasPermission(permission);
@@ -158,31 +113,6 @@ bool ChatHandler::HasLowerSecurityAccount(WorldSession* target, uint32 target_ac
     return false;
 }
 
-bool ChatHandler::hasStringAbbr(const char* name, const char* part)
-{
-    // non "" command
-    if (*name)
-    {
-        // "" part from non-"" command
-        if (!*part)
-            return false;
-
-        while (true)
-        {
-            if (!*part || *part == ' ')
-                return true;
-            else if (!*name)
-                return false;
-            else if (tolower(*name) != tolower(*part))
-                return false;
-            ++name; ++part;
-        }
-    }
-    // allow with any for ""
-
-    return true;
-}
-
 void ChatHandler::SendSysMessage(std::string_view str, bool escapeCharacters)
 {
     std::string msg{ str };
@@ -232,171 +162,9 @@ void ChatHandler::SendSysMessage(uint32 entry)
     SendSysMessage(GetTrinityString(entry));
 }
 
-bool ChatHandler::ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd)
+bool ChatHandler::_ParseCommands(std::string_view text)
 {
-    char const* oldtext = text;
-    std::string cmd = "";
-
-    while (*text != ' ' && *text != '\0')
-    {
-        cmd += *text;
-        ++text;
-    }
-
-    while (*text == ' ') ++text;
-
-    for (uint32 i = 0; i < table.size(); ++i)
-    {
-        if (!hasStringAbbr(table[i].Name, cmd.c_str()))
-            continue;
-
-        bool match = false;
-        if (strlen(table[i].Name) > cmd.length())
-        {
-            for (uint32 j = 0; j < table.size(); ++j)
-            {
-                if (!hasStringAbbr(table[j].Name, cmd.c_str()))
-                    continue;
-
-                if (strcmp(table[j].Name, cmd.c_str()) == 0)
-                {
-                    match = true;
-                    break;
-                }
-            }
-        }
-        if (match)
-            continue;
-
-        // select subcommand from child commands list
-        if (!table[i].ChildCommands.empty())
-        {
-            if (!ExecuteCommandInTable(table[i].ChildCommands, text, fullcmd))
-            {
-                if (m_session && !m_session->HasPermission(rbac::RBAC_PERM_COMMANDS_NOTIFY_COMMAND_NOT_FOUND_ERROR))
-                    return false;
-
-                if (text[0] != '\0')
-                    SendSysMessage(LANG_NO_SUBCMD);
-                else
-                    SendSysMessage(LANG_CMD_SYNTAX);
-
-                ShowHelpForCommand(table[i].ChildCommands, text);
-            }
-
-            return true;
-        }
-
-        // must be available and have handler
-        if (!table[i].HasHandler() || !isAvailable(table[i]))
-            continue;
-
-        SetSentErrorMessage(false);
-        // table[i].Name == "" is special case: send original command to handler
-        if (table[i](this, table[i].Name[0] != '\0' ? text : oldtext))
-        {
-            if (!m_session) // ignore console
-                return true;
-
-            Player* player = m_session->GetPlayer();
-            if (!AccountMgr::IsPlayerAccount(m_session->GetSecurity()))
-            {
-                ObjectGuid guid = player->GetTarget();
-                uint32 areaId = player->GetAreaId();
-                std::string areaName = "Unknown";
-                std::string zoneName = "Unknown";
-                if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
-                {
-                    LocaleConstant locale = GetSessionDbcLocale();
-                    areaName = area->AreaName[locale];
-                    if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
-                        zoneName = zone->AreaName[locale];
-                }
-
-                sLog->outCommand(m_session->GetAccountId(), "Command: %s [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
-                    fullcmd.c_str(), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
-                    m_session->GetAccountId(), player->GetPositionX(), player->GetPositionY(),
-                    player->GetPositionZ(), player->GetMapId(),
-                    player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
-                    areaId, areaName.c_str(), zoneName.c_str(),
-                    (player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
-                    guid.ToString().c_str());
-            }
-        }
-        // some commands have custom error messages. Don't send the default one in these cases.
-        else if (!HasSentErrorMessage())
-        {
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-            else
-                SendSysMessage(LANG_CMD_SYNTAX);
-            SetSentErrorMessage(true);
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-bool ChatHandler::SetDataForCommandInTable(std::vector<ChatCommand>& table, char const* text, uint32 permission, std::string const& help, std::string const& fullcommand)
-{
-    std::string cmd = "";
-
-    while (*text != ' ' && *text != '\0')
-    {
-        cmd += *text;
-        ++text;
-    }
-
-    while (*text == ' ') ++text;
-
-    for (uint32 i = 0; i < table.size(); i++)
-    {
-        // for data fill use full explicit command names
-        if (table[i].Name != cmd)
-            continue;
-
-        // select subcommand from child commands list (including "")
-        if (!table[i].ChildCommands.empty())
-        {
-            if (SetDataForCommandInTable(table[i].ChildCommands, text, permission, help, fullcommand))
-                return true;
-            else if (*text)
-                return false;
-
-            // fail with "" subcommands, then use normal level up command instead
-        }
-        // expected subcommand by full name DB content
-        else if (*text)
-        {
-            TC_LOG_ERROR("sql.sql", "Table `command` contains an unexpected subcommand '%s' in command '%s', skipped.", text, fullcommand.c_str());
-            return false;
-        }
-
-        if (table[i].Permission != permission)
-            TC_LOG_INFO("misc", "Table `command` overwrite for command '%s' default permission (%u) by %u", fullcommand.c_str(), table[i].Permission, permission);
-
-        table[i].Permission = permission;
-        table[i].Help          = help;
-        return true;
-    }
-
-    // in case "" command let process by caller
-    if (!cmd.empty())
-    {
-        if (&table == &getCommandTable())
-            TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing command '%s', skipped.", cmd.c_str());
-        else
-            TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing subcommand '%s' in command '%s', skipped.", cmd.c_str(), fullcommand.c_str());
-    }
-
-    return false;
-}
-
-bool ChatHandler::_ParseCommands(char const* text)
-{
-    if (ExecuteCommandInTable(getCommandTable(), text, text))
+    if (Trinity::ChatCommands::TryExecuteCommand(*this, text))
         return true;
 
     // Pretend commands don't exist for regular players
@@ -404,126 +172,32 @@ bool ChatHandler::_ParseCommands(char const* text)
         return false;
 
     // Send error message for GMs
-    SendSysMessage(LANG_NO_CMD);
+    PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(text));
     SetSentErrorMessage(true);
     return true;
 }
 
-bool ChatHandler::ParseCommands(char const* text)
+bool ChatHandler::ParseCommands(std::string_view text)
 {
-    ASSERT(text);
-    ASSERT(*text);
+    ASSERT(!text.empty());
 
-    /// chat case (.command or !command format)
-    if (text[0] != '!' && text[0] != '.')
+    // chat case (.command or !command format)
+    if ((text[0] != '!') && (text[0] != '.'))
         return false;
 
-    /// ignore single . and ! in line
-    if (!text[1])
+    // ignore single . and ! in line
+    if (text.length() < 2)
         return false;
 
-    /// ignore messages staring from many dots.
-    if (text[1] == '!' || text[1] == '.')
+    // ignore messages staring from many dots.
+    if (text[1] == text[0])
         return false;
 
-    return _ParseCommands(text+1);
-}
-
-bool ChatHandler::ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd)
-{
-    std::string list;
-    for (uint32 i = 0; i < table.size(); ++i)
-    {
-        // must be available (ignore handler existence to show command with possible available subcommands)
-        if (!isAvailable(table[i]))
-            continue;
-
-        // for empty subcmd show all available
-        if (*subcmd && !hasStringAbbr(table[i].Name, subcmd))
-            continue;
-
-        if (m_session)
-            list += "\n    ";
-        else
-            list += "\n\r    ";
-
-        list += table[i].Name;
-
-        if (!table[i].ChildCommands.empty())
-            list += " ...";
-    }
-
-    if (list.empty())
+    // ignore messages with separator after .
+    if (text[1] == Trinity::Impl::ChatCommands::COMMAND_DELIMITER)
         return false;
 
-    if (&table == &getCommandTable())
-    {
-        SendSysMessage(LANG_AVIABLE_CMD);
-        PSendSysMessage("%s", list.c_str());
-    }
-    else
-        PSendSysMessage(LANG_SUBCMDS_LIST, cmd, list.c_str());
-
-    return true;
-}
-
-bool ChatHandler::ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd)
-{
-    if (*cmd)
-    {
-        std::string subcmd;
-        if (size_t n = std::string_view(cmd).find(' '); n != std::string_view::npos)
-            subcmd.assign(cmd+n+1);
-
-        for (uint32 i = 0; i < table.size(); ++i)
-        {
-            // must be available (ignore handler existence to show command with possible available subcommands)
-            if (!isAvailable(table[i]))
-                continue;
-
-            if (!hasStringAbbr(table[i].Name, cmd))
-                continue;
-
-            // have subcommand
-            if (!table[i].ChildCommands.empty() && !subcmd.empty())
-            {
-                if (ShowHelpForCommand(table[i].ChildCommands, subcmd.c_str()))
-                    return true;
-            }
-
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-
-            if (!table[i].ChildCommands.empty())
-                if (ShowHelpForSubCommands(table[i].ChildCommands, table[i].Name, subcmd.c_str()))
-                    return true;
-
-            return !table[i].Help.empty();
-        }
-    }
-    else
-    {
-        for (uint32 i = 0; i < table.size(); ++i)
-        {
-            // must be available (ignore handler existence to show command with possible available subcommands)
-            if (!isAvailable(table[i]))
-                continue;
-
-            if (strlen(table[i].Name))
-                continue;
-
-            if (!table[i].Help.empty())
-                SendSysMessage(table[i].Help.c_str());
-
-            if (!table[i].ChildCommands.empty())
-                if (ShowHelpForSubCommands(table[i].ChildCommands, "", ""))
-                    return true;
-
-            return !table[i].Help.empty();
-        }
-    }
-
-    return ShowHelpForSubCommands(table, "", cmd);
+    return _ParseCommands(text.substr(1));
 }
 
 Player* ChatHandler::getSelectedPlayer()
@@ -1005,25 +679,19 @@ char const* CliHandler::GetTrinityString(uint32 entry) const
     return sObjectMgr->GetTrinityStringForDBCLocale(entry);
 }
 
-bool CliHandler::isAvailable(ChatCommand const& cmd) const
-{
-    // skip non-console commands in console case
-    return cmd.AllowConsole;
-}
-
 void CliHandler::SendSysMessage(std::string_view str, bool /*escapeCharacters*/)
 {
     m_print(m_callbackArg, str);
     m_print(m_callbackArg, "\r\n");
 }
 
-bool CliHandler::ParseCommands(char const* str)
+bool CliHandler::ParseCommands(std::string_view str)
 {
-    if (!str[0])
+    if (str.empty())
         return false;
     // Console allows using commands both with and without leading indicator
     if (str[0] == '.' || str[0] == '!')
-        ++str;
+        str = str.substr(1);
     return _ParseCommands(str);
 }
 
@@ -1093,14 +761,12 @@ LocaleConstant CliHandler::GetSessionDbLocaleIndex() const
 
 std::string const AddonChannelCommandHandler::PREFIX = "TrinityCore";
 
-bool AddonChannelCommandHandler::ParseCommands(char const* str)
+bool AddonChannelCommandHandler::ParseCommands(std::string_view str)
 {
-    char opcode = str[0];
-    if (!opcode) // str[0] is opcode
+    if (str.length() < 5)
         return false;
-    if (!str[1] || !str[2] || !str[3] || !str[4]) // str[1] through str[4] is 4-character command counter
-        return false;
-    echo = str+1;
+    char opcode = str[0];
+    echo = &str[1];
 
     switch (opcode)
     {
@@ -1109,10 +775,12 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
             return true;
         case 'h': // h Issue human-readable command
         case 'i': // i Issue command
+        {
             if (!str[5])
                 return false;
             humanReadable = (opcode == 'h');
-            if (_ParseCommands(str + 5)) // actual command starts at str[5]
+            std::string_view cmd = str.substr(5);
+            if (_ParseCommands(cmd)) // actual command starts at str[5]
             {
                 if (!hadAck)
                     SendAck();
@@ -1123,10 +791,11 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
             }
             else
             {
-                SendSysMessage(LANG_NO_CMD);
+                PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmd));
                 SendFailed();
             }
             return true;
+        }
         default:
             return false;
     }
diff --git a/src/server/game/Chat/Chat.h b/src/server/game/Chat/Chat.h
index edb5858ac7c..5af87f472e9 100644
--- a/src/server/game/Chat/Chat.h
+++ b/src/server/game/Chat/Chat.h
@@ -20,9 +20,7 @@
 
 #include "ObjectGuid.h"
 #include "StringFormat.h"
-#include <vector>
 
-class ChatCommand;
 class ChatHandler;
 class Creature;
 class GameObject;
@@ -39,8 +37,10 @@ enum LocaleConstant : uint8;
 class TC_GAME_API ChatHandler
 {
     public:
+        bool IsConsole() const { return (m_session == nullptr); }
         WorldSession* GetSession() { return m_session; }
-        Player* GetPlayer();
+        WorldSession const* GetSession() const { return m_session; }
+        Player* GetPlayer() const;
         explicit ChatHandler(WorldSession* session) : m_session(session), sentErrorMessage(false) { }
         virtual ~ChatHandler() { }
 
@@ -70,19 +70,12 @@ class TC_GAME_API ChatHandler
             return Trinity::StringFormat(GetTrinityString(entry), std::forward<Args>(args)...);
         }
 
-        bool _ParseCommands(char const* text);
-        virtual bool ParseCommands(char const* text);
-
-        static std::vector<ChatCommand> const& getCommandTable();
-        static void InitializeCommandTable();
-        static void invalidateCommandTable();
+        bool _ParseCommands(std::string_view text);
+        virtual bool ParseCommands(std::string_view text);
 
         void SendGlobalSysMessage(const char *str);
 
-        bool hasStringAbbr(const char* name, const char* part);
-
         // function with different implementation for chat/console
-        virtual bool isAvailable(ChatCommand const& cmd) const;
         virtual bool IsHumanReadable() const { return true; }
         virtual bool HasPermission(uint32 permission) const;
         virtual std::string GetNameLink() const;
@@ -119,13 +112,8 @@ class TC_GAME_API ChatHandler
         Creature* GetCreatureFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid);
         bool HasSentErrorMessage() const { return sentErrorMessage; }
         void SetSentErrorMessage(bool val){ sentErrorMessage = val; }
-
-        bool ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd);
     protected:
         explicit ChatHandler() : m_session(nullptr), sentErrorMessage(false) { }     // for CLI subclass
-        static bool SetDataForCommandInTable(std::vector<ChatCommand>& table, const char* text, uint32 permission, std::string const& help, std::string const& fullcommand);
-        bool ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd);
-        bool ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd);
 
     private:
         WorldSession* m_session;                           // != nullptr for chat command call and nullptr for CLI command
@@ -142,10 +130,9 @@ class TC_GAME_API CliHandler : public ChatHandler
 
         // overwrite functions
         char const* GetTrinityString(uint32 entry) const override;
-        bool isAvailable(ChatCommand const& cmd) const override;
         bool HasPermission(uint32 /*permission*/) const override { return true; }
         void SendSysMessage(std::string_view, bool escapeCharacters) override;
-        bool ParseCommands(char const* str) override;
+        bool ParseCommands(std::string_view str) override;
         std::string GetNameLink() const override;
         bool needReportToTarget(Player* chr) const override;
         LocaleConstant GetSessionDbcLocale() const override;
@@ -162,7 +149,7 @@ class TC_GAME_API AddonChannelCommandHandler : public ChatHandler
         static std::string const PREFIX;
 
         using ChatHandler::ChatHandler;
-        bool ParseCommands(char const* str) override;
+        bool ParseCommands(std::string_view str) override;
         void SendSysMessage(std::string_view, bool escapeCharacters) override;
         using ChatHandler::SendSysMessage;
         bool IsHumanReadable() const override { return humanReadable; }
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.cpp b/src/server/game/Chat/ChatCommands/ChatCommand.cpp
new file mode 100644
index 00000000000..865979999d7
--- /dev/null
+++ b/src/server/game/Chat/ChatCommands/ChatCommand.cpp
@@ -0,0 +1,466 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ChatCommand.h"
+
+#include "AccountMgr.h"
+#include "Chat.h"
+#include "DatabaseEnv.h"
+#include "DB2Stores.h"
+#include "Log.h"
+#include "Map.h"
+#include "Player.h"
+#include "ScriptMgr.h"
+#include "WorldSession.h"
+
+using ChatSubCommandMap = std::map<std::string_view, Trinity::Impl::ChatCommands::ChatCommandNode, StringCompareLessI_T>;
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::LoadFromBuilder(ChatCommandBuilder const& builder)
+{
+    if (std::holds_alternative<ChatCommandBuilder::InvokerEntry>(builder._data))
+    {
+        ASSERT(!_invoker, "Duplicate blank sub-command.");
+        std::tie(_invoker, _permission) = std::get<ChatCommandBuilder::InvokerEntry>(builder._data);
+    }
+    else
+        LoadCommandsIntoMap(this, _subCommands, std::get<ChatCommandBuilder::SubCommandEntry>(builder._data));
+}
+
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandsIntoMap(ChatCommandNode* blank, ChatSubCommandMap& map, Trinity::ChatCommands::ChatCommandTable const& commands)
+{
+    for (ChatCommandBuilder const& builder : commands)
+    {
+        if (builder._name.empty())
+        {
+            ASSERT(blank, "Empty name command at top level is not permitted.");
+            blank->LoadFromBuilder(builder);
+        }
+        else
+        {
+            std::vector<std::string_view> const tokens = Trinity::Tokenize(builder._name, COMMAND_DELIMITER, false);
+            ASSERT(!tokens.empty(), "Invalid command name '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(builder._name));
+            ChatSubCommandMap* subMap = &map;
+            for (size_t i = 0, n = (tokens.size() - 1); i < n; ++i)
+                subMap = &((*subMap)[tokens[i]]._subCommands);
+            ((*subMap)[tokens.back()]).LoadFromBuilder(builder);
+        }
+    }
+}
+
+static ChatSubCommandMap COMMAND_MAP;
+/*static*/ ChatSubCommandMap const& Trinity::Impl::ChatCommands::ChatCommandNode::GetTopLevelMap()
+{
+    if (COMMAND_MAP.empty())
+        LoadCommandMap();
+    return COMMAND_MAP;
+}
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap() { COMMAND_MAP.clear(); }
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap()
+{
+    InvalidateCommandMap();
+    LoadCommandsIntoMap(nullptr, COMMAND_MAP, sScriptMgr->GetChatCommands());
+
+    if (PreparedQueryResult result = WorldDatabase.Query(WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS)))
+    {
+        do
+        {
+            Field* fields = result->Fetch();
+            std::string_view const name = fields[0].GetStringView();
+            uint16 const permission = fields[1].GetUInt16();
+            std::string_view const help = fields[2].GetStringView();
+
+            ChatCommandNode* cmd = nullptr;
+            ChatSubCommandMap* map = &COMMAND_MAP;
+            for (std::string_view key : Trinity::Tokenize(name, COMMAND_DELIMITER, false))
+            {
+                auto it = map->find(key);
+                if (it != map->end())
+                {
+                    cmd = &it->second;
+                    map = &cmd->_subCommands;
+                }
+                else
+                {
+                    TC_LOG_ERROR("sql.sql", "Table `command` contains data for non-existant command '" STRING_VIEW_FMT "'. Skipped.", STRING_VIEW_FMT_ARG(name));
+                    cmd = nullptr;
+                    break;
+                }
+            }
+
+            if (!cmd)
+                continue;
+
+            if (cmd->_invoker && (cmd->_permission.RequiredPermission != permission))
+            {
+                TC_LOG_WARN("sql.sql", "Table `command` has permission %u for '" STRING_VIEW_FMT "' which does not match the core (%u). Overriding.",
+                    permission, STRING_VIEW_FMT_ARG(name), cmd->_permission.RequiredPermission);
+
+                cmd->_permission.RequiredPermission = static_cast<rbac::RBACPermissions>(permission);
+            }
+
+            cmd->_help.assign(help);
+        } while (result->NextRow());
+    }
+
+    for (auto const& [name, cmd] : COMMAND_MAP)
+        cmd.AssertCommandHelp(name);
+}
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::AssertCommandHelp(std::string_view name) const
+{
+    if (_invoker && _help.empty())
+        TC_LOG_WARN("sql.sql", "Table `command` is missing help text for (sub-)command '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(name));
+
+    for (auto const& [name, cmd] : _subCommands)
+        cmd.AssertCommandHelp(name);
+}
+
+static void LogCommandUsage(WorldSession const& session, uint32 permission, std::string_view cmdStr)
+{
+    if (AccountMgr::IsPlayerAccount(session.GetSecurity()))
+        return;
+
+    if (sAccountMgr->GetRBACPermission(rbac::RBAC_ROLE_PLAYER)->GetLinkedPermissions().count(permission))
+        return;
+
+    Player* player = session.GetPlayer();
+    ObjectGuid targetGuid = player->GetTarget();
+    uint32 areaId = player->GetAreaId();
+    std::string areaName = "Unknown";
+    std::string zoneName = "Unknown";
+    if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
+    {
+        LocaleConstant locale = session.GetSessionDbcLocale();
+        areaName = area->AreaName[locale];
+        if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
+            zoneName = zone->AreaName[locale];
+    }
+
+    sLog->outCommand(session.GetAccountId(), "Command: " STRING_VIEW_FMT " [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
+        STRING_VIEW_FMT_ARG(cmdStr), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
+        session.GetAccountId(), player->GetPositionX(), player->GetPositionY(),
+        player->GetPositionZ(), player->GetMapId(),
+        player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
+        areaId, areaName.c_str(), zoneName.c_str(),
+        (player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
+        targetGuid.ToString().c_str());
+}
+
+void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelp(ChatHandler& handler) const
+{
+    if (IsInvokerVisible(handler))
+        handler.SendSysMessage(_help);
+    bool header = false;
+    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
+    {
+        bool const subCommandHasSubCommand = it->second.HasVisibleSubCommands(handler);
+        if (!subCommandHasSubCommand && !it->second.IsInvokerVisible(handler))
+            continue;
+        if (!header)
+        {
+            handler.SendSysMessage(LANG_SUBCMDS_LIST);
+            header = true;
+        }
+        handler.PSendSysMessage(subCommandHasSubCommand ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
+    }
+}
+
+namespace Trinity::Impl::ChatCommands
+{
+    struct FilteredCommandListIterator
+    {
+        public:
+            FilteredCommandListIterator(ChatSubCommandMap const& map, ChatHandler const& handler, std::string_view token)
+                : _handler{ handler }, _token{ token }, _it{ map.lower_bound(token) }, _end{ map.end() }
+            {
+                _skip();
+            }
+
+            decltype(auto) operator*() const { return _it.operator*(); }
+            decltype(auto) operator->() const { return _it.operator->(); }
+            FilteredCommandListIterator& operator++()
+            {
+                ++_it;
+                _skip();
+                return *this;
+            }
+            explicit operator bool() const { return (_it != _end); }
+            bool operator!() const { return !static_cast<bool>(*this); }
+
+        private:
+            void _skip()
+            {
+                if ((_it != _end) && !StringStartsWithI(_it->first, _token))
+                    _it = _end;
+                while ((_it != _end) && !_it->second.IsVisible(_handler))
+                {
+                    ++_it;
+                    if ((_it != _end) && !StringStartsWithI(_it->first, _token))
+                        _it = _end;
+                }
+            }
+            ChatHandler const& _handler;
+            std::string_view const _token;
+            ChatSubCommandMap::const_iterator _it, _end;
+
+    };
+}
+
+/*static*/ bool Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(ChatHandler& handler, std::string_view cmdStr)
+{
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+
+    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
+        cmdStr.remove_prefix(1);
+    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
+        cmdStr.remove_suffix(1);
+    std::string_view oldTail = cmdStr;
+    while (!oldTail.empty())
+    {
+        /* oldTail = token DELIMITER newTail */
+        auto [token, newTail] = tokenize(oldTail);
+        ASSERT(!token.empty());
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+            break; /* no matching subcommands found */
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - print possibilities and return */
+                if (cmd)
+                    handler.PSendSysMessage(LANG_SUBCMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                else
+                    handler.PSendSysMessage(LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
+                do
+                {
+                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
+                } while (++it2);
+
+                return true;
+            }
+        }
+
+        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+
+        oldTail = newTail;
+    }
+
+    if (cmd)
+    { /* if we matched a command at some point, invoke it */
+        handler.SetSentErrorMessage(false);
+        if (cmd->IsInvokerVisible(handler) && cmd->_invoker(&handler, oldTail))
+        { /* invocation succeeded, log this */
+            if (!handler.IsConsole())
+                LogCommandUsage(*handler.GetSession(), cmd->_permission.RequiredPermission, cmdStr);
+        }
+        else if (!handler.HasSentErrorMessage())
+        { /* invocation failed, we should show usage */
+            cmd->SendCommandHelp(handler);
+            handler.SetSentErrorMessage(true);
+        }
+        return true;
+    }
+
+    return false;
+}
+
+/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(ChatHandler& handler, std::string_view cmdStr)
+{
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+    for (std::string_view token : Trinity::Tokenize(cmdStr, COMMAND_DELIMITER, false))
+    {
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+        { /* no matching subcommands found */
+            if (cmd)
+            {
+                cmd->SendCommandHelp(handler);
+                handler.PSendSysMessage(LANG_SUBCMD_INVALID, STRING_VIEW_FMT_ARG(token));
+            }
+            else
+                handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(token));
+            return;
+        }
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - print possibilities and return */
+                handler.PSendSysMessage(cmd ? LANG_SUBCMD_AMBIGUOUS : LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
+                handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
+                do
+                {
+                    handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
+                } while (++it2);
+
+                return;
+            }
+        }
+
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+    }
+
+    if (cmd)
+        cmd->SendCommandHelp(handler);
+    else if (cmdStr.empty())
+    {
+        FilteredCommandListIterator it(*map, handler, "");
+        if (!it)
+            return;
+        handler.SendSysMessage(LANG_AVAILABLE_CMDS);
+        do
+        {
+            handler.PSendSysMessage(it->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
+        } while (++it);
+    }
+    else
+        handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmdStr));
+}
+
+/*static*/ std::vector<std::string> Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmdStr)
+{
+    std::string path;
+    ChatCommandNode const* cmd = nullptr;
+    ChatSubCommandMap const* map = &GetTopLevelMap();
+
+    while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
+        cmdStr.remove_prefix(1);
+    while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
+        cmdStr.remove_suffix(1);
+    std::string_view oldTail = cmdStr;
+    while (!oldTail.empty())
+    {
+        /* oldTail = token DELIMITER newTail */
+        auto [token, newTail] = tokenize(oldTail);
+        ASSERT(!token.empty());
+        FilteredCommandListIterator it1(*map, handler, token);
+        if (!it1)
+            break; /* no matching subcommands found */
+
+        if (!StringEqualI(it1->first, token))
+        { /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
+            auto it2 = it1;
+            ++it2;
+
+            if (it2)
+            { /* there are multiple matching subcommands - terminate here and show possibilities */
+                std::vector<std::string> vec;
+                auto possibility = ([prefix = std::string_view(path), suffix = std::string_view(newTail)](std::string_view match)
+                {
+                    if (prefix.empty())
+                    {
+                        return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                            STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
+                    }
+                    else
+                    {
+                        return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                            STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
+                    }
+                });
+
+                vec.emplace_back(possibility(it1->first));
+
+                do vec.emplace_back(possibility(it2->first));
+                while (++it2);
+
+                return vec;
+            }
+        }
+
+        /* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
+        if (path.empty())
+            path.assign(it1->first);
+        else
+        {
+            path = Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(it1->first));
+        }
+        cmd = &it1->second;
+        map = &cmd->_subCommands;
+
+        oldTail = newTail;
+    }
+
+    if (!oldTail.empty())
+    { /* there is some trailing text, leave it as is */
+        if (cmd)
+        { /* if we matched a command at some point, auto-complete it */
+            return {
+                Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                    STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(oldTail))
+            };
+        }
+        else
+            return {};
+    }
+    else
+    { /* offer all subcommands */
+        auto possibility = ([prefix = std::string_view(path)](std::string_view match)
+        {
+            if (prefix.empty())
+                return std::string(match);
+            else
+            {
+                return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
+                    STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match));
+            }
+        });
+
+        std::vector<std::string> vec;
+        for (FilteredCommandListIterator it(*map, handler, ""); it; ++it)
+            vec.emplace_back(possibility(it->first));
+        return vec;
+    }
+}
+
+bool Trinity::Impl::ChatCommands::ChatCommandNode::IsInvokerVisible(ChatHandler const& who) const
+{
+    if (!_invoker)
+        return false;
+    if (who.IsConsole() && (_permission.AllowConsole == Trinity::ChatCommands::Console::No))
+        return false;
+    return who.HasPermission(_permission.RequiredPermission);
+}
+
+bool Trinity::Impl::ChatCommands::ChatCommandNode::HasVisibleSubCommands(ChatHandler const& who) const
+{
+    for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
+        if (it->second.IsVisible(who))
+            return true;
+    return false;
+}
+
+void Trinity::ChatCommands::LoadCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap(); }
+void Trinity::ChatCommands::InvalidateCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap(); }
+bool Trinity::ChatCommands::TryExecuteCommand(ChatHandler& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(handler, cmd); }
+void Trinity::ChatCommands::SendCommandHelpFor(ChatHandler& handler, std::string_view cmd) { Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(handler, cmd); }
+std::vector<std::string> Trinity::ChatCommands::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(handler, cmd); }
+
diff --git a/src/server/game/Chat/ChatCommands/ChatCommand.h b/src/server/game/Chat/ChatCommands/ChatCommand.h
index 41be7e74c1a..25fcff415c1 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommand.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommand.h
@@ -24,14 +24,31 @@
 #include "Define.h"
 #include "Errors.h"
 #include "Optional.h"
+#include "RBAC.h"
 #include "StringFormat.h"
+#include "Util.h"
 #include <cstddef>
+#include <map>
+#include <utility>
 #include <tuple>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 class ChatHandler;
 
+namespace Trinity::ChatCommands
+{
+    enum class Console : bool
+    {
+        No = false,
+        Yes = true
+    };
+
+    struct ChatCommandBuilder;
+    using ChatCommandTable = std::vector<ChatCommandBuilder>;
+}
+
 namespace Trinity::Impl::ChatCommands
 {
     // forward declaration
@@ -97,63 +114,134 @@ namespace Trinity::Impl::ChatCommands
     }
 
     template <typename T> struct HandlerToTuple { static_assert(Trinity::dependant_false_v<T>, "Invalid command handler signature"); };
-    template <typename... Ts> struct HandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
+    template <typename... Ts> struct HandlerToTuple<bool(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
     template <typename T> using TupleType = typename HandlerToTuple<T>::type;
-}
-
 
-class TC_GAME_API ChatCommand
-{
-    using wrapper_func = bool(void*, ChatHandler*, char const*);
-
-    public:
+    struct CommandInvoker
+    {
+        CommandInvoker() : _wrapper(nullptr), _handler(nullptr) {}
         template <typename TypedHandler>
-        ChatCommand(char const* name, uint32 permission, bool allowConsole, TypedHandler handler, std::string help)
-            : Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands({})
+        CommandInvoker(TypedHandler& handler)
         {
-            _wrapper = [](void* handler, ChatHandler* chatHandler, char const* argsStr)
+            _wrapper = [](void* handler, ChatHandler* chatHandler, std::string_view argsStr)
             {
-                using Tuple = Trinity::Impl::ChatCommands::TupleType<TypedHandler>;
+                using Tuple = TupleType<TypedHandler>;
 
                 Tuple arguments;
                 std::get<0>(arguments) = chatHandler;
-                Trinity::Impl::ChatCommands::ChatCommandResult result = Trinity::Impl::ChatCommands::ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
+                ChatCommandResult result = ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
                 if (result)
-                    return std::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments));
+                    return std::apply(reinterpret_cast<TypedHandler*>(handler), std::move(arguments));
                 else
                 {
                     if (result.HasErrorMessage())
-                        Trinity::Impl::ChatCommands::SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
+                        SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
                     return false;
                 }
             };
             _handler = reinterpret_cast<void*>(handler);
         }
 
-        ChatCommand(char const* name, uint32 permission, bool allowConsole, std::nullptr_t, std::string help, std::vector<ChatCommand> childCommands = {})
-            : Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands(std::move(childCommands))
-        {
-            _wrapper = nullptr;
-            _handler = nullptr;
-        }
-
-        bool operator()(ChatHandler* chatHandler, char const* args) const
+        explicit operator bool() const { return (_wrapper != nullptr); }
+        bool operator()(ChatHandler* chatHandler, std::string_view args) const
         {
             ASSERT(_wrapper && _handler);
             return _wrapper(_handler, chatHandler, args);
         }
 
-        bool HasHandler() const { return !!_handler; }
-
-        char const* Name;
-        uint32 Permission;
-        bool AllowConsole;
-        std::string Help;
-        std::vector<ChatCommand> ChildCommands;
-
     private:
+        using wrapper_func = bool(void*, ChatHandler*, std::string_view);
         wrapper_func* _wrapper;
         void* _handler;
-};
+    };
+
+    struct CommandPermissions
+    {
+        CommandPermissions() : RequiredPermission{}, AllowConsole{} {}
+        CommandPermissions(rbac::RBACPermissions perm, Trinity::ChatCommands::Console console) : RequiredPermission{ perm }, AllowConsole{ console } {}
+        rbac::RBACPermissions RequiredPermission;
+        Trinity::ChatCommands::Console AllowConsole;
+    };
+
+    class ChatCommandNode
+    {
+        friend struct FilteredCommandListIterator;
+        using ChatCommandBuilder = Trinity::ChatCommands::ChatCommandBuilder;
+
+        public:
+            static void LoadCommandMap();
+            static void InvalidateCommandMap();
+            static bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
+            static void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
+            static std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
+
+            ChatCommandNode() : _invoker{}, _permission{}, _help{}, _subCommands{} {}
+
+        private:
+            static std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> const& GetTopLevelMap();
+            static void LoadCommandsIntoMap(ChatCommandNode* blank, std::map<std::string_view, ChatCommandNode, StringCompareLessI_T>& map, Trinity::ChatCommands::ChatCommandTable const& commands);
+
+            void LoadFromBuilder(ChatCommandBuilder const& builder);
+            ChatCommandNode(ChatCommandNode&& other) = default;
+
+            void AssertCommandHelp(std::string_view name) const;
+            void SendCommandHelp(ChatHandler& handler) const;
+
+            bool IsVisible(ChatHandler const& who) const { return (IsInvokerVisible(who) || HasVisibleSubCommands(who)); }
+            bool IsInvokerVisible(ChatHandler const& who) const;
+            bool HasVisibleSubCommands(ChatHandler const& who) const;
+
+            CommandInvoker _invoker;
+            CommandPermissions _permission;
+            std::string _help;
+            std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> _subCommands;
+    };
+}
+
+namespace Trinity::ChatCommands
+{
+    struct ChatCommandBuilder
+    {
+        friend class Trinity::Impl::ChatCommands::ChatCommandNode;
+        using InvokerEntry = std::pair<Trinity::Impl::ChatCommands::CommandInvoker, Trinity::Impl::ChatCommands::CommandPermissions>;
+        using SubCommandEntry = std::reference_wrapper<std::vector<ChatCommandBuilder> const>;
+
+        template <typename TypedHandler>
+        ChatCommandBuilder(char const* name, TypedHandler& handler, rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
+        {}
+        ChatCommandBuilder(char const* name, std::vector<ChatCommandBuilder> const& subCommands)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<SubCommandEntry>, subCommands }
+        {}
+        ChatCommandBuilder(ChatCommandBuilder const&) = default;
+
+        /* deprecated: char const* parameters to command handlers */
+        [[deprecated]] ChatCommandBuilder(char const* name, bool(&handler)(ChatHandler*, char const*), rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
+        {}
+
+        /* deprecated: old-style command table format */
+        template <typename TypedHandler>
+        [[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions permission, bool console, TypedHandler* handler, char const*)
+            : _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(*handler), std::forward_as_tuple(permission, static_cast<Trinity::ChatCommands::Console>(console)) }
+        {}
+        [[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions, bool, std::nullptr_t, char const*, std::vector <ChatCommandBuilder> const& sub)
+            : _name{ ASSERT_NOTNULL(name) }, _data { std::in_place_type<SubCommandEntry>, sub }
+        {}
+
+    private:
+        std::string_view _name;
+        std::variant<InvokerEntry, SubCommandEntry> _data;
+    };
+
+    TC_GAME_API void LoadCommandMap();
+    TC_GAME_API void InvalidateCommandMap();
+    TC_GAME_API bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
+    TC_GAME_API void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
+    TC_GAME_API std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
+}
+
+// backwards compatibility with old patches
+using ChatCommand [[deprecated]] = Trinity::ChatCommands::ChatCommandBuilder;
 
 #endif
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
index 8d2af4e7930..5d51e7c6da6 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
@@ -81,7 +81,7 @@ namespace Trinity::Impl::ChatCommands
     template <>
     struct ArgInfo<char const*, void>
     {
-        static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = args.data(); return std::string_view(); }
+        static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = (args.empty() ? "" : args.data()); return std::string_view(); }
     };
 
     // string_view
diff --git a/src/server/game/Miscellaneous/Language.h b/src/server/game/Miscellaneous/Language.h
index 99c4342a3bb..2ff3bed0043 100644
--- a/src/server/game/Miscellaneous/Language.h
+++ b/src/server/game/Miscellaneous/Language.h
@@ -35,10 +35,10 @@ enum TrinityStrings
     LANG_SYSTEMMESSAGE                    = 3,
     LANG_EVENTMESSAGE                     = 4,
     LANG_NO_HELP_CMD                      = 5,
-    LANG_NO_CMD                           = 6,
-    LANG_NO_SUBCMD                        = 7,
+    LANG_CMD_INVALID                      = 6,
+    LANG_SUBCMD_AMBIGUOUS                 = 7,
     LANG_SUBCMDS_LIST                     = 8,
-    LANG_AVIABLE_CMD                      = 9,
+    LANG_AVAILABLE_CMDS                   = 9,
     LANG_CMD_SYNTAX                       = 10,
     LANG_ACCOUNT_LEVEL                    = 11,
     LANG_CONNECTED_USERS                  = 12,
@@ -232,10 +232,10 @@ enum TrinityStrings
     LANG_2FA_SECRET_TOO_LONG              = 188,
     LANG_2FA_SECRET_INVALID               = 189,
     LANG_2FA_SECRET_SET_COMPLETE          = 190,
-    LANG_SUBCMDS_LIST_ENTRY               = 191, // 3.3.5 RESERVED
-    LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS      = 192, // 3.3.5 RESERVED
-    LANG_SUBCMD_INVALID                   = 193, // 3.3.5 RESERVED
-    LANG_CMD_AMBIGUOUS                    = 194, // 3.3.5 RESERVED
+    LANG_SUBCMDS_LIST_ENTRY               = 191,
+    LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS      = 192,
+    LANG_SUBCMD_INVALID                   = 193,
+    LANG_CMD_AMBIGUOUS                    = 194,
     LANG_CMD_HELP_GENERIC                 = 195, // 3.3.5 RESERVED
     LANG_CMD_NO_HELP_AVAILABLE            = 196, // 3.3.5 RESERVED
     // Room for more level 1                197-199 not used
diff --git a/src/server/game/Scripting/ScriptMgr.cpp b/src/server/game/Scripting/ScriptMgr.cpp
index b50f5a21642..30eefe2fb4a 100644
--- a/src/server/game/Scripting/ScriptMgr.cpp
+++ b/src/server/game/Scripting/ScriptMgr.cpp
@@ -19,7 +19,6 @@
 #include "AchievementMgr.h"
 #include "AreaTrigger.h"
 #include "AreaTriggerAI.h"
-#include "Chat.h"
 #include "ChatCommand.h"
 #include "Conversation.h"
 #include "Creature.h"
@@ -1057,17 +1056,17 @@ class ScriptRegistrySwapHooks<CommandScript, Base>
 public:
     void BeforeReleaseContext(std::string const& /*context*/) final override
     {
-        ChatHandler::invalidateCommandTable();
+        Trinity::ChatCommands::InvalidateCommandMap();
     }
 
     void BeforeSwapContext(bool /*initialize*/) override
     {
-        ChatHandler::invalidateCommandTable();
+        Trinity::ChatCommands::InvalidateCommandMap();
     }
 
     void BeforeUnload() final override
     {
-        ChatHandler::invalidateCommandTable();
+        Trinity::ChatCommands::InvalidateCommandMap();
     }
 };
 
@@ -1753,22 +1752,16 @@ OutdoorPvP* ScriptMgr::CreateOutdoorPvP(uint32 scriptId)
     return tmpscript->GetOutdoorPvP();
 }
 
-std::vector<ChatCommand> ScriptMgr::GetChatCommands()
+Trinity::ChatCommands::ChatCommandTable ScriptMgr::GetChatCommands()
 {
-    std::vector<ChatCommand> table;
+    Trinity::ChatCommands::ChatCommandTable table;
 
     FOR_SCRIPTS_RET(CommandScript, itr, end, table)
     {
-        std::vector<ChatCommand> cmds = itr->second->GetCommands();
-        table.insert(table.end(), cmds.begin(), cmds.end());
+        Trinity::ChatCommands::ChatCommandTable cmds = itr->second->GetCommands();
+        std::move(cmds.begin(), cmds.end(), std::back_inserter(table));
     }
 
-    // Sort commands in alphabetical order
-    std::sort(table.begin(), table.end(), [](ChatCommand const& a, ChatCommand const& b)
-    {
-        return strcmp(a.Name, b.Name) < 0;
-    });
-
     return table;
 }
 
diff --git a/src/server/game/Scripting/ScriptMgr.h b/src/server/game/Scripting/ScriptMgr.h
index 9d420542cae..36e0a2addfc 100644
--- a/src/server/game/Scripting/ScriptMgr.h
+++ b/src/server/game/Scripting/ScriptMgr.h
@@ -34,7 +34,6 @@ class Battlefield;
 class Battleground;
 class BattlegroundMap;
 class Channel;
-class ChatCommand;
 class Conversation;
 class Creature;
 class CreatureAI;
@@ -79,6 +78,8 @@ struct Position;
 struct QuestObjective;
 struct SceneTemplate;
 
+namespace Trinity::ChatCommands { struct ChatCommandBuilder; }
+
 enum BattlegroundTypeId : uint32;
 enum Difficulty : uint8;
 enum DuelCompleteType : uint8;
@@ -569,7 +570,7 @@ class TC_GAME_API CommandScript : public ScriptObject
         ~CommandScript();
 
         // Should return a pointer to a valid command table (ChatCommand array) to be used by ChatHandler.
-        virtual std::vector<ChatCommand> GetCommands() const = 0;
+        virtual std::vector<Trinity::ChatCommands::ChatCommandBuilder> GetCommands() const = 0;
 };
 
 class TC_GAME_API WeatherScript : public ScriptObject, public UpdatableScript<Weather>
@@ -1149,7 +1150,7 @@ class TC_GAME_API ScriptMgr
 
     public: /* CommandScript */
 
-        std::vector<ChatCommand> GetChatCommands();
+        std::vector<Trinity::ChatCommands::ChatCommandBuilder> GetChatCommands();
 
     public: /* WeatherScript */
 
diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp
index e9edf05026c..67bd521f23d 100644
--- a/src/server/game/World/World.cpp
+++ b/src/server/game/World/World.cpp
@@ -38,6 +38,7 @@
 #include "CharacterDatabaseCleaner.h"
 #include "CharacterTemplateDataStore.h"
 #include "Chat.h"
+#include "ChatCommand.h"
 #include "ChatPackets.h"
 #include "Config.h"
 #include "ConversationDataStore.h"
@@ -2314,7 +2315,7 @@ void World::SetInitialWorldSettings()
     sObjectMgr->InitializeQueriesData(QUERY_DATA_ALL);
 
     TC_LOG_INFO("server.loading", "Initialize commands...");
-    ChatHandler::InitializeCommandTable();
+    Trinity::ChatCommands::LoadCommandMap();
 
     ///- Initialize game time and timers
     TC_LOG_INFO("server.loading", "Initialize game time and timers");
diff --git a/src/server/scripts/Commands/cs_account.cpp b/src/server/scripts/Commands/cs_account.cpp
index d20cabcad2e..5d122436de4 100644
--- a/src/server/scripts/Commands/cs_account.cpp
+++ b/src/server/scripts/Commands/cs_account.cpp
@@ -49,48 +49,36 @@ class account_commandscript : public CommandScript
 public:
     account_commandscript() : CommandScript("account_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> accountSetSecTable =
-        {
-            { "regmail",        rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL, true,  &HandleAccountSetRegEmailCommand,  ""       },
-            { "email",          rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL,   true,  &HandleAccountSetEmailCommand,     ""       },
-        };
-        static std::vector<ChatCommand> accountSetCommandTable =
-        {
-            { "addon",          rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON,       true,  &HandleAccountSetAddonCommand,     ""       },
-            { "sec",            rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC,         true,  nullptr,                "", accountSetSecTable },
-            { "gmlevel",        rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL,    true,  &HandleAccountSetSecLevelCommand,  ""       },  // temp for a transition period
-            { "seclevel",       rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL,    true,  &HandleAccountSetSecLevelCommand,  ""       },
-            { "password",       rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD,    true,  &HandleAccountSetPasswordCommand,  ""       },
-            { "2fa",            rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_2FA,         true,  &HandleAccountSet2FACommand,       ""       },
-        };
-        static std::vector<ChatCommand> account2FACommandTable =
-        {
-            { "setup",          rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_SETUP,       false,  &HandleAccount2FASetupCommand,     ""      },
-            { "remove",         rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_REMOVE,      false,  &HandleAccount2FARemoveCommand,     ""     },
-        };
-        static std::vector<ChatCommand> accountLockCommandTable =
-        {
-            { "country",        rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY,    false,  &HandleAccountLockCountryCommand,  ""      },
-            { "ip",             rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP,         false,  &HandleAccountLockIpCommand,       ""      },
+        static ChatCommandTable accountSetCommandTable =
+        {
+            { "addon",              HandleAccountSetAddonCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON,          Console::Yes },
+            { "sec regmail",        HandleAccountSetRegEmailCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL,    Console::Yes },
+            { "sec email",          HandleAccountSetEmailCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL,      Console::Yes },
+            { "gmlevel",            HandleAccountSetSecLevelCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL,       Console::Yes },  // temp for a transition period
+            { "seclevel",           HandleAccountSetSecLevelCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL,       Console::Yes },
+            { "password",           HandleAccountSetPasswordCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD,       Console::Yes },
+            { "2fa",                HandleAccountSet2FACommand,         rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_2FA,            Console::Yes },
         };
-        static std::vector<ChatCommand> accountCommandTable =
-        {
-            { "2fa",            rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA,             false, nullptr,           "", account2FACommandTable  },
-            { "addon",          rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON,           false, &HandleAccountAddonCommand,        ""       },
-            { "create",         rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE,          true,  &HandleAccountCreateCommand,       ""       },
-            { "delete",         rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE,          true,  &HandleAccountDeleteCommand,       ""       },
-            { "email",          rbac::RBAC_PERM_COMMAND_ACCOUNT_EMAIL,           false, &HandleAccountEmailCommand,        ""       },
-            { "onlinelist",     rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST,     true,  &HandleAccountOnlineListCommand,   ""       },
-            { "lock",           rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK,            false, nullptr,        "", accountLockCommandTable },
-            { "set",            rbac::RBAC_PERM_COMMAND_ACCOUNT_SET,             true,  nullptr,         "", accountSetCommandTable },
-            { "password",       rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD,        false, &HandleAccountPasswordCommand,     ""       },
-            { "",               rbac::RBAC_PERM_COMMAND_ACCOUNT,                 false, &HandleAccountCommand,             ""       },
+        static ChatCommandTable accountCommandTable =
+        {
+            { "2fa setup",          HandleAccount2FASetupCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_SETUP,          Console::No  },
+            { "2fa remove",         HandleAccount2FARemoveCommand,      rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_REMOVE,         Console::No  },
+            { "addon",              HandleAccountAddonCommand,          rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON,              Console::No  },
+            { "create",             HandleAccountCreateCommand,         rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE,             Console::Yes },
+            { "delete",             HandleAccountDeleteCommand,         rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE,             Console::Yes },
+            { "email",              HandleAccountEmailCommand,          rbac::RBAC_PERM_COMMAND_ACCOUNT_EMAIL,              Console::No  },
+            { "onlinelist",         HandleAccountOnlineListCommand,     rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST,        Console::Yes },
+            { "lock country",       HandleAccountLockCountryCommand,    rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY,       Console::No  },
+            { "lock ip",            HandleAccountLockIpCommand,         rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP,            Console::No  },
+            { "set",                accountSetCommandTable },
+            { "password",           HandleAccountPasswordCommand,       rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD,           Console::No  },
+            { "",                   HandleAccountCommand,               rbac::RBAC_PERM_COMMAND_ACCOUNT,                    Console::No  },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "account",        rbac::RBAC_PERM_COMMAND_ACCOUNT,                 true,  nullptr,              "",  accountCommandTable },
+            { "account",            accountCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_achievement.cpp b/src/server/scripts/Commands/cs_achievement.cpp
index 51ed80da280..296e5853084 100644
--- a/src/server/scripts/Commands/cs_achievement.cpp
+++ b/src/server/scripts/Commands/cs_achievement.cpp
@@ -30,20 +30,18 @@ EndScriptData */
 #include "Player.h"
 #include "RBAC.h"
 
+using namespace Trinity::ChatCommands;
+
 class achievement_commandscript : public CommandScript
 {
 public:
     achievement_commandscript() : CommandScript("achievement_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> achievementCommandTable =
-        {
-            { "add", rbac::RBAC_PERM_COMMAND_ACHIEVEMENT_ADD, false, &HandleAchievementAddCommand, "" },
-        };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "achievement", rbac::RBAC_PERM_COMMAND_ACHIEVEMENT,  false, nullptr, "", achievementCommandTable },
+            { "achievement add", HandleAchievementAddCommand, rbac::RBAC_PERM_COMMAND_ACHIEVEMENT_ADD, Console::No },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_ahbot.cpp b/src/server/scripts/Commands/cs_ahbot.cpp
index d3c9256bc12..daeb06a7fbe 100644
--- a/src/server/scripts/Commands/cs_ahbot.cpp
+++ b/src/server/scripts/Commands/cs_ahbot.cpp
@@ -22,58 +22,58 @@
 #include "Language.h"
 #include "RBAC.h"
 
-static std::unordered_map<AuctionQuality, uint32> const ahbotQualityLangIds =
-    {
-        { AUCTION_QUALITY_GRAY,   LANG_AHBOT_QUALITY_GRAY },
-        { AUCTION_QUALITY_WHITE,  LANG_AHBOT_QUALITY_WHITE },
-        { AUCTION_QUALITY_GREEN,  LANG_AHBOT_QUALITY_GREEN },
-        { AUCTION_QUALITY_BLUE,   LANG_AHBOT_QUALITY_BLUE },
-        { AUCTION_QUALITY_PURPLE, LANG_AHBOT_QUALITY_PURPLE },
-        { AUCTION_QUALITY_ORANGE, LANG_AHBOT_QUALITY_ORANGE },
-        { AUCTION_QUALITY_YELLOW, LANG_AHBOT_QUALITY_YELLOW }
-    };
-
 using namespace Trinity::ChatCommands;
 
+static std::unordered_map<AuctionQuality, uint32> const ahbotQualityLangIds =
+{
+    { AUCTION_QUALITY_GRAY,   LANG_AHBOT_QUALITY_GRAY },
+    { AUCTION_QUALITY_WHITE,  LANG_AHBOT_QUALITY_WHITE },
+    { AUCTION_QUALITY_GREEN,  LANG_AHBOT_QUALITY_GREEN },
+    { AUCTION_QUALITY_BLUE,   LANG_AHBOT_QUALITY_BLUE },
+    { AUCTION_QUALITY_PURPLE, LANG_AHBOT_QUALITY_PURPLE },
+    { AUCTION_QUALITY_ORANGE, LANG_AHBOT_QUALITY_ORANGE },
+    { AUCTION_QUALITY_YELLOW, LANG_AHBOT_QUALITY_YELLOW }
+};
+
 class ahbot_commandscript : public CommandScript
 {
 public:
     ahbot_commandscript(): CommandScript("ahbot_commandscript") {}
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> ahbotItemsAmountCommandTable =
+        static ChatCommandTable ahbotItemsAmountCommandTable =
         {
-            { "gray",           rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY,   true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GRAY>,     "" },
-            { "white",          rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE,  true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_WHITE>,    "" },
-            { "green",          rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GREEN,  true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREEN>,    "" },
-            { "blue",           rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_BLUE,   true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_BLUE>,     "" },
-            { "purple",         rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_PURPLE, true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_PURPLE>,   "" },
-            { "orange",         rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_ORANGE, true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_ORANGE>,   "" },
-            { "yellow",         rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_YELLOW, true,  &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_YELLOW>,   "" },
-            { "",               rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS,        true,  &HandleAHBotItemsAmountCommand,                                  "" },
+            { "gray",       HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GRAY>,     rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY,       Console::Yes },
+            { "white",      HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_WHITE>,    rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE,      Console::Yes },
+            { "green",      HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREEN>,    rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GREEN,      Console::Yes },
+            { "blue",       HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_BLUE>,     rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_BLUE,       Console::Yes },
+            { "purple",     HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_PURPLE>,   rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_PURPLE,     Console::Yes },
+            { "orange",     HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_ORANGE>,   rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_ORANGE,     Console::Yes },
+            { "yellow",     HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_YELLOW>,   rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_YELLOW,     Console::Yes },
+            { "",           HandleAHBotItemsAmountCommand,                                  rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS,            Console::Yes },
         };
 
-        static std::vector<ChatCommand> ahbotItemsRatioCommandTable =
+        static ChatCommandTable ahbotItemsRatioCommandTable =
         {
-            { "alliance",       rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_ALLIANCE, true,  &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_ALLIANCE>,    "" },
-            { "horde",          rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_HORDE,    true,  &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_HORDE>,       "" },
-            { "neutral",        rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_NEUTRAL,  true,  &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_NEUTRAL>,     "" },
-            { "",               rbac::RBAC_PERM_COMMAND_AHBOT_RATIO,          true,  &HandleAHBotItemsRatioCommand,                                 "" },
+            { "alliance",   HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_ALLIANCE>,      rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_ALLIANCE,   Console::Yes },
+            { "horde",      HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_HORDE>,         rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_HORDE,      Console::Yes },
+            { "neutral",    HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_NEUTRAL>,       rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_NEUTRAL,    Console::Yes },
+            { "",           HandleAHBotItemsRatioCommand,                                   rbac::RBAC_PERM_COMMAND_AHBOT_RATIO,            Console::Yes },
         };
 
-        static std::vector<ChatCommand> ahbotCommandTable =
+        static ChatCommandTable ahbotCommandTable =
         {
-            { "items",          rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS,    true,   nullptr,                    "", ahbotItemsAmountCommandTable },
-            { "ratio",          rbac::RBAC_PERM_COMMAND_AHBOT_RATIO,    true,   nullptr,                    "", ahbotItemsRatioCommandTable },
-            { "rebuild",        rbac::RBAC_PERM_COMMAND_AHBOT_REBUILD,  true,   &HandleAHBotRebuildCommand, "" },
-            { "reload",         rbac::RBAC_PERM_COMMAND_AHBOT_RELOAD,   true,   &HandleAHBotReloadCommand,  "" },
-            { "status",         rbac::RBAC_PERM_COMMAND_AHBOT_STATUS,   true,   &HandleAHBotStatusCommand,  "" },
+            { "items",      ahbotItemsAmountCommandTable },
+            { "ratio",      ahbotItemsRatioCommandTable },
+            { "rebuild",    HandleAHBotRebuildCommand,  rbac::RBAC_PERM_COMMAND_AHBOT_REBUILD,  Console::Yes },
+            { "reload",     HandleAHBotReloadCommand,   rbac::RBAC_PERM_COMMAND_AHBOT_RELOAD,   Console::Yes },
+            { "status",     HandleAHBotStatusCommand,   rbac::RBAC_PERM_COMMAND_AHBOT_STATUS,   Console::Yes },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "ahbot",          rbac::RBAC_PERM_COMMAND_AHBOT,  false, nullptr,    "", ahbotCommandTable },
+            { "ahbot", ahbotCommandTable },
         };
 
         return commandTable;
diff --git a/src/server/scripts/Commands/cs_arena.cpp b/src/server/scripts/Commands/cs_arena.cpp
index fabc9afdb7c..58bdd00a6b2 100644
--- a/src/server/scripts/Commands/cs_arena.cpp
+++ b/src/server/scripts/Commands/cs_arena.cpp
@@ -32,25 +32,26 @@ EndScriptData */
 #include "WorldSession.h"
 
 using namespace Trinity::ChatCommands;
+
 class arena_commandscript : public CommandScript
 {
 public:
     arena_commandscript() : CommandScript("arena_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> arenaCommandTable =
-        {
-            { "create",         rbac::RBAC_PERM_COMMAND_ARENA_CREATE,   true, &HandleArenaCreateCommand,   "" },
-            { "disband",        rbac::RBAC_PERM_COMMAND_ARENA_DISBAND,  true, &HandleArenaDisbandCommand,  "" },
-            { "rename",         rbac::RBAC_PERM_COMMAND_ARENA_RENAME,   true, &HandleArenaRenameCommand,   "" },
-            { "captain",        rbac::RBAC_PERM_COMMAND_ARENA_CAPTAIN, false, &HandleArenaCaptainCommand,  "" },
-            { "info",           rbac::RBAC_PERM_COMMAND_ARENA_INFO,     true, &HandleArenaInfoCommand,     "" },
-            { "lookup",         rbac::RBAC_PERM_COMMAND_ARENA_LOOKUP,  false, &HandleArenaLookupCommand,   "" },
+        static ChatCommandTable arenaCommandTable =
+        {
+            { "create",         HandleArenaCreateCommand,   rbac::RBAC_PERM_COMMAND_ARENA_CREATE,  Console::Yes },
+            { "disband",        HandleArenaDisbandCommand,  rbac::RBAC_PERM_COMMAND_ARENA_DISBAND, Console::Yes },
+            { "rename",         HandleArenaRenameCommand,   rbac::RBAC_PERM_COMMAND_ARENA_RENAME,  Console::Yes },
+            { "captain",        HandleArenaCaptainCommand,  rbac::RBAC_PERM_COMMAND_ARENA_CAPTAIN, Console::No },
+            { "info",           HandleArenaInfoCommand,     rbac::RBAC_PERM_COMMAND_ARENA_INFO,    Console::Yes },
+            { "lookup",         HandleArenaLookupCommand,   rbac::RBAC_PERM_COMMAND_ARENA_LOOKUP,  Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "arena",          rbac::RBAC_PERM_COMMAND_ARENA,     false, nullptr,                       "", arenaCommandTable },
+            { "arena", arenaCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_ban.cpp b/src/server/scripts/Commands/cs_ban.cpp
index a960f0b79b4..2639f62e544 100644
--- a/src/server/scripts/Commands/cs_ban.cpp
+++ b/src/server/scripts/Commands/cs_ban.cpp
@@ -36,45 +36,51 @@ EndScriptData */
 #include "World.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+using namespace Trinity::ChatCommands;
+
 class ban_commandscript : public CommandScript
 {
 public:
     ban_commandscript() : CommandScript("ban_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> unbanCommandTable =
+        static ChatCommandTable unbanCommandTable =
         {
-            { "account",        rbac::RBAC_PERM_COMMAND_UNBAN_ACCOUNT,       true,  &HandleUnBanAccountCommand,          "" },
-            { "character",      rbac::RBAC_PERM_COMMAND_UNBAN_CHARACTER,     true,  &HandleUnBanCharacterCommand,        "" },
-            { "playeraccount",  rbac::RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT, true,  &HandleUnBanAccountByCharCommand,    "" },
-            { "ip",             rbac::RBAC_PERM_COMMAND_UNBAN_IP,            true,  &HandleUnBanIPCommand,               "" },
+            { "account",        HandleUnBanAccountCommand,              rbac::RBAC_PERM_COMMAND_UNBAN_ACCOUNT,          Console::Yes },
+            { "character",      HandleUnBanCharacterCommand,            rbac::RBAC_PERM_COMMAND_UNBAN_CHARACTER,        Console::Yes },
+            { "playeraccount",  HandleUnBanAccountByCharCommand,        rbac::RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT,    Console::Yes },
+            { "ip",             HandleUnBanIPCommand,                   rbac::RBAC_PERM_COMMAND_UNBAN_IP,               Console::Yes },
         };
-        static std::vector<ChatCommand> banlistCommandTable =
+        static ChatCommandTable banlistCommandTable =
         {
-            { "account",        rbac::RBAC_PERM_COMMAND_BANLIST_ACCOUNT,   true,  &HandleBanListAccountCommand,        "" },
-            { "character",      rbac::RBAC_PERM_COMMAND_BANLIST_CHARACTER, true,  &HandleBanListCharacterCommand,      "" },
-            { "ip",             rbac::RBAC_PERM_COMMAND_BANLIST_IP,        true,  &HandleBanListIPCommand,             "" },
+            { "account",        HandleBanListAccountCommand,            rbac::RBAC_PERM_COMMAND_BANLIST_ACCOUNT,        Console::Yes },
+            { "character",      HandleBanListCharacterCommand,          rbac::RBAC_PERM_COMMAND_BANLIST_CHARACTER,      Console::Yes },
+            { "ip",             HandleBanListIPCommand,                 rbac::RBAC_PERM_COMMAND_BANLIST_IP,             Console::Yes },
         };
-        static std::vector<ChatCommand> baninfoCommandTable =
+        static ChatCommandTable baninfoCommandTable =
         {
-            { "account",        rbac::RBAC_PERM_COMMAND_BANINFO_ACCOUNT,   true,  &HandleBanInfoAccountCommand,        "" },
-            { "character",      rbac::RBAC_PERM_COMMAND_BANINFO_CHARACTER, true,  &HandleBanInfoCharacterCommand,      "" },
-            { "ip",             rbac::RBAC_PERM_COMMAND_BANINFO_IP,        true,  &HandleBanInfoIPCommand,             "" },
+            { "account",        HandleBanInfoAccountCommand,            rbac::RBAC_PERM_COMMAND_BANINFO_ACCOUNT,        Console::Yes },
+            { "character",      HandleBanInfoCharacterCommand,          rbac::RBAC_PERM_COMMAND_BANINFO_CHARACTER,      Console::Yes },
+            { "ip",             HandleBanInfoIPCommand,                 rbac::RBAC_PERM_COMMAND_BANINFO_IP,             Console::Yes },
         };
-        static std::vector<ChatCommand> banCommandTable =
+        static ChatCommandTable banCommandTable =
         {
-            { "account",        rbac::RBAC_PERM_COMMAND_BAN_ACCOUNT,       true,  &HandleBanAccountCommand,            "" },
-            { "character",      rbac::RBAC_PERM_COMMAND_BAN_CHARACTER,     true,  &HandleBanCharacterCommand,          "" },
-            { "playeraccount",  rbac::RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT, true,  &HandleBanAccountByCharCommand,      "" },
-            { "ip",             rbac::RBAC_PERM_COMMAND_BAN_IP,            true,  &HandleBanIPCommand,                 "" },
+            { "account",        HandleBanAccountCommand,                rbac::RBAC_PERM_COMMAND_BAN_ACCOUNT,            Console::Yes },
+            { "character",      HandleBanCharacterCommand,              rbac::RBAC_PERM_COMMAND_BAN_CHARACTER,          Console::Yes },
+            { "playeraccount",  HandleBanAccountByCharCommand,          rbac::RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT,      Console::Yes },
+            { "ip",             HandleBanIPCommand,                     rbac::RBAC_PERM_COMMAND_BAN_IP,                 Console::Yes },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "ban",            rbac::RBAC_PERM_COMMAND_BAN,     true,  nullptr,                                "", banCommandTable },
-            { "baninfo",        rbac::RBAC_PERM_COMMAND_BANINFO, true,  nullptr,                                "", baninfoCommandTable },
-            { "banlist",        rbac::RBAC_PERM_COMMAND_BANLIST, true,  nullptr,                                "", banlistCommandTable },
-            { "unban",          rbac::RBAC_PERM_COMMAND_UNBAN,   true,  nullptr,                                "", unbanCommandTable },
+            { "ban",        banCommandTable },
+            { "baninfo",    baninfoCommandTable },
+            { "banlist",    banlistCommandTable },
+            { "unban",      unbanCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_battlenet_account.cpp b/src/server/scripts/Commands/cs_battlenet_account.cpp
index 8eae5a7b411..3abab0ae78a 100644
--- a/src/server/scripts/Commands/cs_battlenet_account.cpp
+++ b/src/server/scripts/Commands/cs_battlenet_account.cpp
@@ -30,39 +30,38 @@
 #include "Util.h"
 #include "WorldSession.h"
 
+using namespace Trinity::ChatCommands;
+
 class battlenet_account_commandscript : public CommandScript
 {
 public:
     battlenet_account_commandscript() : CommandScript("battlenet_account_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> accountSetCommandTable =
+        static ChatCommandTable accountSetCommandTable =
         {
-            { "password", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD, true,  &HandleAccountSetPasswordCommand, "" },
+            { "password",          HandleAccountSetPasswordCommand,rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD,       Console::Yes },
         };
-
-        static std::vector<ChatCommand> accountLockCommandTable =
+        static ChatCommandTable accountLockCommandTable =
         {
-            { "country", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY, true,  &HandleAccountLockCountryCommand, "" },
-            { "ip",      rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP,      true,  &HandleAccountLockIpCommand,      "" },
+            { "country",           HandleAccountLockCountryCommand,rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY,       Console::Yes },
+            { "ip",                HandleAccountLockIpCommand,     rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP,            Console::Yes },
         };
-
-        static std::vector<ChatCommand> accountCommandTable =
+        static ChatCommandTable accountCommandTable =
         {
-            { "create",            rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE,             true,  &HandleAccountCreateCommand,     ""                          },
-            { "gameaccountcreate", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE_GAME,        true,  &HandleGameAccountCreateCommand, ""                          },
-            { "lock",              rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT,                    false, nullptr,                         "", accountLockCommandTable },
-            { "set",               rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET,                true,  nullptr,                         "", accountSetCommandTable  },
-            { "password",          rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD,           false, &HandleAccountPasswordCommand,   ""                          },
-            { "link",              rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK,               true,  &HandleAccountLinkCommand,       ""                          },
-            { "unlink",            rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK,             true,  &HandleAccountUnlinkCommand,     ""                          },
-            { "listgameaccounts",  rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LIST_GAME_ACCOUTNS, true,  &HandleListGameAccountsCommand,  ""                          }
+            { "create",            HandleAccountCreateCommand,     rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE,             Console::Yes },
+            { "gameaccountcreate", HandleGameAccountCreateCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE_GAME,        Console::Yes },
+            { "lock",              accountLockCommandTable },
+            { "set",               accountSetCommandTable },
+            { "password",          HandleAccountPasswordCommand,   rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD,           Console::No  },
+            { "link",              HandleAccountLinkCommand,       rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK,               Console::Yes },
+            { "unlink",            HandleAccountUnlinkCommand,     rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK,             Console::Yes },
+            { "listgameaccounts",  HandleListGameAccountsCommand,  rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LIST_GAME_ACCOUTNS, Console::Yes }
         };
-
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "bnetaccount", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT, true,  nullptr, "", accountCommandTable },
+            { "bnetaccount",       accountCommandTable },
         };
 
         return commandTable;
@@ -117,111 +116,59 @@ public:
     }
 
     // Sets country lock on own account
-    static bool HandleAccountLockCountryCommand(ChatHandler* handler, char const* args)
+    static bool HandleAccountLockCountryCommand(ChatHandler* handler, bool state)
     {
-        if (!*args)
-        {
-            handler->SendSysMessage(LANG_USE_BOL);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        std::string param = (char*)args;
-        if (!param.empty())
+        if (state)
         {
-            if (param == "on")
-            {
-                if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(handler->GetSession()->GetRemoteAddress()))
-                {
-                    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
-                    stmt->setString(0, location->CountryCode);
-                    stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
-                    LoginDatabase.Execute(stmt);
-                    handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
-                }
-                else
-                {
-                    handler->PSendSysMessage("IP2Location] No information");
-                    TC_LOG_DEBUG("server.bnetserver", "IP2Location] No information");
-                }
-            }
-            else if (param == "off")
+            if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(handler->GetSession()->GetRemoteAddress()))
             {
                 LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
-                stmt->setString(0, "00");
+                stmt->setString(0, location->CountryCode);
                 stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
                 LoginDatabase.Execute(stmt);
-                handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
-            }
-            return true;
-        }
-
-        handler->SendSysMessage(LANG_USE_BOL);
-        handler->SetSentErrorMessage(true);
-        return false;
-    }
-
-    // Sets ip lock on own account
-    static bool HandleAccountLockIpCommand(ChatHandler* handler, char const* args)
-    {
-        if (!*args)
-        {
-            handler->SendSysMessage(LANG_USE_BOL);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        std::string param = (char*)args;
-
-        if (!param.empty())
-        {
-            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK);
-
-            if (param == "on")
-            {
-                stmt->setBool(0, true);                                     // locked
                 handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
             }
-            else if (param == "off")
+            else
             {
-                stmt->setBool(0, false);                                    // unlocked
-                handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
+                handler->PSendSysMessage("IP2Location] No information");
+                TC_LOG_DEBUG("server.bnetserver", "IP2Location] No information");
             }
-
+        }
+        else
+        {
+            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
+            stmt->setString(0, "00");
             stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
-
             LoginDatabase.Execute(stmt);
-            return true;
+            handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
         }
-
-        handler->SendSysMessage(LANG_USE_BOL);
-        handler->SetSentErrorMessage(true);
-        return false;
+        return true;
     }
 
-    static bool HandleAccountPasswordCommand(ChatHandler* handler, char const* args)
+    // Sets ip lock on own account
+    static bool HandleAccountLockIpCommand(ChatHandler* handler, bool state)
     {
-        // If no args are given at all, we can return false right away.
-        if (!*args)
+        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK);
+
+        if (state)
         {
-            handler->SendSysMessage(LANG_CMD_SYNTAX);
-            handler->SetSentErrorMessage(true);
-            return false;
+            stmt->setBool(0, true);                                     // locked
+            handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
         }
-
-        // Command is supposed to be: .account password [$oldpassword] [$newpassword] [$newpasswordconfirmation] [$emailconfirmation]
-        char* oldPassword = strtok((char*)args, " ");       // This extracts [$oldpassword]
-        char* newPassword = strtok(nullptr, " ");              // This extracts [$newpassword]
-        char* passwordConfirmation = strtok(nullptr, " ");     // This extracts [$newpasswordconfirmation]
-
-        //Is any of those variables missing for any reason ? We return false.
-        if (!oldPassword || !newPassword || !passwordConfirmation)
+        else
         {
-            handler->SendSysMessage(LANG_CMD_SYNTAX);
-            handler->SetSentErrorMessage(true);
-            return false;
+            stmt->setBool(0, false);                                    // unlocked
+            handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
         }
 
+        stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
+
+        LoginDatabase.Execute(stmt);
+        return true;
+    }
+
+    static bool HandleAccountPasswordCommand(ChatHandler* handler, std::string const& oldPassword, std::string const& newPassword, std::string const& passwordConfirmation)
+    {
         // We compare the old, saved password to the entered old password - no chance for the unauthorized.
         if (!Battlenet::AccountMgr::CheckPassword(handler->GetSession()->GetBattlenetAccountId(), std::string(oldPassword)))
         {
@@ -234,7 +181,7 @@ public:
         }
 
         // Making sure that newly entered password is correctly entered.
-        if (strcmp(newPassword, passwordConfirmation) != 0)
+        if (newPassword != passwordConfirmation)
         {
             handler->SendSysMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
             handler->SetSentErrorMessage(true);
@@ -265,24 +212,8 @@ public:
     }
 
     /// Set password for account
-    static bool HandleAccountSetPasswordCommand(ChatHandler* handler, char const* args)
+    static bool HandleAccountSetPasswordCommand(ChatHandler* handler, std::string accountName, std::string const& password, std::string const& passwordConfirmation)
     {
-        if (!*args)
-        {
-            handler->SendSysMessage(LANG_CMD_SYNTAX);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        ///- Get the command line arguments
-        char* account = strtok((char*)args, " ");
-        char* password = strtok(nullptr, " ");
-        char* passwordConfirmation = strtok(nullptr, " ");
-
-        if (!account || !password || !passwordConfirmation)
-            return false;
-
-        std::string accountName = account;
         if (!Utf8ToUpperOnlyLatin(accountName))
         {
             handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
@@ -298,7 +229,7 @@ public:
             return false;
         }
 
-        if (strcmp(password, passwordConfirmation))
+        if (password != passwordConfirmation)
         {
             handler->SendSysMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
             handler->SetSentErrorMessage(true);
@@ -306,7 +237,6 @@ public:
         }
 
         AccountOpResult result = Battlenet::AccountMgr::ChangePassword(targetAccountId, password);
-
         switch (result)
         {
             case AccountOpResult::AOR_OK:
@@ -348,17 +278,8 @@ public:
         return true;
     }
 
-    static bool HandleAccountUnlinkCommand(ChatHandler* handler, char const* args)
+    static bool HandleAccountUnlinkCommand(ChatHandler* handler, std::string const& gameAccountName)
     {
-        if (!*args)
-        {
-            handler->SendSysMessage(LANG_CMD_SYNTAX);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        std::string gameAccountName = args;
-
         switch (Battlenet::AccountMgr::UnlinkGameAccount(gameAccountName))
         {
             case AccountOpResult::AOR_OK:
@@ -379,16 +300,8 @@ public:
         return true;
     }
 
-    static bool HandleGameAccountCreateCommand(ChatHandler* handler, char const* args)
+    static bool HandleGameAccountCreateCommand(ChatHandler* handler, std::string const& bnetAccountName)
     {
-        if (!*args)
-        {
-            handler->SendSysMessage(LANG_CMD_SYNTAX);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        std::string bnetAccountName = args;
         uint32 accountId = Battlenet::AccountMgr::GetId(bnetAccountName);
         if (!accountId)
         {
@@ -440,14 +353,10 @@ public:
         return true;
     }
 
-    static bool HandleListGameAccountsCommand(ChatHandler* handler, char const* args)
+    static bool HandleListGameAccountsCommand(ChatHandler* handler, std::string const& battlenetAccountName)
     {
-        if (!*args)
-            return false;
-
-        char* battlenetAccountName = strtok((char*)args, " ");
         LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_GAME_ACCOUNT_LIST_SMALL);
-        stmt->setString(0, battlenetAccountName);
+        stmt->setStringView(0, battlenetAccountName);
         if (PreparedQueryResult accountList = LoginDatabase.Query(stmt))
         {
             auto formatDisplayName = [](char const* name) -> std::string
diff --git a/src/server/scripts/Commands/cs_bf.cpp b/src/server/scripts/Commands/cs_bf.cpp
index 2219c912d47..f51dc57cf36 100644
--- a/src/server/scripts/Commands/cs_bf.cpp
+++ b/src/server/scripts/Commands/cs_bf.cpp
@@ -28,24 +28,26 @@ EndScriptData */
 #include "ChatCommand.h"
 #include "RBAC.h"
 
+using namespace Trinity::ChatCommands;
+
 class bf_commandscript : public CommandScript
 {
 public:
     bf_commandscript() : CommandScript("bf_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> battlefieldcommandTable =
+        static ChatCommandTable battlefieldcommandTable =
         {
-            { "start",          rbac::RBAC_PERM_COMMAND_BF_START,  false, &HandleBattlefieldStart,  "" },
-            { "stop",           rbac::RBAC_PERM_COMMAND_BF_STOP,   false, &HandleBattlefieldEnd,    "" },
-            { "switch",         rbac::RBAC_PERM_COMMAND_BF_SWITCH, false, &HandleBattlefieldSwitch, "" },
-            { "timer",          rbac::RBAC_PERM_COMMAND_BF_TIMER,  false, &HandleBattlefieldTimer,  "" },
-            { "enable",         rbac::RBAC_PERM_COMMAND_BF_ENABLE, false, &HandleBattlefieldEnable, "" },
+            { "start",      HandleBattlefieldStart,  rbac::RBAC_PERM_COMMAND_BF_START,  Console::No },
+            { "stop",       HandleBattlefieldEnd,    rbac::RBAC_PERM_COMMAND_BF_STOP,   Console::No },
+            { "switch",     HandleBattlefieldSwitch, rbac::RBAC_PERM_COMMAND_BF_SWITCH, Console::No },
+            { "timer",      HandleBattlefieldTimer,  rbac::RBAC_PERM_COMMAND_BF_TIMER,  Console::No },
+            { "enable",     HandleBattlefieldEnable, rbac::RBAC_PERM_COMMAND_BF_ENABLE, Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "bf",             rbac::RBAC_PERM_COMMAND_BF,        false, nullptr,                     "", battlefieldcommandTable },
+            { "bf", battlefieldcommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_cast.cpp b/src/server/scripts/Commands/cs_cast.cpp
index 633099077e8..d4108921b4e 100644
--- a/src/server/scripts/Commands/cs_cast.cpp
+++ b/src/server/scripts/Commands/cs_cast.cpp
@@ -34,25 +34,26 @@ EndScriptData */
 #include "WorldSession.h"
 
 using namespace Trinity::ChatCommands;
+
 class cast_commandscript : public CommandScript
 {
 public:
     cast_commandscript() : CommandScript("cast_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> castCommandTable =
+        static ChatCommandTable castCommandTable =
         {
-            { "back",   rbac::RBAC_PERM_COMMAND_CAST_BACK,   false, &HandleCastBackCommand,  "" },
-            { "dist",   rbac::RBAC_PERM_COMMAND_CAST_DIST,   false, &HandleCastDistCommand,  "" },
-            { "self",   rbac::RBAC_PERM_COMMAND_CAST_SELF,   false, &HandleCastSelfCommand,  "" },
-            { "target", rbac::RBAC_PERM_COMMAND_CAST_TARGET, false, &HandleCastTargetCommad, "" },
-            { "dest",   rbac::RBAC_PERM_COMMAND_CAST_DEST,   false, &HandleCastDestCommand,  "" },
-            { "",       rbac::RBAC_PERM_COMMAND_CAST,        false, &HandleCastCommand,      "" },
+            { "back",   HandleCastBackCommand,  rbac::RBAC_PERM_COMMAND_CAST_BACK,   Console::No },
+            { "dist",   HandleCastDistCommand,  rbac::RBAC_PERM_COMMAND_CAST_DIST,   Console::No },
+            { "self",   HandleCastSelfCommand,  rbac::RBAC_PERM_COMMAND_CAST_SELF,   Console::No },
+            { "target", HandleCastTargetCommad, rbac::RBAC_PERM_COMMAND_CAST_TARGET, Console::No },
+            { "dest",   HandleCastDestCommand,  rbac::RBAC_PERM_COMMAND_CAST_DEST,   Console::No },
+            { "",       HandleCastCommand,      rbac::RBAC_PERM_COMMAND_CAST,        Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "cast",   rbac::RBAC_PERM_COMMAND_CAST,        false, nullptr,                    "", castCommandTable },
+            { "cast", castCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_character.cpp b/src/server/scripts/Commands/cs_character.cpp
index 4a6d872886f..a0623dc015d 100644
--- a/src/server/scripts/Commands/cs_character.cpp
+++ b/src/server/scripts/Commands/cs_character.cpp
@@ -39,46 +39,47 @@ EndScriptData */
 #include <sstream>
 
 using namespace Trinity::ChatCommands;
+
 class character_commandscript : public CommandScript
 {
 public:
     character_commandscript() : CommandScript("character_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> pdumpCommandTable =
+        static ChatCommandTable pdumpCommandTable =
         {
-            { "copy",          rbac::RBAC_PERM_COMMAND_PDUMP_COPY,                true,  &HandlePDumpCopyCommand,               "" },
-            { "load",          rbac::RBAC_PERM_COMMAND_PDUMP_LOAD,                true,  &HandlePDumpLoadCommand,               "" },
-            { "write",         rbac::RBAC_PERM_COMMAND_PDUMP_WRITE,               true,  &HandlePDumpWriteCommand,              "" },
+            { "copy",          HandlePDumpCopyCommand,               rbac::RBAC_PERM_COMMAND_PDUMP_COPY,                Console::Yes },
+            { "load",          HandlePDumpLoadCommand,               rbac::RBAC_PERM_COMMAND_PDUMP_LOAD,                Console::Yes },
+            { "write",         HandlePDumpWriteCommand,              rbac::RBAC_PERM_COMMAND_PDUMP_WRITE,               Console::Yes },
         };
-        static std::vector<ChatCommand> characterDeletedCommandTable =
+        static ChatCommandTable characterDeletedCommandTable =
         {
-            { "delete",        rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE,  true,  &HandleCharacterDeletedDeleteCommand,  "" },
-            { "list",          rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST,    true,  &HandleCharacterDeletedListCommand,    "" },
-            { "restore",       rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE, true,  &HandleCharacterDeletedRestoreCommand, "" },
-            { "old",           rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_OLD,     true,  &HandleCharacterDeletedOldCommand,     "" },
+            { "delete",        HandleCharacterDeletedDeleteCommand,  rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE,  Console::Yes },
+            { "list",          HandleCharacterDeletedListCommand,    rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST,    Console::Yes },
+            { "restore",       HandleCharacterDeletedRestoreCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE, Console::Yes },
+            { "old",           HandleCharacterDeletedOldCommand,     rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_OLD,     Console::Yes },
         };
 
-        static std::vector<ChatCommand> characterCommandTable =
-        {
-            { "customize",     rbac::RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE,       true,  &HandleCharacterCustomizeCommand,      "", },
-            { "changefaction", rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION,   true,  &HandleCharacterChangeFactionCommand,  "", },
-            { "changerace",    rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGERACE,      true,  &HandleCharacterChangeRaceCommand,     "", },
-            { "changeaccount", rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEACCOUNT,   true,  &HandleCharacterChangeAccountCommand,  "", },
-            { "deleted",       rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED,         true,  nullptr,                               "", characterDeletedCommandTable },
-            { "erase",         rbac::RBAC_PERM_COMMAND_CHARACTER_ERASE,           true,  &HandleCharacterEraseCommand,          "", },
-            { "level",         rbac::RBAC_PERM_COMMAND_CHARACTER_LEVEL,           true,  &HandleLevelUpCommand,                 "", },
-            { "rename",        rbac::RBAC_PERM_COMMAND_CHARACTER_RENAME,          true,  &HandleCharacterRenameCommand,         "", },
-            { "reputation",    rbac::RBAC_PERM_COMMAND_CHARACTER_REPUTATION,      true,  &HandleCharacterReputationCommand,     "", },
-            { "titles",        rbac::RBAC_PERM_COMMAND_CHARACTER_TITLES,          true,  &HandleCharacterTitlesCommand,         "", },
+        static ChatCommandTable characterCommandTable =
+        {
+            { "customize",     HandleCharacterCustomizeCommand,      rbac::RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE,       Console::Yes },
+            { "changefaction", HandleCharacterChangeFactionCommand,  rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION,   Console::Yes },
+            { "changerace",    HandleCharacterChangeRaceCommand,     rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGERACE,      Console::Yes },
+            { "changeaccount", HandleCharacterChangeAccountCommand,  rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEACCOUNT,   Console::Yes },
+            { "deleted",       characterDeletedCommandTable },
+            { "erase",         HandleCharacterEraseCommand,          rbac::RBAC_PERM_COMMAND_CHARACTER_ERASE,           Console::Yes },
+            { "level",         HandleLevelUpCommand,                 rbac::RBAC_PERM_COMMAND_CHARACTER_LEVEL,           Console::Yes },
+            { "rename",        HandleCharacterRenameCommand,         rbac::RBAC_PERM_COMMAND_CHARACTER_RENAME,          Console::Yes },
+            { "reputation",    HandleCharacterReputationCommand,     rbac::RBAC_PERM_COMMAND_CHARACTER_REPUTATION,      Console::Yes },
+            { "titles",        HandleCharacterTitlesCommand,         rbac::RBAC_PERM_COMMAND_CHARACTER_TITLES,          Console::Yes },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "character",     rbac::RBAC_PERM_COMMAND_CHARACTER,                 true,  nullptr,                               "", characterCommandTable },
-            { "levelup",       rbac::RBAC_PERM_COMMAND_LEVELUP,                   false, &HandleLevelUpCommand,                 "" },
-            { "pdump",         rbac::RBAC_PERM_COMMAND_PDUMP,                     true,  nullptr,                               "", pdumpCommandTable },
+            { "character", characterCommandTable },
+            { "levelup",       HandleLevelUpCommand,                 rbac::RBAC_PERM_COMMAND_LEVELUP,                   Console::No },
+            { "pdump", pdumpCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_cheat.cpp b/src/server/scripts/Commands/cs_cheat.cpp
index 279821bb6d7..8187f27a773 100644
--- a/src/server/scripts/Commands/cs_cheat.cpp
+++ b/src/server/scripts/Commands/cs_cheat.cpp
@@ -30,29 +30,31 @@ EndScriptData */
 #include "RBAC.h"
 #include "WorldSession.h"
 
+using namespace Trinity::ChatCommands;
+
 class cheat_commandscript : public CommandScript
 {
 public:
     cheat_commandscript() : CommandScript("cheat_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> cheatCommandTable =
+        static ChatCommandTable cheatCommandTable =
         {
-            { "god",            rbac::RBAC_PERM_COMMAND_CHEAT_GOD,       false, &HandleGodModeCheatCommand,   "" },
-            { "casttime",       rbac::RBAC_PERM_COMMAND_CHEAT_CASTTIME,  false, &HandleCasttimeCheatCommand,  "" },
-            { "cooldown",       rbac::RBAC_PERM_COMMAND_CHEAT_COOLDOWN,  false, &HandleCoolDownCheatCommand,  "" },
-            { "power",          rbac::RBAC_PERM_COMMAND_CHEAT_POWER,     false, &HandlePowerCheatCommand,     "" },
-            { "waterwalk",      rbac::RBAC_PERM_COMMAND_CHEAT_WATERWALK, false, &HandleWaterWalkCheatCommand, "" },
-            { "status",         rbac::RBAC_PERM_COMMAND_CHEAT_STATUS,    false, &HandleCheatStatusCommand,    "" },
-            { "taxi",           rbac::RBAC_PERM_COMMAND_CHEAT_TAXI,      false, &HandleTaxiCheatCommand,      "" },
-            { "explore",        rbac::RBAC_PERM_COMMAND_CHEAT_EXPLORE,   false, &HandleExploreCheatCommand,   "" },
+            { "god",            HandleGodModeCheatCommand,   rbac::RBAC_PERM_COMMAND_CHEAT_GOD,       Console::No },
+            { "casttime",       HandleCasttimeCheatCommand,  rbac::RBAC_PERM_COMMAND_CHEAT_CASTTIME,  Console::No },
+            { "cooldown",       HandleCoolDownCheatCommand,  rbac::RBAC_PERM_COMMAND_CHEAT_COOLDOWN,  Console::No },
+            { "power",          HandlePowerCheatCommand,     rbac::RBAC_PERM_COMMAND_CHEAT_POWER,     Console::No },
+            { "waterwalk",      HandleWaterWalkCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_WATERWALK, Console::No },
+            { "status",         HandleCheatStatusCommand,    rbac::RBAC_PERM_COMMAND_CHEAT_STATUS,    Console::No },
+            { "taxi",           HandleTaxiCheatCommand,      rbac::RBAC_PERM_COMMAND_CHEAT_TAXI,      Console::No },
+            { "explore",        HandleExploreCheatCommand,   rbac::RBAC_PERM_COMMAND_CHEAT_EXPLORE,   Console::No },
 
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "cheat",          rbac::RBAC_PERM_COMMAND_CHEAT, false, nullptr, "", cheatCommandTable },
+            { "cheat", cheatCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_debug.cpp b/src/server/scripts/Commands/cs_debug.cpp
index 127b3249cd3..919a78ff73e 100644
--- a/src/server/scripts/Commands/cs_debug.cpp
+++ b/src/server/scripts/Commands/cs_debug.cpp
@@ -61,91 +61,79 @@ EndScriptData */
 #include <sstream>
 
 using namespace Trinity::ChatCommands;
+
 class debug_commandscript : public CommandScript
 {
 public:
     debug_commandscript() : CommandScript("debug_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> debugPlayCommandTable =
-        {
-            { "cinematic",     rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_CINEMATIC, false, &HandleDebugPlayCinematicCommand,   "" },
-            { "movie",         rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_MOVIE,     false, &HandleDebugPlayMovieCommand,       "" },
-            { "sound",         rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_SOUND,     false, &HandleDebugPlaySoundCommand,       "" },
-            { "music",         rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_MUSIC,     false, &HandleDebugPlayMusicCommand,       "" },
-        };
-        static std::vector<ChatCommand> debugSendCommandTable =
-        {
-            { "buyerror",      rbac::RBAC_PERM_COMMAND_DEBUG_SEND_BUYERROR,      false, &HandleDebugSendBuyErrorCommand,        "" },
-            { "channelnotify", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_CHANNELNOTIFY, false, &HandleDebugSendChannelNotifyCommand,   "" },
-            { "chatmessage",   rbac::RBAC_PERM_COMMAND_DEBUG_SEND_CHATMESSAGE,   false, &HandleDebugSendChatMsgCommand,         "" },
-            { "equiperror",    rbac::RBAC_PERM_COMMAND_DEBUG_SEND_EQUIPERROR,    false, &HandleDebugSendEquipErrorCommand,      "" },
-            { "largepacket",   rbac::RBAC_PERM_COMMAND_DEBUG_SEND_LARGEPACKET,   false, &HandleDebugSendLargePacketCommand,     "" },
-            { "opcode",        rbac::RBAC_PERM_COMMAND_DEBUG_SEND_OPCODE,        false, &HandleDebugSendOpcodeCommand,          "" },
-            { "qpartymsg",     rbac::RBAC_PERM_COMMAND_DEBUG_SEND_QPARTYMSG,     false, &HandleDebugSendQuestPartyMsgCommand,   "" },
-            { "qinvalidmsg",   rbac::RBAC_PERM_COMMAND_DEBUG_SEND_QINVALIDMSG,   false, &HandleDebugSendQuestInvalidMsgCommand, "" },
-            { "sellerror",     rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SELLERROR,     false, &HandleDebugSendSellErrorCommand,       "" },
-            { "setphaseshift", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SETPHASESHIFT, false, &HandleDebugSendSetPhaseShiftCommand,   "" },
-            { "spellfail",     rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SPELLFAIL,     false, &HandleDebugSendSpellFailCommand,       "" },
-            { "playerchoice",  rbac::RBAC_PERM_COMMAND_DEBUG_SEND_PLAYER_CHOICE, false, &HandleDebugSendPlayerChoiceCommand,    "" },
-        };
-        static std::vector<ChatCommand> debugPvpCommandTable =
-        {
-            { "warmode",       rbac::RBAC_PERM_COMMAND_DEBUG,                    false, &HandleDebugWarModeFactionBalanceCommand, "" },
-        };
-        static std::vector<ChatCommand> debugAsanCommandTable =
+        static ChatCommandTable debugPlayCommandTable =
         {
-            { "memoryleak",    rbac::RBAC_PERM_COMMAND_DEBUG_ASAN,               true,  &HandleDebugMemoryLeak,         "" },
-            { "outofbounds",   rbac::RBAC_PERM_COMMAND_DEBUG_ASAN,               true,  &HandleDebugOutOfBounds,        "" },
+            { "cinematic",          HandleDebugPlayCinematicCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,  Console::No },
+            { "movie",              HandleDebugPlayMovieCommand,            rbac::RBAC_PERM_COMMAND_DEBUG,  Console::No },
+            { "sound",              HandleDebugPlaySoundCommand,            rbac::RBAC_PERM_COMMAND_DEBUG,  Console::No },
+            { "music",              HandleDebugPlayMusicCommand,            rbac::RBAC_PERM_COMMAND_DEBUG,  Console::No },
         };
-        static std::vector<ChatCommand> debugWardenCommandTable =
-        {
-            { "force",         rbac::RBAC_PERM_COMMAND_DEBUG,                    true,  &HandleDebugWardenForce,        "" }
+        static ChatCommandTable debugSendCommandTable =
+        {
+            { "buyerror",           HandleDebugSendBuyErrorCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "channelnotify",      HandleDebugSendChannelNotifyCommand,   rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "chatmessage",        HandleDebugSendChatMsgCommand,         rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "equiperror",         HandleDebugSendEquipErrorCommand,      rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "largepacket",        HandleDebugSendLargePacketCommand,     rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "opcode",             HandleDebugSendOpcodeCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "qpartymsg",          HandleDebugSendQuestPartyMsgCommand,   rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "qinvalidmsg",        HandleDebugSendQuestInvalidMsgCommand, rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "sellerror",          HandleDebugSendSellErrorCommand,       rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "setphaseshift",      HandleDebugSendSetPhaseShiftCommand,   rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "spellfail",          HandleDebugSendSpellFailCommand,       rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "playerchoice",       HandleDebugSendPlayerChoiceCommand,    rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
         };
-        static std::vector<ChatCommand> debugCommandTable =
-        {
-            { "threat",        rbac::RBAC_PERM_COMMAND_DEBUG_THREAT,        false, &HandleDebugThreatListCommand,       "" },
-            { "threatinfo",    rbac::RBAC_PERM_COMMAND_DEBUG_THREATINFO,    false, &HandleDebugThreatInfoCommand,       "" },
-            { "combat",        rbac::RBAC_PERM_COMMAND_DEBUG_COMBAT,        false, &HandleDebugCombatListCommand,       "" },
-            { "anim",          rbac::RBAC_PERM_COMMAND_DEBUG_ANIM,          false, &HandleDebugAnimCommand,             "" },
-            { "arena",         rbac::RBAC_PERM_COMMAND_DEBUG_ARENA,         true,  &HandleDebugArenaCommand,            "" },
-            { "bg",            rbac::RBAC_PERM_COMMAND_DEBUG_BG,            true,  &HandleDebugBattlegroundCommand,     "" },
-            { "getitemstate",  rbac::RBAC_PERM_COMMAND_DEBUG_GETITEMSTATE,  false, &HandleDebugGetItemStateCommand,     "" },
-            { "lootrecipient", rbac::RBAC_PERM_COMMAND_DEBUG_LOOTRECIPIENT, false, &HandleDebugGetLootRecipientCommand, "" },
-            { "play",          rbac::RBAC_PERM_COMMAND_DEBUG_PLAY,          false, nullptr,                             "", debugPlayCommandTable },
-            { "send",          rbac::RBAC_PERM_COMMAND_DEBUG_SEND,          false, nullptr,                             "", debugSendCommandTable },
-            { "setaurastate",  rbac::RBAC_PERM_COMMAND_DEBUG_SETAURASTATE,  false, &HandleDebugSetAuraStateCommand,     "" },
-            { "spawnvehicle",  rbac::RBAC_PERM_COMMAND_DEBUG_SPAWNVEHICLE,  false, &HandleDebugSpawnVehicleCommand,     "" },
-            { "entervehicle",  rbac::RBAC_PERM_COMMAND_DEBUG_ENTERVEHICLE,  false, &HandleDebugEnterVehicleCommand,     "" },
-            { "worldstate",    rbac::RBAC_PERM_COMMAND_DEBUG_WORLDSTATE,    false, &HandleDebugUpdateWorldStateCommand, "" },
-            { "itemexpire",    rbac::RBAC_PERM_COMMAND_DEBUG_ITEMEXPIRE,    false, &HandleDebugItemExpireCommand,       "" },
-            { "areatriggers",  rbac::RBAC_PERM_COMMAND_DEBUG_AREATRIGGERS,  false, &HandleDebugAreaTriggersCommand,     "" },
-            { "los",           rbac::RBAC_PERM_COMMAND_DEBUG_LOS,           false, &HandleDebugLoSCommand,              "" },
-            { "moveflags",     rbac::RBAC_PERM_COMMAND_DEBUG_MOVEFLAGS,     false, &HandleDebugMoveflagsCommand,        "" },
-            { "transport",     rbac::RBAC_PERM_COMMAND_DEBUG_TRANSPORT,     false, &HandleDebugTransportCommand,        "" },
-            { "loadcells",     rbac::RBAC_PERM_COMMAND_DEBUG_LOADCELLS,     false, &HandleDebugLoadCellsCommand,        "",},
-            { "phase",         rbac::RBAC_PERM_COMMAND_DEBUG_PHASE,         false, &HandleDebugPhaseCommand,            "" },
-            { "boundary",      rbac::RBAC_PERM_COMMAND_DEBUG_BOUNDARY,      false, &HandleDebugBoundaryCommand,         "" },
-            { "raidreset",     rbac::RBAC_PERM_COMMAND_INSTANCE_UNBIND,     false, &HandleDebugRaidResetCommand,        "" },
-            { "neargraveyard", rbac::RBAC_PERM_COMMAND_NEARGRAVEYARD,       false, &HandleDebugNearGraveyard,           "" },
-            { "instancespawn", rbac::RBAC_PERM_COMMAND_DEBUG_INSTANCESPAWN, false, &HandleDebugInstanceSpawns,          "" },
-            { "conversation" , rbac::RBAC_PERM_COMMAND_DEBUG_CONVERSATION,  false, &HandleDebugConversationCommand,     "" },
-            { "worldstate" ,   rbac::RBAC_PERM_COMMAND_DEBUG,               false, &HandleDebugWorldStateCommand,       "" },
-            { "wsexpression" , rbac::RBAC_PERM_COMMAND_DEBUG,               false, &HandleDebugWSExpressionCommand,     "" },
-            { "pvp",           rbac::RBAC_PERM_COMMAND_DEBUG,               false, nullptr,                             "", debugPvpCommandTable },
-            { "dummy",         rbac::RBAC_PERM_COMMAND_DEBUG_DUMMY,         false, &HandleDebugDummyCommand,            "" },
-            { "asan",          rbac::RBAC_PERM_COMMAND_DEBUG_ASAN,          true,  nullptr,                             "", debugAsanCommandTable },
-            { "guidlimits",    rbac::RBAC_PERM_COMMAND_DEBUG,               true,  &HandleDebugGuidLimitsCommand,       "" },
-            { "objectcount",   rbac::RBAC_PERM_COMMAND_DEBUG,               true,  &HandleDebugObjectCountCommand,      "" },
-            { "questreset",    rbac::RBAC_PERM_COMMAND_DEBUG_QUESTRESET,    true,  &HandleDebugQuestResetCommand,       "" },
-            { "warden",        rbac::RBAC_PERM_COMMAND_DEBUG,               true,  nullptr,                             "", debugWardenCommandTable },
-            { "personalclone", rbac::RBAC_PERM_COMMAND_DEBUG,               false, &HandleDebugBecomePersonalClone,     "" }
+        static ChatCommandTable debugCommandTable =
+        {
+            { "threat",             HandleDebugThreatListCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "threatinfo",         HandleDebugThreatInfoCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "combat",             HandleDebugCombatListCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "anim",               HandleDebugAnimCommand,                rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "arena",              HandleDebugArenaCommand,               rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "bg",                 HandleDebugBattlegroundCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "getitemstate",       HandleDebugGetItemStateCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "lootrecipient",      HandleDebugGetLootRecipientCommand,    rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "play",               debugPlayCommandTable },
+            { "send",               debugSendCommandTable },
+            { "setaurastate",       HandleDebugSetAuraStateCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "spawnvehicle",       HandleDebugSpawnVehicleCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "entervehicle",       HandleDebugEnterVehicleCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "worldstate" ,        HandleDebugUpdateWorldStateCommand,    rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "itemexpire",         HandleDebugItemExpireCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "areatriggers",       HandleDebugAreaTriggersCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "los",                HandleDebugLoSCommand,                 rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "moveflags",          HandleDebugMoveflagsCommand,           rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "transport",          HandleDebugTransportCommand,           rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "loadcells",          HandleDebugLoadCellsCommand,           rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "phase",              HandleDebugPhaseCommand,               rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "boundary",           HandleDebugBoundaryCommand,            rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "raidreset",          HandleDebugRaidResetCommand,           rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "neargraveyard",      HandleDebugNearGraveyard,              rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "instancespawn",      HandleDebugInstanceSpawns,             rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "conversation" ,      HandleDebugConversationCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "wsexpression" ,      HandleDebugWSExpressionCommand,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "pvp warmode",        HandleDebugWarModeBalanceCommand,      rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "dummy",              HandleDebugDummyCommand,               rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
+            { "asan memoryleak",    HandleDebugMemoryLeak,                 rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "asan outofbounds",   HandleDebugOutOfBounds,                rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "guidlimits",         HandleDebugGuidLimitsCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "objectcount",        HandleDebugObjectCountCommand,         rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "questreset",         HandleDebugQuestResetCommand,          rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "warden force",       HandleDebugWardenForce,                rbac::RBAC_PERM_COMMAND_DEBUG,   Console::Yes },
+            { "personalclone",      HandleDebugBecomePersonalClone,        rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No }
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "debug",         rbac::RBAC_PERM_COMMAND_DEBUG,               true,  nullptr,                             "", debugCommandTable },
-            { "wpgps",         rbac::RBAC_PERM_COMMAND_WPGPS,               false, &HandleWPGPSCommand,                 "" },
+            { "debug",              debugCommandTable },
+            { "wpgps",              HandleWPGPSCommand,                    rbac::RBAC_PERM_COMMAND_DEBUG,   Console::No },
         };
         return commandTable;
     }
@@ -164,7 +152,7 @@ public:
         return true;
     }
 
-    static bool HandleDebugWarModeFactionBalanceCommand(ChatHandler* handler, Variant<uint32, EXACT_SEQUENCE("alliance"), EXACT_SEQUENCE("horde"), EXACT_SEQUENCE("neutral"), EXACT_SEQUENCE("off")> command, Optional<int32> rewardValue)
+    static bool HandleDebugWarModeBalanceCommand(ChatHandler* handler, Variant<uint32, EXACT_SEQUENCE("alliance"), EXACT_SEQUENCE("horde"), EXACT_SEQUENCE("neutral"), EXACT_SEQUENCE("off")> command, Optional<int32> rewardValue)
     {
         // USAGE: .debug pvp fb <alliance|horde|neutral|off> [pct]
         // neutral     Sets faction balance off.
@@ -1522,28 +1510,6 @@ public:
         return Conversation::CreateConversation(conversationEntry, target, *target, target->GetGUID()) != nullptr;
     }
 
-    static bool HandleDebugWorldStateCommand(ChatHandler* handler, uint32 worldStateId, Optional<uint32> value)
-    {
-        Player* target = handler->getSelectedPlayerOrSelf();
-
-        if (!target)
-        {
-            handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-
-        if (value)
-        {
-            sWorld->setWorldState(worldStateId, *value);
-            target->SendUpdateWorldState(worldStateId, *value);
-        }
-        else
-            handler->PSendSysMessage("Worldstate %u actual value : %u", worldStateId, sWorld->getWorldState(worldStateId));
-
-        return true;
-    }
-
     static bool HandleDebugWSExpressionCommand(ChatHandler* handler, uint32 expressionId)
     {
         Player* target = handler->getSelectedPlayerOrSelf();
diff --git a/src/server/scripts/Commands/cs_deserter.cpp b/src/server/scripts/Commands/cs_deserter.cpp
index b72d723d141..9ddb213af02 100644
--- a/src/server/scripts/Commands/cs_deserter.cpp
+++ b/src/server/scripts/Commands/cs_deserter.cpp
@@ -30,6 +30,8 @@
 #include "RBAC.h"
 #include "SpellAuras.h"
 
+using namespace Trinity::ChatCommands;
+
 enum Spells
 {
     LFG_SPELL_DUNGEON_DESERTER = 71041,
@@ -45,27 +47,27 @@ public:
     * @brief Returns the command structure for the system.
     */
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> deserterInstanceCommandTable =
+        static ChatCommandTable deserterInstanceCommandTable =
         {
-            { "add",      rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD,    false, &HandleDeserterInstanceAdd,    "" },
-            { "remove",   rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE, false, &HandleDeserterInstanceRemove, "" },
+            { "add",      HandleDeserterInstanceAdd,    rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD,    Console::No },
+            { "remove",   HandleDeserterInstanceRemove, rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE, Console::No },
         };
-        static std::vector<ChatCommand> deserterBGCommandTable =
+        static ChatCommandTable deserterBGCommandTable =
         {
-            { "add",      rbac::RBAC_PERM_COMMAND_DESERTER_BG_ADD,    false, &HandleDeserterBGAdd,    "" },
-            { "remove",   rbac::RBAC_PERM_COMMAND_DESERTER_BG_REMOVE, false, &HandleDeserterBGRemove, "" },
+            { "add",      HandleDeserterBGAdd,    rbac::RBAC_PERM_COMMAND_DESERTER_BG_ADD,          Console::No },
+            { "remove",   HandleDeserterBGRemove, rbac::RBAC_PERM_COMMAND_DESERTER_BG_REMOVE,       Console::No },
         };
 
-        static std::vector<ChatCommand> deserterCommandTable =
+        static ChatCommandTable deserterCommandTable =
         {
-            { "instance", rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE, false, nullptr, "", deserterInstanceCommandTable },
-            { "bg",       rbac::RBAC_PERM_COMMAND_DESERTER_BG,       false, nullptr, "", deserterBGCommandTable },
+            { "instance", deserterInstanceCommandTable },
+            { "bg",       deserterBGCommandTable },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "deserter", rbac::RBAC_PERM_COMMAND_DESERTER, false, nullptr, "", deserterCommandTable },
+            { "deserter", deserterCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_disable.cpp b/src/server/scripts/Commands/cs_disable.cpp
index b3bffc4049b..da8ca86df59 100644
--- a/src/server/scripts/Commands/cs_disable.cpp
+++ b/src/server/scripts/Commands/cs_disable.cpp
@@ -36,43 +36,49 @@ EndScriptData */
 #include "RBAC.h"
 #include "SpellMgr.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+using namespace Trinity::ChatCommands;
+
 class disable_commandscript : public CommandScript
 {
 public:
     disable_commandscript() : CommandScript("disable_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> removeDisableCommandTable =
+        static ChatCommandTable removeDisableCommandTable =
         {
-            { "spell",        rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL,        true, &HandleRemoveDisableSpellCommand,        "" },
-            { "quest",        rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST,        true, &HandleRemoveDisableQuestCommand,        "" },
-            { "map",          rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP,          true, &HandleRemoveDisableMapCommand,          "" },
-            { "battleground", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND, true, &HandleRemoveDisableBattlegroundCommand, "" },
-            { "criteria",     rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA,     true, &HandleRemoveDisableCriteriaCommand,     "" },
-            { "outdoorpvp",   rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_OUTDOORPVP,   true, &HandleRemoveDisableOutdoorPvPCommand,   "" },
-            { "vmap",         rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP,         true, &HandleRemoveDisableVmapCommand,         "" },
-            { "mmap",         rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MMAP,         true, &HandleRemoveDisableMMapCommand,         "" },
+            { "spell",                HandleRemoveDisableSpellCommand,               rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL,                Console::Yes },
+            { "quest",                HandleRemoveDisableQuestCommand,               rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST,                Console::Yes },
+            { "map",                  HandleRemoveDisableMapCommand,                 rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP,                  Console::Yes },
+            { "battleground",         HandleRemoveDisableBattlegroundCommand,        rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND,         Console::Yes },
+            { "criteria",             HandleRemoveDisableCriteriaCommand,            rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA,             Console::Yes },
+            { "outdoorpvp",           HandleRemoveDisableOutdoorPvPCommand,          rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_OUTDOORPVP,           Console::Yes },
+            { "vmap",                 HandleRemoveDisableVmapCommand,                rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP,                 Console::Yes },
+            { "mmap",                 HandleRemoveDisableMMapCommand,                rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MMAP,                 Console::Yes },
         };
-        static std::vector<ChatCommand> addDisableCommandTable =
+        static ChatCommandTable addDisableCommandTable =
         {
-            { "spell",        rbac::RBAC_PERM_COMMAND_DISABLE_ADD_SPELL,        true, &HandleAddDisableSpellCommand,        "" },
-            { "quest",        rbac::RBAC_PERM_COMMAND_DISABLE_ADD_QUEST,        true, &HandleAddDisableQuestCommand,        "" },
-            { "map",          rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MAP,          true, &HandleAddDisableMapCommand,          "" },
-            { "battleground", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND, true, &HandleAddDisableBattlegroundCommand, "" },
-            { "criteria",     rbac::RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA,     true, &HandleAddDisableCriteriaCommand,     "" },
-            { "outdoorpvp",   rbac::RBAC_PERM_COMMAND_DISABLE_ADD_OUTDOORPVP,   true, &HandleAddDisableOutdoorPvPCommand,   "" },
-            { "vmap",         rbac::RBAC_PERM_COMMAND_DISABLE_ADD_VMAP,         true, &HandleAddDisableVmapCommand,         "" },
-            { "mmap",         rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MMAP,         true, &HandleAddDisableMMapCommand,         "" },
+            { "spell",                HandleAddDisableSpellCommand,                  rbac::RBAC_PERM_COMMAND_DISABLE_ADD_SPELL,                Console::Yes },
+            { "quest",                HandleAddDisableQuestCommand,                  rbac::RBAC_PERM_COMMAND_DISABLE_ADD_QUEST,                Console::Yes },
+            { "map",                  HandleAddDisableMapCommand,                    rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MAP,                  Console::Yes },
+            { "battleground",         HandleAddDisableBattlegroundCommand,           rbac::RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND,         Console::Yes },
+            { "criteria",             HandleAddDisableCriteriaCommand,               rbac::RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA,             Console::Yes },
+            { "outdoorpvp",           HandleAddDisableOutdoorPvPCommand,             rbac::RBAC_PERM_COMMAND_DISABLE_ADD_OUTDOORPVP,           Console::Yes },
+            { "vmap",                 HandleAddDisableVmapCommand,                   rbac::RBAC_PERM_COMMAND_DISABLE_ADD_VMAP,                 Console::Yes },
+            { "mmap",                 HandleAddDisableMMapCommand,                   rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MMAP,                 Console::Yes },
         };
-        static std::vector<ChatCommand> disableCommandTable =
+        static ChatCommandTable disableCommandTable =
         {
-            { "add",    rbac::RBAC_PERM_COMMAND_DISABLE_ADD,    true, nullptr, "", addDisableCommandTable },
-            { "remove", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE, true, nullptr, "", removeDisableCommandTable },
+            { "add",    addDisableCommandTable },
+            { "remove", removeDisableCommandTable },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "disable", rbac::RBAC_PERM_COMMAND_DISABLE, false, nullptr, "", disableCommandTable },
+            { "disable", disableCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_event.cpp b/src/server/scripts/Commands/cs_event.cpp
index ae11663e267..0f956dccfb2 100644
--- a/src/server/scripts/Commands/cs_event.cpp
+++ b/src/server/scripts/Commands/cs_event.cpp
@@ -37,18 +37,18 @@ class event_commandscript : public CommandScript
 public:
     event_commandscript() : CommandScript("event_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> eventCommandTable =
+        static ChatCommandTable eventCommandTable =
         {
-            { "activelist", rbac::RBAC_PERM_COMMAND_EVENT_ACTIVELIST, true, &HandleEventActiveListCommand, "" },
-            { "start",      rbac::RBAC_PERM_COMMAND_EVENT_START,      true, &HandleEventStartCommand,      "" },
-            { "stop",       rbac::RBAC_PERM_COMMAND_EVENT_STOP,       true, &HandleEventStopCommand,       "" },
-            { "info",       rbac::RBAC_PERM_COMMAND_EVENT,            true, &HandleEventInfoCommand,       "" },
+            { "activelist", HandleEventActiveListCommand, rbac::RBAC_PERM_COMMAND_EVENT_ACTIVELIST, Console::Yes },
+            { "start",      HandleEventStartCommand,      rbac::RBAC_PERM_COMMAND_EVENT_START,      Console::Yes },
+            { "stop",       HandleEventStopCommand,       rbac::RBAC_PERM_COMMAND_EVENT_STOP,       Console::Yes },
+            { "info",       HandleEventInfoCommand,       rbac::RBAC_PERM_COMMAND_EVENT_INFO,       Console::Yes },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "event", rbac::RBAC_PERM_COMMAND_EVENT, false, nullptr, "", eventCommandTable },
+            { "event", eventCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_gm.cpp b/src/server/scripts/Commands/cs_gm.cpp
index 7bbd5196a7c..17b7889b64a 100644
--- a/src/server/scripts/Commands/cs_gm.cpp
+++ b/src/server/scripts/Commands/cs_gm.cpp
@@ -34,25 +34,27 @@ EndScriptData */
 #include "World.h"
 #include "WorldSession.h"
 
+using namespace Trinity::ChatCommands;
+
 class gm_commandscript : public CommandScript
 {
 public:
     gm_commandscript() : CommandScript("gm_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> gmCommandTable =
+        static ChatCommandTable gmCommandTable =
         {
-            { "chat",    rbac::RBAC_PERM_COMMAND_GM_CHAT,    false, &HandleGMChatCommand,       "" },
-            { "fly",     rbac::RBAC_PERM_COMMAND_GM_FLY,     false, &HandleGMFlyCommand,        "" },
-            { "ingame",  rbac::RBAC_PERM_COMMAND_GM_INGAME,   true, &HandleGMListIngameCommand, "" },
-            { "list",    rbac::RBAC_PERM_COMMAND_GM_LIST,     true, &HandleGMListFullCommand,   "" },
-            { "visible", rbac::RBAC_PERM_COMMAND_GM_VISIBLE, false, &HandleGMVisibleCommand,    "" },
-            { "",        rbac::RBAC_PERM_COMMAND_GM,         false, &HandleGMCommand,           "" },
+            { "chat",       HandleGMChatCommand,        rbac::RBAC_PERM_COMMAND_GM_CHAT,        Console::No },
+            { "fly",        HandleGMFlyCommand,         rbac::RBAC_PERM_COMMAND_GM_FLY,         Console::No },
+            { "ingame",     HandleGMListIngameCommand,  rbac::RBAC_PERM_COMMAND_GM_INGAME,      Console::Yes },
+            { "list",       HandleGMListFullCommand,    rbac::RBAC_PERM_COMMAND_GM_LIST,        Console::Yes },
+            { "visible",    HandleGMVisibleCommand,     rbac::RBAC_PERM_COMMAND_GM_VISIBLE,     Console::No },
+            { "",           HandleGMCommand,            rbac::RBAC_PERM_COMMAND_GM,             Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "gm", rbac::RBAC_PERM_COMMAND_GM, false, nullptr, "", gmCommandTable },
+            { "gm", gmCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_go.cpp b/src/server/scripts/Commands/cs_go.cpp
index ef923230077..9aeffbad0b1 100644
--- a/src/server/scripts/Commands/cs_go.cpp
+++ b/src/server/scripts/Commands/cs_go.cpp
@@ -40,47 +40,38 @@ EndScriptData */
 #include <sstream>
 
 using namespace Trinity::ChatCommands;
+
 class go_commandscript : public CommandScript
 {
 public:
     go_commandscript() : CommandScript("go_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> goCreatureCommandTable =
-        {
-            { "id",     rbac::RBAC_PERM_COMMAND_GO,     false,      &HandleGoCreatureCIdCommand,            "" },
-            { "",       rbac::RBAC_PERM_COMMAND_GO,     false,      &HandleGoCreatureSpawnIdCommand,        "" }
-        };
-
-        static std::vector<ChatCommand> goGameObjectCommandTable =
-        {
-            { "id",     rbac::RBAC_PERM_COMMAND_GO,     false,      &HandleGoGameObjectGOIdCommand,         "" },
-            { "",       rbac::RBAC_PERM_COMMAND_GO,     false,      &HandleGoGameObjectSpawnIdCommand,      "" }
-        };
-
-        static std::vector<ChatCommand> goCommandTable =
-        {
-            { "creature",           rbac::RBAC_PERM_COMMAND_GO,             false, nullptr,                                     "", goCreatureCommandTable },
-            { "gameobject",         rbac::RBAC_PERM_COMMAND_GO,             false, nullptr,                                     "", goGameObjectCommandTable },
-            { "graveyard",          rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoGraveyardCommand,                   "" },
-            { "grid",               rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoGridCommand,                        "" },
-            { "quest",              rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoQuestCommand,                       "" },
-            { "taxinode",           rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoTaxinodeCommand,                    "" },
-            { "areatrigger",        rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoAreaTriggerCommand,                 "" },
-            { "zonexy",             rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoZoneXYCommand,                      "" },
-            { "xyz",                rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoXYZCommand,                         "" },
-            { "bugticket",          rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoTicketCommand<BugTicket>,           "" },
-            { "complaintticket",    rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoTicketCommand<ComplaintTicket>,     "" },
-            { "suggestionticket",   rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoTicketCommand<SuggestionTicket>,    "" },
-            { "offset",             rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoOffsetCommand,                      "" },
-            { "instance",           rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoInstanceCommand,                    "" },
-            { "boss",               rbac::RBAC_PERM_COMMAND_GO,             false, &HandleGoBossCommand,                        "" }
+        static ChatCommandTable goCommandTable =
+        {
+            { "creature",           HandleGoCreatureSpawnIdCommand,         rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "creature id",        HandleGoCreatureCIdCommand,             rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "gameobject",         HandleGoGameObjectSpawnIdCommand,       rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "gameobject id",      HandleGoGameObjectGOIdCommand,          rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "graveyard",          HandleGoGraveyardCommand,               rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "grid",               HandleGoGridCommand,                    rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "quest",              HandleGoQuestCommand,                   rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "taxinode",           HandleGoTaxinodeCommand,                rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "areatrigger",        HandleGoAreaTriggerCommand,             rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "zonexy",             HandleGoZoneXYCommand,                  rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "xyz",                HandleGoXYZCommand,                     rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "bugticket",          HandleGoTicketCommand<BugTicket>,       rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "complaintticket",    HandleGoTicketCommand<ComplaintTicket>, rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "suggestionticket",   HandleGoTicketCommand<SuggestionTicket>,rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "offset",             HandleGoOffsetCommand,                  rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "instance",           HandleGoInstanceCommand,                rbac::RBAC_PERM_COMMAND_GO,             Console::No },
+            { "boss",               HandleGoBossCommand,                    rbac::RBAC_PERM_COMMAND_GO,             Console::No }
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "go", rbac::RBAC_PERM_COMMAND_GO, false, nullptr, "", goCommandTable },
+            { "go", goCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_gobject.cpp b/src/server/scripts/Commands/cs_gobject.cpp
index d22e53739f6..2dcb4a9138d 100644
--- a/src/server/scripts/Commands/cs_gobject.cpp
+++ b/src/server/scripts/Commands/cs_gobject.cpp
@@ -43,8 +43,8 @@ EndScriptData */
 #include "WorldSession.h"
 #include <sstream>
 
-
 using namespace Trinity::ChatCommands;
+
 using GameObjectSpawnId = Variant<Hyperlink<gameobject>, ObjectGuid::LowType>;
 using GameObjectEntry = Variant<Hyperlink<gameobject_entry>, uint32>;
 
@@ -57,35 +57,27 @@ class gobject_commandscript : public CommandScript
 public:
     gobject_commandscript() : CommandScript("gobject_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> gobjectAddCommandTable =
-        {
-            { "temp", rbac::RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP, false, &HandleGameObjectAddTempCommand,   "" },
-            { "",     rbac::RBAC_PERM_COMMAND_GOBJECT_ADD,      false, &HandleGameObjectAddCommand,       "" },
-        };
-        static std::vector<ChatCommand> gobjectSetCommandTable =
-        {
-            { "phase", rbac::RBAC_PERM_COMMAND_GOBJECT_SET_PHASE, false, &HandleGameObjectSetPhaseCommand,  "" },
-            { "state", rbac::RBAC_PERM_COMMAND_GOBJECT_SET_STATE, false, &HandleGameObjectSetStateCommand,  "" },
-        };
-        static std::vector<ChatCommand> gobjectCommandTable =
-        {
-            { "activate",     rbac::RBAC_PERM_COMMAND_GOBJECT_ACTIVATE,     false, &HandleGameObjectActivateCommand,  ""       },
-            { "delete",       rbac::RBAC_PERM_COMMAND_GOBJECT_DELETE,       false, &HandleGameObjectDeleteCommand,    ""       },
-            { "info",         rbac::RBAC_PERM_COMMAND_GOBJECT_INFO,         false, &HandleGameObjectInfoCommand,      ""       },
-            { "move",         rbac::RBAC_PERM_COMMAND_GOBJECT_MOVE,         false, &HandleGameObjectMoveCommand,      ""       },
-            { "near",         rbac::RBAC_PERM_COMMAND_GOBJECT_NEAR,         false, &HandleGameObjectNearCommand,      ""       },
-            { "target",       rbac::RBAC_PERM_COMMAND_GOBJECT_TARGET,       false, &HandleGameObjectTargetCommand,    ""       },
-            { "turn",         rbac::RBAC_PERM_COMMAND_GOBJECT_TURN,         false, &HandleGameObjectTurnCommand,      ""       },
-            { "spawngroup",   rbac::RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP,   false, &HandleNpcSpawnGroup,              ""       },
-            { "despawngroup", rbac::RBAC_PERM_COMMAND_GOBJECT_DESPAWNGROUP, false, &HandleNpcDespawnGroup,            ""       },
-            { "add",          rbac::RBAC_PERM_COMMAND_GOBJECT_ADD,          false, nullptr,         "", gobjectAddCommandTable },
-            { "set",          rbac::RBAC_PERM_COMMAND_GOBJECT_SET,          false, nullptr,         "", gobjectSetCommandTable },
+        static ChatCommandTable gobjectCommandTable =
+        {
+            { "activate",       HandleGameObjectActivateCommand,  rbac::RBAC_PERM_COMMAND_GOBJECT_ACTIVATE,       Console::No },
+            { "delete",         HandleGameObjectDeleteCommand,    rbac::RBAC_PERM_COMMAND_GOBJECT_DELETE,         Console::No },
+            { "info",           HandleGameObjectInfoCommand,      rbac::RBAC_PERM_COMMAND_GOBJECT_INFO,           Console::No },
+            { "move",           HandleGameObjectMoveCommand,      rbac::RBAC_PERM_COMMAND_GOBJECT_MOVE,           Console::No },
+            { "near",           HandleGameObjectNearCommand,      rbac::RBAC_PERM_COMMAND_GOBJECT_NEAR,           Console::No },
+            { "target",         HandleGameObjectTargetCommand,    rbac::RBAC_PERM_COMMAND_GOBJECT_TARGET,         Console::No },
+            { "turn",           HandleGameObjectTurnCommand,      rbac::RBAC_PERM_COMMAND_GOBJECT_TURN,           Console::No },
+            { "spawngroup",     HandleNpcSpawnGroup,              rbac::RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP,     Console::No },
+            { "despawngroup",   HandleNpcDespawnGroup,            rbac::RBAC_PERM_COMMAND_GOBJECT_DESPAWNGROUP,   Console::No },
+            { "add temp",       HandleGameObjectAddTempCommand,   rbac::RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP,       Console::No },
+            { "add",            HandleGameObjectAddCommand,       rbac::RBAC_PERM_COMMAND_GOBJECT_ADD,            Console::No },
+            { "set phase",      HandleGameObjectSetPhaseCommand,  rbac::RBAC_PERM_COMMAND_GOBJECT_SET_PHASE,      Console::No },
+            { "set state",      HandleGameObjectSetStateCommand,  rbac::RBAC_PERM_COMMAND_GOBJECT_SET_STATE,      Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "gobject", rbac::RBAC_PERM_COMMAND_GOBJECT, false, nullptr, "", gobjectCommandTable },
+            { "gobject", gobjectCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_group.cpp b/src/server/scripts/Commands/cs_group.cpp
index 41db433f631..c5d1c6a8f09 100644
--- a/src/server/scripts/Commands/cs_group.cpp
+++ b/src/server/scripts/Commands/cs_group.cpp
@@ -31,6 +31,10 @@
 #include "RBAC.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class group_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_guild.cpp b/src/server/scripts/Commands/cs_guild.cpp
index 17efbbac016..2a0185223ec 100644
--- a/src/server/scripts/Commands/cs_guild.cpp
+++ b/src/server/scripts/Commands/cs_guild.cpp
@@ -35,6 +35,10 @@ EndScriptData */
 #include "RBAC.h"
 #include <iomanip>
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 using namespace Trinity::ChatCommands;
 class guild_commandscript : public CommandScript
 {
diff --git a/src/server/scripts/Commands/cs_honor.cpp b/src/server/scripts/Commands/cs_honor.cpp
index 0b435e2cba0..d2c7eb58385 100644
--- a/src/server/scripts/Commands/cs_honor.cpp
+++ b/src/server/scripts/Commands/cs_honor.cpp
@@ -30,6 +30,10 @@ EndScriptData */
 #include "RBAC.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class honor_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_instance.cpp b/src/server/scripts/Commands/cs_instance.cpp
index 4c275943b48..e31043c36e5 100644
--- a/src/server/scripts/Commands/cs_instance.cpp
+++ b/src/server/scripts/Commands/cs_instance.cpp
@@ -39,6 +39,10 @@ EndScriptData */
 #include "WorldSession.h"
 #include <sstream>
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class instance_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_learn.cpp b/src/server/scripts/Commands/cs_learn.cpp
index 7d5a5cd8552..1ee96137c6c 100644
--- a/src/server/scripts/Commands/cs_learn.cpp
+++ b/src/server/scripts/Commands/cs_learn.cpp
@@ -34,41 +34,46 @@ EndScriptData */
 #include "SpellMgr.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+using namespace Trinity::ChatCommands;
 class learn_commandscript : public CommandScript
 {
 public:
     learn_commandscript() : CommandScript("learn_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> learnAllMyCommandTable =
+        static ChatCommandTable learnAllMyCommandTable =
         {
-            { "class",      rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS,      false, &HandleLearnAllMyClassCommand,      "" },
-            { "pettalents", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS, false, &HandleLearnAllMyPetTalentsCommand, "" },
-            { "spells",     rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS,     false, &HandleLearnAllMySpellsCommand,     "" },
-            { "talents",    rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS,    false, &HandleLearnAllMyTalentsCommand,    "" },
+            { "class",      HandleLearnAllMyClassCommand,       rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS,         Console::No },
+            { "pettalents", HandleLearnAllMyPetTalentsCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS,    Console::No },
+            { "spells",     HandleLearnAllMySpellsCommand,      rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS,        Console::No },
+            { "talents",    HandleLearnAllMyTalentsCommand,     rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS,       Console::No },
         };
 
-        static std::vector<ChatCommand> learnAllCommandTable =
+        static ChatCommandTable learnAllCommandTable =
         {
-            { "my",      rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY,      false, nullptr,                       "", learnAllMyCommandTable },
-            { "gm",      rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM,      false, &HandleLearnAllGMCommand,      "" },
-            { "crafts",  rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS,  false, &HandleLearnAllCraftsCommand,  "" },
-            { "default", rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT, false, &HandleLearnAllDefaultCommand, "" },
-            { "lang",    rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG,    false, &HandleLearnAllLangCommand,    "" },
-            { "recipes", rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES, false, &HandleLearnAllRecipesCommand, "" },
+            { "my",      learnAllMyCommandTable },
+            { "gm",      HandleLearnAllGMCommand,       rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM,       Console::No },
+            { "crafts",  HandleLearnAllCraftsCommand,   rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS,   Console::No },
+            { "default", HandleLearnAllDefaultCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT,  Console::No },
+            { "lang",    HandleLearnAllLangCommand,     rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG,     Console::No },
+            { "recipes", HandleLearnAllRecipesCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES,  Console::No },
         };
 
-        static std::vector<ChatCommand> learnCommandTable =
+        static ChatCommandTable learnCommandTable =
         {
-            { "all", rbac::RBAC_PERM_COMMAND_LEARN_ALL, false, nullptr,             "", learnAllCommandTable },
-            { "",    rbac::RBAC_PERM_COMMAND_LEARN,     false, &HandleLearnCommand, "" },
+            { "",       HandleLearnCommand,             rbac::RBAC_PERM_COMMAND_LEARN,              Console::No },
+            { "all",    learnAllCommandTable },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "learn",   rbac::RBAC_PERM_COMMAND_LEARN,   false, nullptr,               "", learnCommandTable },
-            { "unlearn", rbac::RBAC_PERM_COMMAND_UNLEARN, false, &HandleUnLearnCommand, "" },
+            { "learn",   learnCommandTable },
+            { "unlearn", HandleUnLearnCommand,          rbac::RBAC_PERM_COMMAND_UNLEARN,            Console::No },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_lfg.cpp b/src/server/scripts/Commands/cs_lfg.cpp
index e70304240cb..da7a1f73f69 100644
--- a/src/server/scripts/Commands/cs_lfg.cpp
+++ b/src/server/scripts/Commands/cs_lfg.cpp
@@ -49,20 +49,20 @@ class lfg_commandscript : public CommandScript
 public:
     lfg_commandscript() : CommandScript("lfg_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> lfgCommandTable =
+        static ChatCommandTable lfgCommandTable =
         {
-            {  "player", rbac::RBAC_PERM_COMMAND_LFG_PLAYER,  false, &HandleLfgPlayerInfoCommand, "" },
-            {   "group", rbac::RBAC_PERM_COMMAND_LFG_GROUP,   false, &HandleLfgGroupInfoCommand,  "" },
-            {   "queue", rbac::RBAC_PERM_COMMAND_LFG_QUEUE,   true,  &HandleLfgQueueInfoCommand,  "" },
-            {   "clean", rbac::RBAC_PERM_COMMAND_LFG_CLEAN,   true,  &HandleLfgCleanCommand,      "" },
-            { "options", rbac::RBAC_PERM_COMMAND_LFG_OPTIONS, true,  &HandleLfgOptionsCommand,    "" },
+            { "player",     HandleLfgPlayerInfoCommand,     rbac::RBAC_PERM_COMMAND_LFG_PLAYER,     Console::No },
+            { "group",      HandleLfgGroupInfoCommand,      rbac::RBAC_PERM_COMMAND_LFG_GROUP,      Console::No },
+            { "queue",      HandleLfgQueueInfoCommand,      rbac::RBAC_PERM_COMMAND_LFG_QUEUE,      Console::Yes },
+            { "clean",      HandleLfgCleanCommand,          rbac::RBAC_PERM_COMMAND_LFG_CLEAN,      Console::Yes },
+            { "options",    HandleLfgOptionsCommand,        rbac::RBAC_PERM_COMMAND_LFG_OPTIONS,    Console::Yes },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "lfg", rbac::RBAC_PERM_COMMAND_LFG, true, nullptr, "", lfgCommandTable },
+            { "lfg", lfgCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_list.cpp b/src/server/scripts/Commands/cs_list.cpp
index 568a0bf993f..4eb121024e5 100644
--- a/src/server/scripts/Commands/cs_list.cpp
+++ b/src/server/scripts/Commands/cs_list.cpp
@@ -33,7 +33,6 @@ EndScriptData */
 #include "GameTime.h"
 #include "Language.h"
 #include "MapManager.h"
-#include "ObjectAccessor.h"
 #include "ObjectMgr.h"
 #include "PhasingHandler.h"
 #include "Player.h"
@@ -49,22 +48,22 @@ class list_commandscript : public CommandScript
 public:
     list_commandscript() : CommandScript("list_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> listCommandTable =
+        static ChatCommandTable listCommandTable =
         {
-            { "creature",    rbac::RBAC_PERM_COMMAND_LIST_CREATURE,    true,  &HandleListCreatureCommand,    "" },
-            { "item",        rbac::RBAC_PERM_COMMAND_LIST_ITEM,        true,  &HandleListItemCommand,        "" },
-            { "object",      rbac::RBAC_PERM_COMMAND_LIST_OBJECT,      true,  &HandleListObjectCommand,      "" },
-            { "auras",       rbac::RBAC_PERM_COMMAND_LIST_AURAS,       false, &HandleListAurasCommand,       "" },
-            { "mail",        rbac::RBAC_PERM_COMMAND_LIST_MAIL,        true,  &HandleListMailCommand,        "" },
-            { "spawnpoints", rbac::RBAC_PERM_COMMAND_LIST_SPAWNPOINTS, false, &HandleListSpawnPointsCommand, "" },
-            { "respawns",    rbac::RBAC_PERM_COMMAND_LIST_RESPAWNS,    false, &HandleListRespawnsCommand,    "" },
-            { "scenes",      rbac::RBAC_PERM_COMMAND_LIST_SCENES,      false, &HandleListScenesCommand,      "" },
+            { "creature",       HandleListCreatureCommand,      rbac::RBAC_PERM_COMMAND_LIST_CREATURE,      Console::Yes },
+            { "item",           HandleListItemCommand,          rbac::RBAC_PERM_COMMAND_LIST_ITEM,          Console::Yes },
+            { "object",         HandleListObjectCommand,        rbac::RBAC_PERM_COMMAND_LIST_OBJECT,        Console::Yes },
+            { "auras",          HandleListAurasCommand,         rbac::RBAC_PERM_COMMAND_LIST_AURAS,         Console::No },
+            { "mail",           HandleListMailCommand,          rbac::RBAC_PERM_COMMAND_LIST_MAIL,          Console::Yes },
+            { "spawnpoints",    HandleListSpawnPointsCommand,   rbac::RBAC_PERM_COMMAND_LIST_SPAWNPOINTS,   Console::No },
+            { "respawns",       HandleListRespawnsCommand,      rbac::RBAC_PERM_COMMAND_LIST_RESPAWNS,      Console::No },
+            { "scenes",         HandleListScenesCommand,        rbac::RBAC_PERM_COMMAND_LIST_SCENES,        Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "list", rbac::RBAC_PERM_COMMAND_LIST,true, nullptr, "", listCommandTable },
+            { "list", listCommandTable },
         };
         return commandTable;
     }
@@ -482,40 +481,27 @@ public:
         return true;
     }
     // handle list mail command
-    static bool HandleListMailCommand(ChatHandler* handler, char const* args)
+    static bool HandleListMailCommand(ChatHandler* handler, Optional<PlayerIdentifier> player)
     {
-        Player* target;
-        ObjectGuid targetGuid;
-        std::string targetName;
-        CharacterDatabasePreparedStatement* stmt = nullptr;
-
-        if (!*args)
-            return false;
-
-        ObjectGuid parseGUID = ObjectGuid::Create<HighGuid::Player>(strtoull(args, nullptr, 10));
-
-        if (sCharacterCache->GetCharacterNameByGuid(parseGUID, targetName))
-        {
-            target = ObjectAccessor::FindPlayer(parseGUID);
-            targetGuid = parseGUID;
-        }
-        else if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
+        if (!player)
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player)
             return false;
 
-        stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_COUNT);
-        stmt->setUInt64(0, targetGuid.GetCounter());
+        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_COUNT);
+        stmt->setUInt64(0, player->GetGUID().GetCounter());
         PreparedQueryResult queryResult = CharacterDatabase.Query(stmt);
         if (queryResult)
         {
             Field* fields       = queryResult->Fetch();
             uint32 countMail    = fields[0].GetUInt64();
 
-            std::string nameLink = handler->playerLink(targetName);
-            handler->PSendSysMessage(LANG_LIST_MAIL_HEADER, countMail, nameLink.c_str(), targetGuid.ToString().c_str());
+            std::string nameLink = handler->playerLink(player->GetName());
+            handler->PSendSysMessage(LANG_LIST_MAIL_HEADER, countMail, nameLink.c_str(), player->GetGUID().ToString().c_str());
             handler->PSendSysMessage(LANG_ACCOUNT_LIST_BAR);
 
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_INFO);
-            stmt->setUInt64(0, targetGuid.GetCounter());
+            stmt->setUInt64(0, player->GetGUID().GetCounter());
             queryResult = CharacterDatabase.Query(stmt);
 
             if (queryResult)
diff --git a/src/server/scripts/Commands/cs_lookup.cpp b/src/server/scripts/Commands/cs_lookup.cpp
index e3c0ab66617..65803f99801 100644
--- a/src/server/scripts/Commands/cs_lookup.cpp
+++ b/src/server/scripts/Commands/cs_lookup.cpp
@@ -38,6 +38,10 @@ EndScriptData */
 #include "WorldSession.h"
 #include <sstream>
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class lookup_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_message.cpp b/src/server/scripts/Commands/cs_message.cpp
index 2f2fa9f4f57..df2b4243643 100644
--- a/src/server/scripts/Commands/cs_message.cpp
+++ b/src/server/scripts/Commands/cs_message.cpp
@@ -45,26 +45,18 @@ class message_commandscript : public CommandScript
 public:
     message_commandscript() : CommandScript("message_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> channelSetCommandTable =
+        static ChatCommandTable commandTable =
         {
-            { "ownership", rbac::RBAC_PERM_COMMAND_CHANNEL_SET_OWNERSHIP, false, &HandleChannelSetOwnership, "" },
-        };
-        static std::vector<ChatCommand> channelCommandTable =
-        {
-            { "set", rbac::RBAC_PERM_COMMAND_CHANNEL_SET, true, nullptr, "", channelSetCommandTable },
-        };
-        static std::vector<ChatCommand> commandTable =
-        {
-            { "channel",        rbac::RBAC_PERM_COMMAND_CHANNEL,        true, nullptr,                      "", channelCommandTable  },
-            { "nameannounce",   rbac::RBAC_PERM_COMMAND_NAMEANNOUNCE,   true, &HandleNameAnnounceCommand,   "" },
-            { "gmnameannounce", rbac::RBAC_PERM_COMMAND_GMNAMEANNOUNCE, true, &HandleGMNameAnnounceCommand, "" },
-            { "announce",       rbac::RBAC_PERM_COMMAND_ANNOUNCE,       true, &HandleAnnounceCommand,       "" },
-            { "gmannounce",     rbac::RBAC_PERM_COMMAND_GMANNOUNCE,     true, &HandleGMAnnounceCommand,     "" },
-            { "notify",         rbac::RBAC_PERM_COMMAND_NOTIFY,         true, &HandleNotifyCommand,         "" },
-            { "gmnotify",       rbac::RBAC_PERM_COMMAND_GMNOTIFY,       true, &HandleGMNotifyCommand,       "" },
-            { "whispers",       rbac::RBAC_PERM_COMMAND_WHISPERS,      false, &HandleWhispersCommand,       "" },
+            { "channel set ownership",  HandleChannelSetOwnership,      rbac::RBAC_PERM_COMMAND_CHANNEL_SET_OWNERSHIP,  Console::No },
+            { "nameannounce",           HandleNameAnnounceCommand,      rbac::RBAC_PERM_COMMAND_NAMEANNOUNCE,           Console::Yes },
+            { "gmnameannounce",         HandleGMNameAnnounceCommand,    rbac::RBAC_PERM_COMMAND_GMNAMEANNOUNCE,         Console::Yes },
+            { "announce",               HandleAnnounceCommand,          rbac::RBAC_PERM_COMMAND_ANNOUNCE,               Console::Yes },
+            { "gmannounce",             HandleGMAnnounceCommand,        rbac::RBAC_PERM_COMMAND_GMANNOUNCE,             Console::Yes },
+            { "notify",                 HandleNotifyCommand,            rbac::RBAC_PERM_COMMAND_NOTIFY,                 Console::Yes },
+            { "gmnotify",               HandleGMNotifyCommand,          rbac::RBAC_PERM_COMMAND_GMNOTIFY,               Console::Yes },
+            { "whispers",               HandleWhispersCommand,          rbac::RBAC_PERM_COMMAND_WHISPERS,               Console::No },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index 088233742ad..7985a1ad5bb 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -56,6 +56,10 @@
 #undef GetClassName
 #endif
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 using namespace Trinity::ChatCommands;
 
 class misc_commandscript : public CommandScript
@@ -603,7 +607,7 @@ public:
 
     static bool HandleCommandsCommand(ChatHandler* handler)
     {
-        handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "");
+        Trinity::ChatCommands::SendCommandHelpFor(*handler, "");
         return true;
     }
 
@@ -694,19 +698,9 @@ public:
         return true;
     }
 
-    static bool HandleHelpCommand(ChatHandler* handler, Tail cmdArg)
+    static bool HandleHelpCommand(ChatHandler* handler, Tail cmd)
     {
-        if (cmdArg.empty())
-        {
-            handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "help");
-            handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "");
-        }
-        else
-        {
-            if (!handler->ShowHelpForCommand(ChatHandler::getCommandTable(), std::string(cmdArg).c_str()))
-                handler->SendSysMessage(LANG_NO_HELP_CMD);
-        }
-
+        Trinity::ChatCommands::SendCommandHelpFor(*handler, cmd);
         return true;
     }
 
diff --git a/src/server/scripts/Commands/cs_mmaps.cpp b/src/server/scripts/Commands/cs_mmaps.cpp
index fb817c5cf51..455f12ec622 100644
--- a/src/server/scripts/Commands/cs_mmaps.cpp
+++ b/src/server/scripts/Commands/cs_mmaps.cpp
@@ -37,6 +37,10 @@
 #include "RBAC.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class mmaps_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_modify.cpp b/src/server/scripts/Commands/cs_modify.cpp
index 7f24788c115..9960143f455 100644
--- a/src/server/scripts/Commands/cs_modify.cpp
+++ b/src/server/scripts/Commands/cs_modify.cpp
@@ -38,6 +38,10 @@ EndScriptData */
 #include "UpdateFields.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class modify_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_npc.cpp b/src/server/scripts/Commands/cs_npc.cpp
index 24dc0ded865..bfd84278a14 100644
--- a/src/server/scripts/Commands/cs_npc.cpp
+++ b/src/server/scripts/Commands/cs_npc.cpp
@@ -47,6 +47,7 @@ EndScriptData */
 #include "WorldSession.h"
 
 using namespace Trinity::ChatCommands;
+
 using CreatureSpawnId = Variant<Hyperlink<creature>, ObjectGuid::LowType>;
 using CreatureEntry = Variant<Hyperlink<creature_entry>, uint32>;
 
@@ -59,66 +60,57 @@ class npc_commandscript : public CommandScript
 public:
     npc_commandscript() : CommandScript("npc_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> npcAddCommandTable =
-        {
-            { "formation", rbac::RBAC_PERM_COMMAND_NPC_ADD_FORMATION, false, &HandleNpcAddFormationCommand,      "" },
-            { "item",      rbac::RBAC_PERM_COMMAND_NPC_ADD_ITEM,      false, &HandleNpcAddVendorItemCommand,     "" },
-            { "move",      rbac::RBAC_PERM_COMMAND_NPC_ADD_MOVE,      false, &HandleNpcAddMoveCommand,           "" },
-            { "temp",      rbac::RBAC_PERM_COMMAND_NPC_ADD_TEMP,      false, &HandleNpcAddTempSpawnCommand,      "" },
-            //{ "weapon",    rbac::RBAC_PERM_COMMAND_NPC_ADD_WEAPON,    false, &HandleNpcAddWeaponCommand,         "" },
-            { "",          rbac::RBAC_PERM_COMMAND_NPC_ADD,           false, &HandleNpcAddCommand,               "" },
-        };
-        static std::vector<ChatCommand> npcDeleteCommandTable =
-        {
-            { "item", rbac::RBAC_PERM_COMMAND_NPC_DELETE_ITEM, false, &HandleNpcDeleteVendorItemCommand,  "" },
-            { "",     rbac::RBAC_PERM_COMMAND_NPC_DELETE,      false, &HandleNpcDeleteCommand,            "" },
-        };
-        static std::vector<ChatCommand> npcFollowCommandTable =
-        {
-            { "stop", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW_STOP, false, &HandleNpcUnFollowCommand,          "" },
-            { "",     rbac::RBAC_PERM_COMMAND_NPC_FOLLOW,      false, &HandleNpcFollowCommand,            "" },
+        static ChatCommandTable npcAddCommandTable =
+        {
+            { "formation",      HandleNpcAddFormationCommand,      rbac::RBAC_PERM_COMMAND_NPC_ADD_FORMATION,  Console::No },
+            { "item",           HandleNpcAddVendorItemCommand,     rbac::RBAC_PERM_COMMAND_NPC_ADD_ITEM,       Console::No },
+            { "move",           HandleNpcAddMoveCommand,           rbac::RBAC_PERM_COMMAND_NPC_ADD_MOVE,       Console::No },
+            { "temp",           HandleNpcAddTempSpawnCommand,      rbac::RBAC_PERM_COMMAND_NPC_ADD_TEMP,       Console::No },
+//          { "weapon",         HandleNpcAddWeaponCommand,         rbac::RBAC_PERM_COMMAND_NPC_ADD_WEAPON,     Console::No },
+            { "",               HandleNpcAddCommand,               rbac::RBAC_PERM_COMMAND_NPC_ADD,            Console::No },
         };
-        static std::vector<ChatCommand> npcSetCommandTable =
-        {
-            { "allowmove",      rbac::RBAC_PERM_COMMAND_NPC_SET_ALLOWMOVE, false, &HandleNpcSetAllowMovementCommand,  "" },
-            { "entry",          rbac::RBAC_PERM_COMMAND_NPC_SET_ENTRY,     false, &HandleNpcSetEntryCommand,          "" },
-            { "factionid",      rbac::RBAC_PERM_COMMAND_NPC_SET_FACTIONID, false, &HandleNpcSetFactionIdCommand,      "" },
-            { "flag",           rbac::RBAC_PERM_COMMAND_NPC_SET_FLAG,      false, &HandleNpcSetFlagCommand,           "" },
-            { "level",          rbac::RBAC_PERM_COMMAND_NPC_SET_LEVEL,     false, &HandleNpcSetLevelCommand,          "" },
-            { "link",           rbac::RBAC_PERM_COMMAND_NPC_SET_LINK,      false, &HandleNpcSetLinkCommand,           "" },
-            { "model",          rbac::RBAC_PERM_COMMAND_NPC_SET_MODEL,     false, &HandleNpcSetModelCommand,          "" },
-            { "movetype",       rbac::RBAC_PERM_COMMAND_NPC_SET_MOVETYPE,  false, &HandleNpcSetMoveTypeCommand,       "" },
-            { "phase",          rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE,     false, &HandleNpcSetPhaseCommand,          "" },
-            { "phasegroup",     rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE,     false, &HandleNpcSetPhaseGroup,            "" },
-            { "wanderdistance", rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNDIST, false, &HandleNpcSetWanderDistanceCommand, "" },
-            { "spawntime",      rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNTIME, false, &HandleNpcSetSpawnTimeCommand,      "" },
-            { "data",           rbac::RBAC_PERM_COMMAND_NPC_SET_DATA,      false, &HandleNpcSetDataCommand,           "" },
+        static ChatCommandTable npcSetCommandTable =
+        {
+            { "allowmove",      HandleNpcSetAllowMovementCommand,  rbac::RBAC_PERM_COMMAND_NPC_SET_ALLOWMOVE,  Console::No },
+            { "entry",          HandleNpcSetEntryCommand,          rbac::RBAC_PERM_COMMAND_NPC_SET_ENTRY,      Console::No },
+            { "factionid",      HandleNpcSetFactionIdCommand,      rbac::RBAC_PERM_COMMAND_NPC_SET_FACTIONID,  Console::No },
+            { "flag",           HandleNpcSetFlagCommand,           rbac::RBAC_PERM_COMMAND_NPC_SET_FLAG,       Console::No },
+            { "level",          HandleNpcSetLevelCommand,          rbac::RBAC_PERM_COMMAND_NPC_SET_LEVEL,      Console::No },
+            { "link",           HandleNpcSetLinkCommand,           rbac::RBAC_PERM_COMMAND_NPC_SET_LINK,       Console::No },
+            { "model",          HandleNpcSetModelCommand,          rbac::RBAC_PERM_COMMAND_NPC_SET_MODEL,      Console::No },
+            { "movetype",       HandleNpcSetMoveTypeCommand,       rbac::RBAC_PERM_COMMAND_NPC_SET_MOVETYPE,   Console::No },
+            { "phase",          HandleNpcSetPhaseCommand,          rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE,      Console::No },
+            { "wanderdistance", HandleNpcSetWanderDistanceCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNDIST,  Console::No },
+            { "spawntime",      HandleNpcSetSpawnTimeCommand,      rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNTIME,  Console::No },
+            { "data",           HandleNpcSetDataCommand,           rbac::RBAC_PERM_COMMAND_NPC_SET_DATA,       Console::No },
         };
-        static std::vector<ChatCommand> npcCommandTable =
-        {
-            { "info",         rbac::RBAC_PERM_COMMAND_NPC_INFO,         false, &HandleNpcInfoCommand,              ""       },
-            { "near",         rbac::RBAC_PERM_COMMAND_NPC_NEAR,         false, &HandleNpcNearCommand,              ""       },
-            { "move",         rbac::RBAC_PERM_COMMAND_NPC_MOVE,         false, &HandleNpcMoveCommand,              ""       },
-            { "playemote",    rbac::RBAC_PERM_COMMAND_NPC_PLAYEMOTE,    false, &HandleNpcPlayEmoteCommand,         ""       },
-            { "say",          rbac::RBAC_PERM_COMMAND_NPC_SAY,          false, &HandleNpcSayCommand,               ""       },
-            { "textemote",    rbac::RBAC_PERM_COMMAND_NPC_TEXTEMOTE,    false, &HandleNpcTextEmoteCommand,         ""       },
-            { "whisper",      rbac::RBAC_PERM_COMMAND_NPC_WHISPER,      false, &HandleNpcWhisperCommand,           ""       },
-            { "yell",         rbac::RBAC_PERM_COMMAND_NPC_YELL,         false, &HandleNpcYellCommand,              ""       },
-            { "tame",         rbac::RBAC_PERM_COMMAND_NPC_TAME,         false, &HandleNpcTameCommand,              ""       },
-            { "spawngroup",   rbac::RBAC_PERM_COMMAND_NPC_SPAWNGROUP,   false, &HandleNpcSpawnGroup,               ""       },
-            { "despawngroup", rbac::RBAC_PERM_COMMAND_NPC_DESPAWNGROUP, false, &HandleNpcDespawnGroup,             ""       },
-            { "add",          rbac::RBAC_PERM_COMMAND_NPC_ADD,          false, nullptr,              "", npcAddCommandTable },
-            { "delete",       rbac::RBAC_PERM_COMMAND_NPC_DELETE,       false, nullptr,           "", npcDeleteCommandTable },
-            { "follow",       rbac::RBAC_PERM_COMMAND_NPC_FOLLOW,       false, nullptr,           "", npcFollowCommandTable },
-            { "set",          rbac::RBAC_PERM_COMMAND_NPC_SET,          false, nullptr,              "", npcSetCommandTable },
-            { "evade",        rbac::RBAC_PERM_COMMAND_NPC_EVADE,        false, &HandleNpcEvadeCommand,             ""       },
-            { "showloot",  rbac::RBAC_PERM_COMMAND_NPC_SHOWLOOT,        false, &HandleNpcShowLootCommand,          ""       },
+        static ChatCommandTable npcCommandTable =
+        {
+            { "add", npcAddCommandTable },
+            { "set", npcSetCommandTable },
+            { "info",           HandleNpcInfoCommand,              rbac::RBAC_PERM_COMMAND_NPC_INFO,           Console::No },
+            { "near",           HandleNpcNearCommand,              rbac::RBAC_PERM_COMMAND_NPC_NEAR,           Console::No },
+            { "move",           HandleNpcMoveCommand,              rbac::RBAC_PERM_COMMAND_NPC_MOVE,           Console::No },
+            { "playemote",      HandleNpcPlayEmoteCommand,         rbac::RBAC_PERM_COMMAND_NPC_PLAYEMOTE,      Console::No },
+            { "say",            HandleNpcSayCommand,               rbac::RBAC_PERM_COMMAND_NPC_SAY,            Console::No },
+            { "textemote",      HandleNpcTextEmoteCommand,         rbac::RBAC_PERM_COMMAND_NPC_TEXTEMOTE,      Console::No },
+            { "whisper",        HandleNpcWhisperCommand,           rbac::RBAC_PERM_COMMAND_NPC_WHISPER,        Console::No },
+            { "yell",           HandleNpcYellCommand,              rbac::RBAC_PERM_COMMAND_NPC_YELL,           Console::No },
+            { "tame",           HandleNpcTameCommand,              rbac::RBAC_PERM_COMMAND_NPC_TAME,           Console::No },
+            { "spawngroup",     HandleNpcSpawnGroup,               rbac::RBAC_PERM_COMMAND_NPC_SPAWNGROUP,     Console::No },
+            { "despawngroup",   HandleNpcDespawnGroup,             rbac::RBAC_PERM_COMMAND_NPC_DESPAWNGROUP,   Console::No },
+            { "delete",         HandleNpcDeleteCommand,            rbac::RBAC_PERM_COMMAND_NPC_DELETE,         Console::No },
+            { "delete item",    HandleNpcDeleteVendorItemCommand,  rbac::RBAC_PERM_COMMAND_NPC_DELETE_ITEM,    Console::No },
+            { "follow",         HandleNpcFollowCommand,            rbac::RBAC_PERM_COMMAND_NPC_FOLLOW,         Console::No },
+            { "follow stop",    HandleNpcUnFollowCommand,          rbac::RBAC_PERM_COMMAND_NPC_FOLLOW,         Console::No },
+            { "evade",          HandleNpcEvadeCommand,             rbac::RBAC_PERM_COMMAND_NPC_EVADE,          Console::No },
+            { "showloot",       HandleNpcShowLootCommand,          rbac::RBAC_PERM_COMMAND_NPC_SHOWLOOT,       Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "npc", rbac::RBAC_PERM_COMMAND_NPC, false, nullptr, "", npcCommandTable },
+            { "npc", npcCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_pet.cpp b/src/server/scripts/Commands/cs_pet.cpp
index bc60a0ce43d..f2582778cdc 100644
--- a/src/server/scripts/Commands/cs_pet.cpp
+++ b/src/server/scripts/Commands/cs_pet.cpp
@@ -26,6 +26,10 @@
 #include "SpellMgr.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 inline Pet* GetSelectedPlayerPetOrOwn(ChatHandler* handler)
 {
     if (Unit* target = handler->getSelectedUnit())
diff --git a/src/server/scripts/Commands/cs_quest.cpp b/src/server/scripts/Commands/cs_quest.cpp
index 751848c35bd..f901737fab7 100644
--- a/src/server/scripts/Commands/cs_quest.cpp
+++ b/src/server/scripts/Commands/cs_quest.cpp
@@ -34,6 +34,10 @@ EndScriptData */
 #include "ReputationMgr.h"
 #include "World.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class quest_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_rbac.cpp b/src/server/scripts/Commands/cs_rbac.cpp
index 851a1e28420..d745de91872 100644
--- a/src/server/scripts/Commands/cs_rbac.cpp
+++ b/src/server/scripts/Commands/cs_rbac.cpp
@@ -33,6 +33,10 @@ EndScriptData */
 #include "World.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 struct RBACCommandData
 {
     RBACCommandData(): id(0), realmId(0), rbac(nullptr), needDelete(false) { }
diff --git a/src/server/scripts/Commands/cs_reload.cpp b/src/server/scripts/Commands/cs_reload.cpp
index 75e7f8c6455..9efb9155dce 100644
--- a/src/server/scripts/Commands/cs_reload.cpp
+++ b/src/server/scripts/Commands/cs_reload.cpp
@@ -51,6 +51,10 @@ EndScriptData */
 #include "WaypointManager.h"
 #include "World.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class reload_commandscript : public CommandScript
 {
 public:
@@ -408,9 +412,13 @@ public:
 
     static bool HandleReloadCommandCommand(ChatHandler* handler, char const* /*args*/)
     {
-        ChatHandler::invalidateCommandTable();
-        handler->SendGlobalGMSysMessage("DB table `command` will be reloaded at next chat command use.");
-        return true;
+        TC_LOG_INFO("misc", "Reloading .command information...");
+        Trinity::ChatCommands::LoadCommandMap();
+        handler->SendGlobalGMSysMessage("DB table `command` reloaded.");
+
+        // do not log this invocation, otherwise we might crash (the command table we used to get here is no longer valid!)
+        handler->SetSentErrorMessage(true);
+        return false;
     }
 
     static bool HandleReloadOnKillReputationCommand(ChatHandler* handler, char const* /*args*/)
diff --git a/src/server/scripts/Commands/cs_reset.cpp b/src/server/scripts/Commands/cs_reset.cpp
index e95d0cd37b9..2cddb813ac1 100644
--- a/src/server/scripts/Commands/cs_reset.cpp
+++ b/src/server/scripts/Commands/cs_reset.cpp
@@ -37,6 +37,10 @@ EndScriptData */
 #include "World.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class reset_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_scene.cpp b/src/server/scripts/Commands/cs_scene.cpp
index cad61904f7c..ad474723b69 100644
--- a/src/server/scripts/Commands/cs_scene.cpp
+++ b/src/server/scripts/Commands/cs_scene.cpp
@@ -25,28 +25,30 @@
 #include "RBAC.h"
 #include "WorldSession.h"
 
+using namespace Trinity::ChatCommands;
+
 class scene_commandscript : public CommandScript
 {
 public:
     scene_commandscript() : CommandScript("scene_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> sceneCommandTable =
+        static ChatCommandTable sceneCommandTable =
         {
-            { "debug",          rbac::RBAC_PERM_COMMAND_SCENE_DEBUG,        false, &HandleDebugSceneCommand,        "" },
-            { "play",           rbac::RBAC_PERM_COMMAND_SCENE_PLAY,         false, &HandlePlaySceneCommand,         "" },
-            { "playpackage",    rbac::RBAC_PERM_COMMAND_SCENE_PLAY_PACKAGE, false, &HandlePlayScenePackageCommand,  "" },
-            { "cancel",         rbac::RBAC_PERM_COMMAND_SCENE_CANCEL,       false, &HandleCancelSceneCommand,       "" }
+            { "debug",          HandleDebugSceneCommand,       rbac::RBAC_PERM_COMMAND_SCENE_DEBUG,        Console::No },
+            { "play",           HandlePlaySceneCommand,        rbac::RBAC_PERM_COMMAND_SCENE_PLAY,         Console::No },
+            { "playpackage",    HandlePlayScenePackageCommand, rbac::RBAC_PERM_COMMAND_SCENE_PLAY_PACKAGE, Console::No },
+            { "cancel",         HandleCancelSceneCommand,      rbac::RBAC_PERM_COMMAND_SCENE_CANCEL,       Console::No }
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "scene",          rbac::RBAC_PERM_COMMAND_SCENE,              true, nullptr,                          "", sceneCommandTable }
+            { "scene",          sceneCommandTable }
         };
         return commandTable;
     }
 
-    static bool HandleDebugSceneCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleDebugSceneCommand(ChatHandler* handler)
     {
         if (Player* player = handler->GetSession()->GetPlayer())
         {
@@ -57,17 +59,8 @@ public:
         return true;
     }
 
-    static bool HandlePlaySceneCommand(ChatHandler* handler, char const* args)
+    static bool HandlePlaySceneCommand(ChatHandler* handler, uint32 sceneId)
     {
-        if (!*args)
-            return false;
-
-        char const* sceneIdStr = strtok((char*)args, " ");
-
-        if (!sceneIdStr)
-            return false;
-
-        uint32 sceneId = atoi(sceneIdStr);
         Player* target = handler->getSelectedPlayerOrSelf();
 
         if (!target)
@@ -84,19 +77,8 @@ public:
         return true;
     }
 
-    static bool HandlePlayScenePackageCommand(ChatHandler* handler, char const* args)
+    static bool HandlePlayScenePackageCommand(ChatHandler* handler, uint32 sceneScriptPackageId, Optional<uint32> flags)
     {
-        if (!*args)
-            return false;
-
-        char const* scenePackageIdStr = strtok((char*)args, " ");
-        char const* flagsStr = strtok(nullptr, "");
-
-        if (!scenePackageIdStr)
-            return false;
-
-        uint32 scenePackageId = atoi(scenePackageIdStr);
-        EnumFlag<SceneFlag> flags = flagsStr ? static_cast<SceneFlag>(atoi(flagsStr)) : SceneFlag::None;
         Player* target = handler->getSelectedPlayerOrSelf();
 
         if (!target)
@@ -106,18 +88,15 @@ public:
             return false;
         }
 
-        if (!sSceneScriptPackageStore.HasRecord(scenePackageId))
+        if (!sSceneScriptPackageStore.HasRecord(sceneScriptPackageId))
             return false;
 
-        target->GetSceneMgr().PlaySceneByPackageId(scenePackageId, flags);
+        target->GetSceneMgr().PlaySceneByPackageId(sceneScriptPackageId, static_cast<SceneFlag>(flags.value_or(0)));
         return true;
     }
 
-    static bool HandleCancelSceneCommand(ChatHandler* handler, char const* args)
+    static bool HandleCancelSceneCommand(ChatHandler* handler, uint32 sceneScriptPackageId)
     {
-        if (!*args)
-            return false;
-
         Player* target = handler->getSelectedPlayerOrSelf();
 
         if (!target)
@@ -127,12 +106,10 @@ public:
             return false;
         }
 
-        uint32 id = atoi((char*)args);
-
-        if (!sSceneScriptPackageStore.HasRecord(id))
+        if (!sSceneScriptPackageStore.HasRecord(sceneScriptPackageId))
             return false;
 
-        target->GetSceneMgr().CancelSceneByPackageId(id);
+        target->GetSceneMgr().CancelSceneByPackageId(sceneScriptPackageId);
         return true;
     }
 };
diff --git a/src/server/scripts/Commands/cs_send.cpp b/src/server/scripts/Commands/cs_send.cpp
index aedd128072d..d4f42b6c5f5 100644
--- a/src/server/scripts/Commands/cs_send.cpp
+++ b/src/server/scripts/Commands/cs_send.cpp
@@ -27,6 +27,10 @@
 #include "RBAC.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class send_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_server.cpp b/src/server/scripts/Commands/cs_server.cpp
index ea2ea7f5fb2..edc83157e2d 100644
--- a/src/server/scripts/Commands/cs_server.cpp
+++ b/src/server/scripts/Commands/cs_server.cpp
@@ -46,6 +46,10 @@ EndScriptData */
 #include <openssl/opensslv.h>
 #include <numeric>
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class server_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_tele.cpp b/src/server/scripts/Commands/cs_tele.cpp
index 9af0fe00e8e..06f277b0370 100644
--- a/src/server/scripts/Commands/cs_tele.cpp
+++ b/src/server/scripts/Commands/cs_tele.cpp
@@ -43,19 +43,19 @@ class tele_commandscript : public CommandScript
 public:
     tele_commandscript() : CommandScript("tele_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> teleCommandTable =
+        static ChatCommandTable teleCommandTable =
         {
-            { "add",   rbac::RBAC_PERM_COMMAND_TELE_ADD,   false, &HandleTeleAddCommand,   "" },
-            { "del",   rbac::RBAC_PERM_COMMAND_TELE_DEL,    true, &HandleTeleDelCommand,   "" },
-            { "name",  rbac::RBAC_PERM_COMMAND_TELE_NAME,   true, &HandleTeleNameCommand,  "" },
-            { "group", rbac::RBAC_PERM_COMMAND_TELE_GROUP, false, &HandleTeleGroupCommand, "" },
-            { "",      rbac::RBAC_PERM_COMMAND_TELE,       false, &HandleTeleCommand,      "" },
+            { "add",    HandleTeleAddCommand,   rbac::RBAC_PERM_COMMAND_TELE_ADD,   Console::No },
+            { "del",    HandleTeleDelCommand,   rbac::RBAC_PERM_COMMAND_TELE_DEL,   Console::Yes },
+            { "name",   HandleTeleNameCommand,  rbac::RBAC_PERM_COMMAND_TELE_NAME,  Console::Yes },
+            { "group",  HandleTeleGroupCommand, rbac::RBAC_PERM_COMMAND_TELE_GROUP, Console::No },
+            { "",       HandleTeleCommand,      rbac::RBAC_PERM_COMMAND_TELE,       Console::No },
         };
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "tele", rbac::RBAC_PERM_COMMAND_TELE, false, nullptr, "", teleCommandTable },
+            { "tele", teleCommandTable },
         };
         return commandTable;
     }
diff --git a/src/server/scripts/Commands/cs_ticket.cpp b/src/server/scripts/Commands/cs_ticket.cpp
index 81879aebaf7..f1b982b744b 100644
--- a/src/server/scripts/Commands/cs_ticket.cpp
+++ b/src/server/scripts/Commands/cs_ticket.cpp
@@ -35,6 +35,10 @@ EndScriptData */
 #include "World.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class ticket_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_titles.cpp b/src/server/scripts/Commands/cs_titles.cpp
index 7aebc7770c7..9f19fd600be 100644
--- a/src/server/scripts/Commands/cs_titles.cpp
+++ b/src/server/scripts/Commands/cs_titles.cpp
@@ -30,6 +30,10 @@ EndScriptData */
 #include "Player.h"
 #include "RBAC.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class titles_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/scripts/Commands/cs_wp.cpp b/src/server/scripts/Commands/cs_wp.cpp
index fb1fad6dff4..51606163eff 100644
--- a/src/server/scripts/Commands/cs_wp.cpp
+++ b/src/server/scripts/Commands/cs_wp.cpp
@@ -37,6 +37,10 @@ EndScriptData */
 #include "WaypointManager.h"
 #include "WorldSession.h"
 
+#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 class wp_commandscript : public CommandScript
 {
 public:
diff --git a/src/server/worldserver/CommandLine/CliRunnable.cpp b/src/server/worldserver/CommandLine/CliRunnable.cpp
index 5263d3ba3b6..a46d39478fe 100644
--- a/src/server/worldserver/CommandLine/CliRunnable.cpp
+++ b/src/server/worldserver/CommandLine/CliRunnable.cpp
@@ -39,54 +39,34 @@ static inline void PrintCliPrefix()
 }
 
 #if TRINITY_PLATFORM != TRINITY_PLATFORM_WINDOWS
-char* command_finder(char const* text, int state)
+namespace Trinity::Impl::Readline
 {
-    static size_t idx, len;
-    char const* ret;
-    std::vector<ChatCommand> const& cmd = ChatHandler::getCommandTable();
-
-    if (!state)
+    static std::vector<std::string> vec;
+    char* cli_unpack_vector(char const*, int state)
     {
-        idx = 0;
-        len = strlen(text);
+        static size_t i=0;
+        if (!state)
+            i = 0;
+        if (i < vec.size())
+            return strdup(vec[i++].c_str());
+        else
+            return nullptr;
     }
 
-    while (idx < cmd.size())
+    char** cli_completion(char const* text, int /*start*/, int /*end*/)
     {
-        ret = cmd[idx].Name;
-        if (!cmd[idx].AllowConsole)
-        {
-            ++idx;
-            continue;
-        }
-
-        ++idx;
-        //printf("Checking %s \n", cmd[idx].Name);
-        if (strncmp(ret, text, len) == 0)
-            return strdup(ret);
+        ::rl_attempted_completion_over = 1;
+        vec = Trinity::ChatCommands::GetAutoCompletionsFor(CliHandler(nullptr,nullptr), text);
+        return ::rl_completion_matches(text, &cli_unpack_vector);
     }
 
-    return nullptr;
-}
-
-char** cli_completion(char const* text, int start, int /*end*/)
-{
-    char** matches = nullptr;
-
-    if (start)
-        rl_bind_key('\t', rl_abort);
-    else
-        matches = rl_completion_matches((char*)text, &command_finder);
-    return matches;
-}
-
-int cli_hook_func()
-{
-       if (World::IsStopped())
-           rl_done = 1;
-       return 0;
+    int cli_hook_func()
+    {
+        if (World::IsStopped())
+            ::rl_done = 1;
+        return 0;
+    }
 }
-
 #endif
 
 void utf8print(void* /*arg*/, std::string_view str)
@@ -134,8 +114,12 @@ void CliThread()
     // later it will be printed after command queue updates
     PrintCliPrefix();
 #else
-    rl_attempted_completion_function = cli_completion;
-    rl_event_hook = cli_hook_func;
+    ::rl_attempted_completion_function = &Trinity::Impl::Readline::cli_completion;
+    {
+        static char BLANK = '\0';
+        ::rl_completer_word_break_characters = &BLANK;
+    }
+    ::rl_event_hook = &Trinity::Impl::Readline::cli_hook_func;
 #endif
 
     if (sConfigMgr->GetBoolDefault("BeepAtStart", true))
@@ -160,7 +144,7 @@ void CliThread()
         }
 #else
         char* command_str = readline(CLI_PREFIX);
-        rl_bind_key('\t', rl_complete);
+        ::rl_bind_key('\t', ::rl_complete);
         if (command_str != nullptr)
         {
             command = command_str;