Merge remote-tracking branch 'upstream/develop' into develop-upstream

Libraries/SPTarkov.Server.Assets/SPT_Data/database/locales/server/el.json

@@ -748,6 +748,7 @@
   "watermark-discord_url": "https://discord.sp-tarkov.com",
   "watermark-do_not_report": "ΜΗΝ ΤΟ ΑΝΑΦΕΡΕΤΕ",
   "watermark-free_of_charge": "Αυτή η εργασία είναι χωρίς χρέωση",
+  "watermark-issue_tracker_url": "https://github.com/sp-tarkov/server-csharp/",
   "watermark-modding_disabled": "ΑΥΤΗ Η ΕΚΔΟΣΗ ΕΧΕΙ ΑΠΕΝΕΡΓΟΠΟΙΗΜΈΝΕΣ ΤΙΣ ΤΡΟΠΟΠΟΙΗΣΕΙΣ ΑΠΟ ΤΟΝ ΔΙΑΚΟΜΙΣΤΗ",
   "watermark-no_support": "ΔΕΝ ΘΑ ΔΩΘΕΙ ΥΠΟΣΤΗΡΙΞΗ",
   "watermark-not_an_issue": "ΑΥΤΟ ΔΕΝ ΕΙΝΑΙ ΠΡΟΒΛΗΜΑ",

Libraries/SPTarkov.Server.Assets/SPT_Data/database/locales/server/it.json

@@ -75,6 +75,7 @@
   "dialog-chatbot_id_already_exists": "Il bot della chat: %s è già stato registrato, impossibile registrare il bot",
   "dialog-missing_item_template": "Oggetto tpl {{tpl}} non trovato nel database, impossibile inviare messaggio di type{{type}}, ignorato",
   "dialogue-unable_to_find_dialogs_in_profile": "Nessun oggetto di dialogo nel profilo: {{sessionId}}",
+  "dialogue-list_from_client_empty": "Non è stato possibile inviare alcun dialog object dal client: {{sessionId}}",
   "dialogue-unable_to_find_in_profile": "Nessun dialog nel profilo: {{sessionId}} con id: {{dialogueId}}",
   "event-unhandled_event": "[EVENTO INATTESO] %s",
   "executing_startup_callbacks": "Server: esecuzione delle chiamate all'avvio...",
@@ -153,6 +154,7 @@
   "inventory-unable_to_toggle_item_not_found": "Impossibile attivare o disattivare l'oggetto dell'inventario con id: %s, elemento non trovato",
   "item-durability_value_invalid_use_default": "getRepairableItemQualityValue() arma con tpl: %s il valore di durabilità è invalido, riportato al default 1",
   "item-invalid_tpl_item": "Impossibile trovare un oggetto con un tpl di: %s in Db",
+  "item-helper_no_items_for_barter": "Non sono stati trovati oggetti corrispondenti al seguente barter Id: %s",
   "launcher-missing_property": "Al profilo: %s manca la property descriptionLocaleKey",
   "launcher-profile-edgeofdarkness": "Uguale al profilo Prepare to Escape di live EFT ed in più; dimensioni del nascondiglio massime (10x68), oggetti/equipaggiamento extra, reputazione con i mercanti più alta, 1000 dollari, 500 euro",
   "launcher-profile-tournament": "Ha un contenitore sicuro da torneo ed una baionetta ExtremaRatio Fulcrum come arma da mischia. Mercato nero e ricettatore non accessibili. Tutti gli indumenti da Ragman sono sbloccati. Invia il codice 'TOURNAMENTGIFT' a SPT nella lista amici per sbloccare tutte le funzionalità del profilo.",
@@ -746,6 +748,7 @@
   "watermark-discord_url": "https://discord.sp-tarkov.com",
   "watermark-do_not_report": "NON SEGNALARLO",
   "watermark-free_of_charge": "Questo lavoro è gratuito",
+  "watermark-issue_tracker_url": "https://github.com/sp-tarkov/server-csharp/",
   "watermark-modding_disabled": "QUESTA BUILD HA LE MOD SERVER DISATTIVATE",
   "watermark-no_support": "NESSUN SUPPORTO SARA' FORNITO",
   "watermark-not_an_issue": "QUESTO NON É UN ERRORE",

Libraries/SPTarkov.Server.Assets/SPT_Data/database/locales/server/nl.json

@@ -75,6 +75,7 @@
   "dialog-chatbot_id_already_exists": "Chat bot: %s die geregistreerd wordt bestaat al, kan de bot niet registreren",
   "dialog-missing_item_template": "Kon item met tpl {{tpl}} niet vinden in db, kon bericht van type {{type}} niet verzenden, wordt overgeslagen",
   "dialogue-unable_to_find_dialogs_in_profile": "Geen dialoog object in profiel: {{sessionId}}",
+  "dialogue-list_from_client_empty": "Geen dialoog object verzonden van client: {{sessionId}}",
   "dialogue-unable_to_find_in_profile": "Geen dialoog in profiel: {{sessionId}} gevonden met id: {{dialogueId}}",
   "event-unhandled_event": "[ONBEHANDELDE EVENEMENT] %s",
   "executing_startup_callbacks": "Server: Uitvoeren van opstart terugkoppelingen...",
@@ -153,6 +154,7 @@
   "inventory-unable_to_toggle_item_not_found": "Niet in staat om inventaris item te schakelen met id: %s, item niet gevonden",
   "item-durability_value_invalid_use_default": "getRepairableItemQualityValue() wapen tpl: %s durabiliteit waarde is invalide, er wordt teruggevallen op 1",
   "item-invalid_tpl_item": "Kan geen voorwerp met tpl van: %s vinden in Db",
+  "item-helper_no_items_for_barter": "Geen items gevonden voor barter Id: %s",
   "launcher-missing_property": "Profiel: %s mist de eigenschap descriptionLocaleKey",
   "launcher-profile-edgeofdarkness": "Zelfde als Prepare To Escape plus; grotere stash (10x68), extra uitrusting/items, hogere start reputatie met traders, 1000 dollars, 500 euros",
   "launcher-profile-tournament": "Heeft een toernooi veilige container en ER Fulcrum Bayonet handgemeen wapen. Op de zwarte lijst van Flea en Fence. Alle Ragman kleding ontgrendeld. Stuur code 'TOURNAMENTGIFT' naar SPT op vriendenlijst om alle profiel functionaliteiten te ontgrendelen.",
@@ -746,6 +748,7 @@
   "watermark-discord_url": "https://discord.sp-tarkov.com",
   "watermark-do_not_report": "RAPPORTEER HET NIET",
   "watermark-free_of_charge": "Dit werk is gratis",
+  "watermark-issue_tracker_url": "https://github.com/sp-tarkov/server-csharp/",
   "watermark-modding_disabled": "DEZE BUILD HEEFT SERVER MODDEN UITGESCHAKELD",
   "watermark-no_support": "ER WORDT GEEN SUPPORT GEGEVEN",
   "watermark-not_an_issue": "DIT IS GEEN PROBLEEM",

Libraries/SPTarkov.Server.Assets/SPT_Data/database/locales/server/zh-cn.json

@@ -748,6 +748,7 @@
   "watermark-discord_url": "https://discord.sp-tarkov.com",
   "watermark-do_not_report": "不 要 报 告",
   "watermark-free_of_charge": "该软件免费",
+  "watermark-issue_tracker_url": "https://github.com/sp-tarkov/server-csharp/",
   "watermark-modding_disabled": "该 编 译 不 启 用 服 务 端 模 改",
   "watermark-no_support": "不 会 提 供 支 持",
   "watermark-not_an_issue": "这 不 是 个 问 题",

Libraries/SPTarkov.Server.Core/Callbacks/GameCallbacks.cs

@@ -62,7 +62,7 @@ public class GameCallbacks(
     ///     Handle client/game/config
     /// </summary>
     /// <returns></returns>
-    public ValueTask<string> GetGameConfig(string url, GameEmptyCrcRequestData info, MongoId sessionID)
+    public ValueTask<string> GetGameConfig(string url, EmptyRequestData info, MongoId sessionID)
     {
         return new ValueTask<string>(httpResponseUtil.GetBody(gameController.GetGameConfig(sessionID)));
     }

Libraries/SPTarkov.Server.Core/DI/Router.cs

@@ -52,7 +52,7 @@ public abstract class StaticRouter(JsonUtil jsonUtil, IEnumerable<RouteAction> r
             info = (IRequestData?)jsonUtil.Deserialize(body, type);
         }
 
-        return await action.action(url, info, sessionId, output);
+        return await action.action(url, info ?? new EmptyRequestData(), sessionId, output);
     }
 
     protected override IEnumerable<HandledRoute> GetHandledRoutes()
@@ -73,7 +73,7 @@ public abstract class DynamicRouter(JsonUtil jsonUtil, IEnumerable<RouteAction>
             info = (IRequestData?)jsonUtil.Deserialize(body, type);
         }
 
-        return await action.action(url, info, sessionID, output);
+        return await action.action(url, info ?? new EmptyRequestData(), sessionID, output);
     }
 
     protected override IEnumerable<HandledRoute> GetHandledRoutes()
@@ -102,5 +102,8 @@ public abstract class SaveLoadRouter : Router
 
 public record HandledRoute(string route, bool dynamic);
 
-public record RouteAction(string url, Func<string, IRequestData?, MongoId, string?, ValueTask<object>> action, Type? bodyType = null);
-//public action: (url: string, info: any, sessionID: string, output: string) => Promise<any>,
+public record RouteAction(string url, Func<string, IRequestData, MongoId, string?, ValueTask<object>> action, Type? bodyType = null);
+
+public record RouteAction<TRequest>(string url, Func<string, TRequest, MongoId, string?, ValueTask<string>> typedAction)
+    : RouteAction(url, async (url, info, sessionId, output) => await typedAction(url, (TRequest)info, sessionId, output), typeof(TRequest))
+    where TRequest : class;

Libraries/SPTarkov.Server.Core/Routers/Dynamic/BotDynamicRouter.cs

@@ -7,33 +7,29 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class BotDynamicRouter : DynamicRouter
-{
-    public BotDynamicRouter(JsonUtil jsonUtil, BotCallbacks botCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/singleplayer/settings/bot/limit/",
-                    async (url, info, sessionID, output) => await botCallbacks.GetBotLimit(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/bot/difficulty/",
-                    async (url, info, sessionID, output) => await botCallbacks.GetBotDifficulty(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/bot/difficulties",
-                    async (url, info, sessionID, output) =>
-                        await botCallbacks.GetAllBotDifficulties(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/bot/maxCap",
-                    async (url, info, sessionID, output) => await botCallbacks.GetBotCap(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/bot/getBotBehaviours/",
-                    async (url, info, sessionID, output) => await botCallbacks.GetBotBehaviours()
-                ),
-            ]
-        ) { }
-}
+public class BotDynamicRouter(JsonUtil jsonUtil, BotCallbacks botCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/bot/limit/",
+                async (url, info, sessionID, output) => await botCallbacks.GetBotLimit(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/bot/difficulty/",
+                async (url, info, sessionID, output) => await botCallbacks.GetBotDifficulty(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/bot/difficulties",
+                async (url, info, sessionID, output) => await botCallbacks.GetAllBotDifficulties(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/bot/maxCap",
+                async (url, info, sessionID, output) => await botCallbacks.GetBotCap(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/bot/getBotBehaviours/",
+                async (url, info, sessionID, output) => await botCallbacks.GetBotBehaviours()
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/BundleDynamicRouter.cs

@@ -7,16 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class BundleDynamicRouter : DynamicRouter
-{
-    public BundleDynamicRouter(JsonUtil jsonUtil, BundleCallbacks bundleCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/files/bundle",
-                    async (url, info, sessionID, output) => await bundleCallbacks.GetBundle(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class BundleDynamicRouter(JsonUtil jsonUtil, BundleCallbacks bundleCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/files/bundle",
+                async (url, info, sessionID, output) => await bundleCallbacks.GetBundle(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/CustomizationDynamicRouter.cs

@@ -7,17 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class CustomizationDynamicRouter : DynamicRouter
-{
-    public CustomizationDynamicRouter(JsonUtil jsonUtil, CustomizationCallbacks customizationCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/trading/customization/",
-                    async (url, info, sessionID, output) =>
-                        await customizationCallbacks.GetTraderSuits(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class CustomizationDynamicRouter(JsonUtil jsonUtil, CustomizationCallbacks customizationCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/trading/customization/",
+                async (url, info, sessionID, output) => await customizationCallbacks.GetTraderSuits(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/DataDynamicRouter.cs

@@ -7,24 +7,21 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class DataDynamicRouter : DynamicRouter
-{
-    public DataDynamicRouter(JsonUtil jsonUtil, DataCallbacks dataCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/menu/locale/",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetLocalesMenu(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/locale/",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetLocalesGlobal(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/items/prices/",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetItemPrices(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class DataDynamicRouter(JsonUtil jsonUtil, DataCallbacks dataCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/menu/locale/",
+                async (url, info, sessionID, output) => await dataCallbacks.GetLocalesMenu(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/locale/",
+                async (url, info, sessionID, output) => await dataCallbacks.GetLocalesGlobal(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/items/prices/",
+                async (url, info, sessionID, output) => await dataCallbacks.GetItemPrices(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/HttpDynamicRouter.cs

@@ -1,19 +1,17 @@
 using SPTarkov.DI.Annotations;
 using SPTarkov.Server.Core.DI;
+using SPTarkov.Server.Core.Models.Eft.Common;
 using SPTarkov.Server.Core.Utils;
 
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class HttpDynamicRouter : DynamicRouter
-{
-    public HttpDynamicRouter(ImageRouter imageRouter, JsonUtil jsonUtil)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(".jpg", async (_, _, _, _) => await imageRouter.GetImage()),
-                new RouteAction(".png", async (_, _, _, _) => await imageRouter.GetImage()),
-                new RouteAction(".ico", async (_, _, _, _) => await imageRouter.GetImage()),
-            ]
-        ) { }
-}
+public class HttpDynamicRouter(ImageRouter imageRouter, JsonUtil jsonUtil)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(".jpg", async (_, _, _, _) => await imageRouter.GetImage()),
+            new RouteAction<EmptyRequestData>(".png", async (_, _, _, _) => await imageRouter.GetImage()),
+            new RouteAction<EmptyRequestData>(".ico", async (_, _, _, _) => await imageRouter.GetImage()),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/InraidDynamicRouter.cs

@@ -7,21 +7,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class InraidDynamicRouter : DynamicRouter
+public class InraidDynamicRouter(JsonUtil jsonUtil, InraidCallbacks inraidCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<RegisterPlayerRequestData>(
+                "/client/location/getLocalloot",
+                async (url, info, sessionID, output) => await inraidCallbacks.RegisterPlayer(url, info, sessionID)
+            ),
+        ]
+    )
 {
-    public InraidDynamicRouter(JsonUtil jsonUtil, InraidCallbacks inraidCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/location/getLocalloot",
-                    async (url, info, sessionID, output) =>
-                        await inraidCallbacks.RegisterPlayer(url, info as RegisterPlayerRequestData, sessionID),
-                    typeof(RegisterPlayerRequestData)
-                ),
-            ]
-        ) { }
-
     public override string GetTopLevelRoute()
     {
         return "spt-name";

Libraries/SPTarkov.Server.Core/Routers/Dynamic/LocationDynamicRouter.cs

@@ -5,11 +5,8 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class LocationDynamicRouter : DynamicRouter
+public class LocationDynamicRouter(JsonUtil jsonUtil) : DynamicRouter(jsonUtil, [])
 {
-    public LocationDynamicRouter(JsonUtil jsonUtil)
-        : base(jsonUtil, []) { }
-
     public override string GetTopLevelRoute()
     {
         return "spt-loot";

Libraries/SPTarkov.Server.Core/Routers/Dynamic/NotifierDynamicRouter.cs

@@ -1,27 +1,31 @@
 using SPTarkov.DI.Annotations;
 using SPTarkov.Server.Core.Callbacks;
 using SPTarkov.Server.Core.DI;
+using SPTarkov.Server.Core.Models.Eft.Common;
 using SPTarkov.Server.Core.Utils;
 
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class NotifierDynamicRouter : DynamicRouter
-{
-    public NotifierDynamicRouter(JsonUtil jsonUtil, NotifierCallbacks notifierCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction("/?last_id", async (url, info, sessionID, _) => await notifierCallbacks.Notify(url, info, sessionID)),
-                new RouteAction("/notifierServer", async (url, info, sessionID, _) => await notifierCallbacks.Notify(url, info, sessionID)),
-                new RouteAction(
-                    "/push/notifier/get/",
-                    async (url, info, sessionID, _) => await notifierCallbacks.GetNotifier(url, info, sessionID)
-                ),
-                new RouteAction(
-                    "/push/notifier/get/",
-                    async (url, info, sessionID, _) => await notifierCallbacks.GetNotifier(url, info, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class NotifierDynamicRouter(JsonUtil jsonUtil, NotifierCallbacks notifierCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/?last_id",
+                async (url, info, sessionID, _) => await notifierCallbacks.Notify(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/notifierServer",
+                async (url, info, sessionID, _) => await notifierCallbacks.Notify(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/push/notifier/get/",
+                async (url, info, sessionID, _) => await notifierCallbacks.GetNotifier(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/push/notifier/get/",
+                async (url, info, sessionID, _) => await notifierCallbacks.GetNotifier(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Dynamic/TraderDynamicRouter.cs

@@ -7,20 +7,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Dynamic;
 
 [Injectable]
-public class TraderDynamicRouter : DynamicRouter
-{
-    public TraderDynamicRouter(JsonUtil jsonUtil, TraderCallbacks traderCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/trading/api/getTrader/",
-                    async (url, info, sessionID, output) => await traderCallbacks.GetTrader(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/trading/api/getTraderAssort/",
-                    async (url, info, sessionID, output) => await traderCallbacks.GetAssort(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class TraderDynamicRouter(JsonUtil jsonUtil, TraderCallbacks traderCallbacks)
+    : DynamicRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/trading/api/getTrader/",
+                async (url, info, sessionID, output) => await traderCallbacks.GetTrader(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/trading/api/getTraderAssort/",
+                async (url, info, sessionID, output) => await traderCallbacks.GetAssort(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/HttpRouter.cs

@@ -6,41 +6,16 @@ using SPTarkov.Server.Core.Models.Common;
 namespace SPTarkov.Server.Core.Routers;
 
 [Injectable]
-public class HttpRouter
+public class HttpRouter(IEnumerable<StaticRouter> staticRouters, IEnumerable<DynamicRouter> dynamicRoutes)
 {
-    protected readonly IEnumerable<DynamicRouter> _dynamicRoutes;
-    protected readonly IEnumerable<StaticRouter> _staticRouters;
-
-    public HttpRouter(IEnumerable<StaticRouter> staticRouters, IEnumerable<DynamicRouter> dynamicRoutes)
-    {
-        _staticRouters = staticRouters;
-        _dynamicRoutes = dynamicRoutes;
-    }
-
-    /*
-    protected groupBy<T>(list: T[], keyGetter: (t: T) => string): Map<string, T[]> {
-        const map: Map<string, T[]> = new Map();
-        for (const item of list) {
-            const key = keyGetter(item);
-            const collection = map.get(key);
-            if (!collection) {
-                map.set(key, [item]);
-            } else {
-                collection.push(item);
-            }
-        }
-        return map;
-    }
-    */
-
     public async ValueTask<string?> GetResponse(HttpRequest req, MongoId sessionID, string? body)
     {
         var wrapper = new ResponseWrapper("");
 
-        var handled = await HandleRoute(req, sessionID, wrapper, _staticRouters, false, body);
+        var handled = await HandleRoute(req, sessionID, wrapper, staticRouters, false, body);
         if (!handled)
         {
-            await HandleRoute(req, sessionID, wrapper, _dynamicRoutes, true, body);
+            await HandleRoute(req, sessionID, wrapper, dynamicRoutes, true, body);
         }
 
         return wrapper.Output;

Libraries/SPTarkov.Server.Core/Routers/Static/AchievementStaticRouter.cs

@@ -7,21 +7,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class AchievementStaticRouter : StaticRouter
-{
-    public AchievementStaticRouter(JsonUtil jsonUtil, AchievementCallbacks achievementCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/achievement/list",
-                    async (url, info, sessionID, output) =>
-                        await achievementCallbacks.GetAchievements(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/achievement/statistic",
-                    async (url, info, sessionID, output) => await achievementCallbacks.Statistic(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class AchievementStaticRouter(JsonUtil jsonUtil, AchievementCallbacks achievementCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/achievement/list",
+                async (url, info, sessionID, output) => await achievementCallbacks.GetAchievements(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/achievement/statistic",
+                async (url, info, sessionID, output) => await achievementCallbacks.Statistic(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/BotStaticRouter.cs

@@ -7,18 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class BotStaticRouter : StaticRouter
-{
-    public BotStaticRouter(JsonUtil jsonUtil, BotCallbacks botCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/game/bot/generate",
-                    async (url, info, sessionID, outout) =>
-                        await botCallbacks.GenerateBots(url, info as GenerateBotsRequestData, sessionID),
-                    typeof(GenerateBotsRequestData)
-                ),
-            ]
-        ) { }
-}
+public class BotStaticRouter(JsonUtil jsonUtil, BotCallbacks botCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<GenerateBotsRequestData>(
+                "/client/game/bot/generate",
+                async (url, info, sessionID, outout) => await botCallbacks.GenerateBots(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/BuildStaticRouter.cs

@@ -9,40 +9,29 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class BuildStaticRouter : StaticRouter
-{
-    public BuildStaticRouter(JsonUtil jsonUtil, BuildsCallbacks buildsCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/builds/list",
-                    async (url, info, sessionID, output) => await buildsCallbacks.GetBuilds(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/builds/magazine/save",
-                    async (url, info, sessionID, output) =>
-                        await buildsCallbacks.CreateMagazineTemplate(url, info as SetMagazineRequest, sessionID),
-                    typeof(SetMagazineRequest)
-                ),
-                new RouteAction(
-                    "/client/builds/weapon/save",
-                    async (url, info, sessionID, output) =>
-                        await buildsCallbacks.SetWeapon(url, info as PresetBuildActionRequestData, sessionID),
-                    typeof(PresetBuildActionRequestData)
-                ),
-                new RouteAction(
-                    "/client/builds/equipment/save",
-                    async (url, info, sessionID, output) =>
-                        await buildsCallbacks.SetEquipment(url, info as PresetBuildActionRequestData, sessionID),
-                    typeof(PresetBuildActionRequestData)
-                ),
-                new RouteAction(
-                    "/client/builds/delete",
-                    async (url, info, sessionID, output) =>
-                        await buildsCallbacks.DeleteBuild(url, info as RemoveBuildRequestData, sessionID),
-                    typeof(RemoveBuildRequestData)
-                ),
-            ]
-        ) { }
-}
+public class BuildStaticRouter(JsonUtil jsonUtil, BuildsCallbacks buildsCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/builds/list",
+                async (url, info, sessionID, output) => await buildsCallbacks.GetBuilds(url, info, sessionID)
+            ),
+            new RouteAction<SetMagazineRequest>(
+                "/client/builds/magazine/save",
+                async (url, info, sessionID, output) => await buildsCallbacks.CreateMagazineTemplate(url, info, sessionID)
+            ),
+            new RouteAction<PresetBuildActionRequestData>(
+                "/client/builds/weapon/save",
+                async (url, info, sessionID, output) => await buildsCallbacks.SetWeapon(url, info, sessionID)
+            ),
+            new RouteAction<PresetBuildActionRequestData>(
+                "/client/builds/equipment/save",
+                async (url, info, sessionID, output) => await buildsCallbacks.SetEquipment(url, info, sessionID)
+            ),
+            new RouteAction<RemoveBuildRequestData>(
+                "/client/builds/delete",
+                async (url, info, sessionID, output) => await buildsCallbacks.DeleteBuild(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/BundleStaticRouter.cs

@@ -7,16 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class BundleStaticRouter : StaticRouter
-{
-    public BundleStaticRouter(JsonUtil jsonUtil, BundleCallbacks bundleCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/singleplayer/bundles",
-                    async (url, info, sessionID, output) => await bundleCallbacks.GetBundles(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class BundleStaticRouter(JsonUtil jsonUtil, BundleCallbacks bundleCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/bundles",
+                async (url, info, sessionID, output) => await bundleCallbacks.GetBundles(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/ClientLogStaticRouter.cs

@@ -1,28 +1,28 @@
 using SPTarkov.DI.Annotations;
 using SPTarkov.Server.Core.Callbacks;
 using SPTarkov.Server.Core.DI;
+using SPTarkov.Server.Core.Models.Eft.Common;
 using SPTarkov.Server.Core.Models.Spt.Logging;
 using SPTarkov.Server.Core.Utils;
 
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class ClientLogStaticRouter : StaticRouter
-{
-    public ClientLogStaticRouter(JsonUtil jsonUtil, ClientLogCallbacks clientLogCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/singleplayer/log",
-                    async (url, info, sessionID, output) => await clientLogCallbacks.ClientLog(url, info as ClientLogRequest, sessionID),
-                    typeof(ClientLogRequest)
-                ),
-                new RouteAction("/singleplayer/release", async (url, info, sessionID, output) => await clientLogCallbacks.ReleaseNotes()),
-                new RouteAction(
-                    "/singleplayer/enableBSGlogging",
-                    async (url, info, sessionID, output) => await clientLogCallbacks.BsgLogging()
-                ),
-            ]
-        ) { }
-}
+public class ClientLogStaticRouter(JsonUtil jsonUtil, ClientLogCallbacks clientLogCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<ClientLogRequest>(
+                "/singleplayer/log",
+                async (url, info, sessionID, output) => await clientLogCallbacks.ClientLog(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/release",
+                async (url, info, sessionID, output) => await clientLogCallbacks.ReleaseNotes()
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/enableBSGlogging",
+                async (url, info, sessionID, output) => await clientLogCallbacks.BsgLogging()
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/CustomizationStaticRouter.cs

@@ -7,27 +7,21 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class CustomizationStaticRouter : StaticRouter
-{
-    public CustomizationStaticRouter(JsonUtil jsonUtil, CustomizationCallbacks customizationCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/trading/customization/storage",
-                    async (url, info, sessionID, output) =>
-                        await customizationCallbacks.GetCustomisationUnlocks(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/hideout/customization/offer/list",
-                    async (url, info, sessionID, output) =>
-                        await customizationCallbacks.GetHideoutCustomisation(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/customization/storage",
-                    async (url, info, sessionID, output) =>
-                        await customizationCallbacks.GetStorage(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class CustomizationStaticRouter(JsonUtil jsonUtil, CustomizationCallbacks customizationCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/trading/customization/storage",
+                async (url, info, sessionID, output) => await customizationCallbacks.GetCustomisationUnlocks(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/hideout/customization/offer/list",
+                async (url, info, sessionID, output) => await customizationCallbacks.GetHideoutCustomisation(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/customization/storage",
+                async (url, info, sessionID, output) => await customizationCallbacks.GetStorage(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/DataStaticRouter.cs

@@ -7,60 +7,53 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class DataStaticRouter : StaticRouter
-{
-    public DataStaticRouter(JsonUtil jsonUtil, DataCallbacks dataCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/settings",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetSettings(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/globals",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetGlobals(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/items",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetTemplateItems(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/handbook/templates",
-                    async (url, info, sessionID, output) =>
-                        await dataCallbacks.GetTemplateHandbook(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/customization",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetTemplateSuits(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/account/customization",
-                    async (url, info, sessionID, output) =>
-                        await dataCallbacks.GetTemplateCharacter(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/hideout/production/recipes",
-                    async (url, info, sessionID, output) =>
-                        await dataCallbacks.GetHideoutProduction(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/hideout/settings",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetHideoutSettings(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/hideout/areas",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetHideoutAreas(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/languages",
-                    async (url, info, sessionID, output) =>
-                        await dataCallbacks.GetLocalesLanguages(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/hideout/qte/list",
-                    async (url, info, sessionID, output) => await dataCallbacks.GetQteList(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class DataStaticRouter(JsonUtil jsonUtil, DataCallbacks dataCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/settings",
+                async (url, info, sessionID, output) => await dataCallbacks.GetSettings(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/globals",
+                async (url, info, sessionID, output) => await dataCallbacks.GetGlobals(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/items",
+                async (url, info, sessionID, output) => await dataCallbacks.GetTemplateItems(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/handbook/templates",
+                async (url, info, sessionID, output) => await dataCallbacks.GetTemplateHandbook(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/customization",
+                async (url, info, sessionID, output) => await dataCallbacks.GetTemplateSuits(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/account/customization",
+                async (url, info, sessionID, output) => await dataCallbacks.GetTemplateCharacter(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/hideout/production/recipes",
+                async (url, info, sessionID, output) => await dataCallbacks.GetHideoutProduction(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/hideout/settings",
+                async (url, info, sessionID, output) => await dataCallbacks.GetHideoutSettings(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/hideout/areas",
+                async (url, info, sessionID, output) => await dataCallbacks.GetHideoutAreas(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/languages",
+                async (url, info, sessionID, output) => await dataCallbacks.GetLocalesLanguages(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/hideout/qte/list",
+                async (url, info, sessionID, output) => await dataCallbacks.GetQteList(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/DialogStaticRouter.cs

@@ -9,157 +9,113 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class DialogStaticRouter : StaticRouter
-{
-    public DialogStaticRouter(JsonUtil jsonUtil, DialogueCallbacks dialogueCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/chatServer/list",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.GetChatServerList(url, info as GetChatServerListRequestData, sessionID),
-                    typeof(GetChatServerListRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/list",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.GetMailDialogList(url, info as GetMailDialogListRequestData, sessionID),
-                    typeof(GetMailDialogListRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/view",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.GetMailDialogView(url, info as GetMailDialogViewRequestData, sessionID),
-                    typeof(GetMailDialogViewRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/info",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.GetMailDialogInfo(url, info as GetMailDialogInfoRequestData, sessionID),
-                    typeof(GetMailDialogInfoRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/remove",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.RemoveDialog(url, info as RemoveDialogRequestData, sessionID),
-                    typeof(RemoveDialogRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/pin",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.PinDialog(url, info as PinDialogRequestData, sessionID),
-                    typeof(PinDialogRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/unpin",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.UnpinDialog(url, info as PinDialogRequestData, sessionID),
-                    typeof(PinDialogRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/read",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.SetRead(url, info as SetDialogReadRequestData, sessionID),
-                    typeof(SetDialogReadRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/getAllAttachments",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.GetAllAttachments(url, info as GetAllAttachmentsRequestData, sessionID),
-                    typeof(GetAllAttachmentsRequestData)
-                ),
-                new RouteAction(
-                    "/client/mail/msg/send",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.SendMessage(url, info as SendMessageRequest, sessionID),
-                    typeof(SendMessageRequest)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/clear",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.ClearMail(url, info as ClearMailMessageRequest, sessionID),
-                    typeof(ClearMailMessageRequest)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/group/create",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.CreateGroupMail(url, info as CreateGroupMailRequest, sessionID),
-                    typeof(CreateGroupMailRequest)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/group/owner/change",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.ChangeMailGroupOwner(url, info as ChangeGroupMailOwnerRequest, sessionID),
-                    typeof(ChangeGroupMailOwnerRequest)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/group/users/add",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.AddUserToMail(url, info as AddUserGroupMailRequest, sessionID),
-                    typeof(AddUserGroupMailRequest)
-                ),
-                new RouteAction(
-                    "/client/mail/dialog/group/users/remove",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.RemoveUserFromMail(url, info as RemoveUserGroupMailRequest, sessionID),
-                    typeof(RemoveUserGroupMailRequest)
-                ),
-                new RouteAction(
-                    "/client/friend/list",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.GetFriendList(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/friend/request/list/outbox",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.ListOutbox(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/friend/request/list/inbox",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.ListInbox(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/friend/request/send",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.SendFriendRequest(url, info as FriendRequestData, sessionID),
-                    typeof(FriendRequestData)
-                ),
-                new RouteAction(
-                    "/client/friend/request/accept-all",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.AcceptAllFriendRequests(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/friend/request/accept",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.AcceptFriendRequest(url, info as AcceptFriendRequestData, sessionID),
-                    typeof(AcceptFriendRequestData)
-                ),
-                new RouteAction(
-                    "/client/friend/request/decline",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.DeclineFriendRequest(url, info as DeclineFriendRequestData, sessionID),
-                    typeof(DeclineFriendRequestData)
-                ),
-                new RouteAction(
-                    "/client/friend/request/cancel",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.CancelFriendRequest(url, info as CancelFriendRequestData, sessionID),
-                    typeof(CancelFriendRequestData)
-                ),
-                new RouteAction(
-                    "/client/friend/delete",
-                    async (url, info, sessionID, output) =>
-                        await dialogueCallbacks.DeleteFriend(url, info as DeleteFriendRequest, sessionID),
-                    typeof(DeleteFriendRequest)
-                ),
-                new RouteAction(
-                    "/client/friend/ignore/set",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.IgnoreFriend(url, info as UIDRequestData, sessionID),
-                    typeof(UIDRequestData)
-                ),
-                new RouteAction(
-                    "/client/friend/ignore/remove",
-                    async (url, info, sessionID, output) => await dialogueCallbacks.UnIgnoreFriend(url, info as UIDRequestData, sessionID),
-                    typeof(UIDRequestData)
-                ),
-            ]
-        ) { }
-}
+public class DialogStaticRouter(JsonUtil jsonUtil, DialogueCallbacks dialogueCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<GetChatServerListRequestData>(
+                "/client/chatServer/list",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetChatServerList(url, info, sessionID)
+            ),
+            new RouteAction<GetMailDialogListRequestData>(
+                "/client/mail/dialog/list",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetMailDialogList(url, info, sessionID)
+            ),
+            new RouteAction<GetMailDialogViewRequestData>(
+                "/client/mail/dialog/view",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetMailDialogView(url, info, sessionID)
+            ),
+            new RouteAction<GetMailDialogInfoRequestData>(
+                "/client/mail/dialog/info",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetMailDialogInfo(url, info, sessionID)
+            ),
+            new RouteAction<RemoveDialogRequestData>(
+                "/client/mail/dialog/remove",
+                async (url, info, sessionID, output) => await dialogueCallbacks.RemoveDialog(url, info, sessionID)
+            ),
+            new RouteAction<PinDialogRequestData>(
+                "/client/mail/dialog/pin",
+                async (url, info, sessionID, output) => await dialogueCallbacks.PinDialog(url, info, sessionID)
+            ),
+            new RouteAction<PinDialogRequestData>(
+                "/client/mail/dialog/unpin",
+                async (url, info, sessionID, output) => await dialogueCallbacks.UnpinDialog(url, info, sessionID)
+            ),
+            new RouteAction<SetDialogReadRequestData>(
+                "/client/mail/dialog/read",
+                async (url, info, sessionID, output) => await dialogueCallbacks.SetRead(url, info, sessionID)
+            ),
+            new RouteAction<GetAllAttachmentsRequestData>(
+                "/client/mail/dialog/getAllAttachments",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetAllAttachments(url, info, sessionID)
+            ),
+            new RouteAction<SendMessageRequest>(
+                "/client/mail/msg/send",
+                async (url, info, sessionID, output) => await dialogueCallbacks.SendMessage(url, info, sessionID)
+            ),
+            new RouteAction<ClearMailMessageRequest>(
+                "/client/mail/dialog/clear",
+                async (url, info, sessionID, output) => await dialogueCallbacks.ClearMail(url, info, sessionID)
+            ),
+            new RouteAction<CreateGroupMailRequest>(
+                "/client/mail/dialog/group/create",
+                async (url, info, sessionID, output) => await dialogueCallbacks.CreateGroupMail(url, info, sessionID)
+            ),
+            new RouteAction<ChangeGroupMailOwnerRequest>(
+                "/client/mail/dialog/group/owner/change",
+                async (url, info, sessionID, output) => await dialogueCallbacks.ChangeMailGroupOwner(url, info, sessionID)
+            ),
+            new RouteAction<AddUserGroupMailRequest>(
+                "/client/mail/dialog/group/users/add",
+                async (url, info, sessionID, output) => await dialogueCallbacks.AddUserToMail(url, info, sessionID)
+            ),
+            new RouteAction<RemoveUserGroupMailRequest>(
+                "/client/mail/dialog/group/users/remove",
+                async (url, info, sessionID, output) => await dialogueCallbacks.RemoveUserFromMail(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/friend/list",
+                async (url, info, sessionID, output) => await dialogueCallbacks.GetFriendList(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/friend/request/list/outbox",
+                async (url, info, sessionID, output) => await dialogueCallbacks.ListOutbox(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/friend/request/list/inbox",
+                async (url, info, sessionID, output) => await dialogueCallbacks.ListInbox(url, info, sessionID)
+            ),
+            new RouteAction<FriendRequestData>(
+                "/client/friend/request/send",
+                async (url, info, sessionID, output) => await dialogueCallbacks.SendFriendRequest(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/friend/request/accept-all",
+                async (url, info, sessionID, output) => await dialogueCallbacks.AcceptAllFriendRequests(url, info, sessionID)
+            ),
+            new RouteAction<AcceptFriendRequestData>(
+                "/client/friend/request/accept",
+                async (url, info, sessionID, output) => await dialogueCallbacks.AcceptFriendRequest(url, info, sessionID)
+            ),
+            new RouteAction<DeclineFriendRequestData>(
+                "/client/friend/request/decline",
+                async (url, info, sessionID, output) => await dialogueCallbacks.DeclineFriendRequest(url, info, sessionID)
+            ),
+            new RouteAction<CancelFriendRequestData>(
+                "/client/friend/request/cancel",
+                async (url, info, sessionID, output) => await dialogueCallbacks.CancelFriendRequest(url, info, sessionID)
+            ),
+            new RouteAction<DeleteFriendRequest>(
+                "/client/friend/delete",
+                async (url, info, sessionID, output) => await dialogueCallbacks.DeleteFriend(url, info, sessionID)
+            ),
+            new RouteAction<UIDRequestData>(
+                "/client/friend/ignore/set",
+                async (url, info, sessionID, output) => await dialogueCallbacks.IgnoreFriend(url, info, sessionID)
+            ),
+            new RouteAction<UIDRequestData>(
+                "/client/friend/ignore/remove",
+                async (url, info, sessionID, output) => await dialogueCallbacks.UnIgnoreFriend(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/GameStaticRouter.cs

@@ -9,100 +9,81 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class GameStaticRouter : StaticRouter
-{
-    public GameStaticRouter(JsonUtil jsonUtil, GameCallbacks gameCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/game/config",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.GetGameConfig(url, info as GameEmptyCrcRequestData, sessionID),
-                    typeof(GameEmptyCrcRequestData)
-                ),
-                new RouteAction(
-                    "/client/putHWMetrics",
-                    async (url, info, sessionID, output) => await gameCallbacks.PutHwMetrics(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/mode",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetGameMode(url, info as GameModeRequestData, sessionID),
-                    typeof(GameModeRequestData)
-                ),
-                new RouteAction(
-                    "/client/server/list",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetServer(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/current",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetCurrentGroup(url, info as EmptyRequestData, sessionID),
-                    typeof(GameModeRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/version/validate",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.VersionValidate(url, info as VersionValidateRequestData, sessionID),
-                    typeof(VersionValidateRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/start",
-                    async (url, info, sessionID, output) => await gameCallbacks.GameStart(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/logout",
-                    async (url, info, sessionID, output) => await gameCallbacks.GameLogout(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/checkVersion",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.ValidateGameVersion(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/keepalive",
-                    async (url, info, sessionID, output) => await gameCallbacks.GameKeepalive(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/version",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetVersion(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/reports/lobby/send",
-                    async (url, info, sessionID, output) => await gameCallbacks.ReportNickname(url, info as UIDRequestData, sessionID),
-                    typeof(UIDRequestData)
-                ),
-                new RouteAction(
-                    "/client/report/send",
-                    async (url, info, sessionID, output) => await gameCallbacks.ReportNickname(url, info as UIDRequestData, sessionID),
-                    typeof(GameModeRequestData)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/getRaidTime",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetRaidTime(url, info as GetRaidTimeRequest, sessionID),
-                    typeof(GetRaidTimeRequest)
-                ),
-                new RouteAction(
-                    "/client/survey",
-                    async (url, info, sessionID, output) => await gameCallbacks.GetSurvey(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/survey/view",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.GetSurveyView(url, info as SendSurveyOpinionRequest, sessionID),
-                    typeof(SendSurveyOpinionRequest)
-                ),
-                new RouteAction(
-                    "/client/survey/opinion",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.SendSurveyOpinion(url, info as SendSurveyOpinionRequest, sessionID),
-                    typeof(SendSurveyOpinionRequest)
-                ),
-                new RouteAction(
-                    "/singleplayer/clientmods",
-                    async (url, info, sessionID, output) =>
-                        await gameCallbacks.ReceiveClientMods(url, info as SendClientModsRequest, sessionID),
-                    typeof(SendClientModsRequest)
-                ),
-            ]
-        ) { }
-}
+public class GameStaticRouter(JsonUtil jsonUtil, GameCallbacks gameCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/game/config",
+                async (url, info, sessionID, output) => await gameCallbacks.GetGameConfig(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/putHWMetrics",
+                async (url, info, sessionID, output) => await gameCallbacks.PutHwMetrics(url, info, sessionID)
+            ),
+            new RouteAction<GameModeRequestData>(
+                "/client/game/mode",
+                async (url, info, sessionID, output) => await gameCallbacks.GetGameMode(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/server/list",
+                async (url, info, sessionID, output) => await gameCallbacks.GetServer(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/current",
+                async (url, info, sessionID, output) => await gameCallbacks.GetCurrentGroup(url, info, sessionID)
+            ),
+            new RouteAction<VersionValidateRequestData>(
+                "/client/game/version/validate",
+                async (url, info, sessionID, output) => await gameCallbacks.VersionValidate(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/start",
+                async (url, info, sessionID, output) => await gameCallbacks.GameStart(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/logout",
+                async (url, info, sessionID, output) => await gameCallbacks.GameLogout(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/checkVersion",
+                async (url, info, sessionID, output) => await gameCallbacks.ValidateGameVersion(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/keepalive",
+                async (url, info, sessionID, output) => await gameCallbacks.GameKeepalive(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/version",
+                async (url, info, sessionID, output) => await gameCallbacks.GetVersion(url, info, sessionID)
+            ),
+            new RouteAction<UIDRequestData>(
+                "/client/reports/lobby/send",
+                async (url, info, sessionID, output) => await gameCallbacks.ReportNickname(url, info, sessionID)
+            ),
+            new RouteAction<UIDRequestData>(
+                "/client/report/send",
+                async (url, info, sessionID, output) => await gameCallbacks.ReportNickname(url, info, sessionID)
+            ),
+            new RouteAction<GetRaidTimeRequest>(
+                "/singleplayer/settings/getRaidTime",
+                async (url, info, sessionID, output) => await gameCallbacks.GetRaidTime(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/survey",
+                async (url, info, sessionID, output) => await gameCallbacks.GetSurvey(url, info, sessionID)
+            ),
+            new RouteAction<SendSurveyOpinionRequest>(
+                "/client/survey/view",
+                async (url, info, sessionID, output) => await gameCallbacks.GetSurveyView(url, info, sessionID)
+            ),
+            new RouteAction<SendSurveyOpinionRequest>(
+                "/client/survey/opinion",
+                async (url, info, sessionID, output) => await gameCallbacks.SendSurveyOpinion(url, info, sessionID)
+            ),
+            new RouteAction<SendClientModsRequest>(
+                "/singleplayer/clientmods",
+                async (url, info, sessionID, output) => await gameCallbacks.ReceiveClientMods(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/HealthStaticRouter.cs

@@ -7,17 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class HealthStaticRouter : StaticRouter
-{
-    public HealthStaticRouter(JsonUtil jsonUtil, HealthCallbacks healthCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/hideout/workout",
-                    async (url, info, sessionID, output) => await healthCallbacks.HandleWorkoutEffects(url, info as WorkoutData, sessionID),
-                    typeof(WorkoutData)
-                ),
-            ]
-        ) { }
-}
+public class HealthStaticRouter(JsonUtil jsonUtil, HealthCallbacks healthCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<WorkoutData>(
+                "/client/hideout/workout",
+                async (url, info, sessionID, output) => await healthCallbacks.HandleWorkoutEffects(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/InraidStaticRouter.cs

@@ -8,30 +8,25 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class InraidStaticRouter : StaticRouter
-{
-    public InraidStaticRouter(InraidCallbacks inRaidCallbacks, JsonUtil jsonUtil)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/raid/profile/scavsave",
-                    async (url, info, sessionID, output) => await inRaidCallbacks.SaveProgress(url, info as ScavSaveRequestData, sessionID),
-                    typeof(ScavSaveRequestData)
-                ),
-                new RouteAction(
-                    "/singleplayer/settings/raid/menu",
-                    async (url, info, sessionID, output) => await inRaidCallbacks.GetRaidMenuSettings()
-                ),
-                new RouteAction(
-                    "/singleplayer/scav/traitorscavhostile",
-                    async (url, info, sessionID, output) =>
-                        await inRaidCallbacks.GetTraitorScavHostileChance(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/bosstypes",
-                    async (url, info, sessionID, output) => await inRaidCallbacks.GetBossTypes(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class InraidStaticRouter(InraidCallbacks inRaidCallbacks, JsonUtil jsonUtil)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<ScavSaveRequestData>(
+                "/raid/profile/scavsave",
+                async (url, info, sessionID, output) => await inRaidCallbacks.SaveProgress(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/settings/raid/menu",
+                async (url, info, sessionID, output) => await inRaidCallbacks.GetRaidMenuSettings()
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/scav/traitorscavhostile",
+                async (url, info, sessionID, output) => await inRaidCallbacks.GetTraitorScavHostileChance(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/bosstypes",
+                async (url, info, sessionID, output) => await inRaidCallbacks.GetBossTypes(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/InsuranceStaticRouter.cs

@@ -7,18 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class InsuranceStaticRouter : StaticRouter
-{
-    public InsuranceStaticRouter(JsonUtil jsonUtil, InsuranceCallbacks insuranceCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/insurance/items/list/cost",
-                    async (url, info, sessionID, output) =>
-                        await insuranceCallbacks.GetInsuranceCost(url, info as GetInsuranceCostRequestData, sessionID),
-                    typeof(GetInsuranceCostRequestData)
-                ),
-            ]
-        ) { }
-}
+public class InsuranceStaticRouter(JsonUtil jsonUtil, InsuranceCallbacks insuranceCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<GetInsuranceCostRequestData>(
+                "/client/insurance/items/list/cost",
+                async (url, info, sessionID, output) => await insuranceCallbacks.GetInsuranceCost(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/ItemEventStaticRouter.cs

@@ -7,18 +7,13 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class ItemEventStaticRouter : StaticRouter
-{
-    public ItemEventStaticRouter(JsonUtil jsonUtil, ItemEventCallbacks itemEventCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/game/profile/items/moving",
-                    async (url, info, sessionID, output) =>
-                        await itemEventCallbacks.HandleEvents(url, info as ItemEventRouterRequest, sessionID),
-                    typeof(ItemEventRouterRequest)
-                ),
-            ]
-        ) { }
-}
+public class ItemEventStaticRouter(JsonUtil jsonUtil, ItemEventCallbacks itemEventCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<ItemEventRouterRequest>(
+                "/client/game/profile/items/moving",
+                async (url, info, sessionID, output) => await itemEventCallbacks.HandleEvents(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/LauncherStaticRouter.cs

@@ -8,61 +8,55 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class LauncherStaticRouter : StaticRouter
-{
-    public LauncherStaticRouter(LauncherCallbacks launcherCallbacks, JsonUtil jsonUtil)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction("/launcher/ping", async (url, _, sessionID, _) => await launcherCallbacks.Ping(url, null, sessionID)),
-                new RouteAction("/launcher/server/connect", async (_, _, _, _) => await launcherCallbacks.Connect()),
-                new RouteAction(
-                    "/launcher/profile/login",
-                    async (url, info, sessionID, _) => await launcherCallbacks.Login(url, info as LoginRequestData, sessionID),
-                    typeof(LoginRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/register",
-                    async (url, info, sessionID, _) => await launcherCallbacks.Register(url, info as RegisterData, sessionID),
-                    typeof(RegisterData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/get",
-                    async (url, info, sessionID, _) => await launcherCallbacks.Get(url, info as LoginRequestData, sessionID),
-                    typeof(LoginRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/change/username",
-                    async (url, info, sessionID, _) => await launcherCallbacks.ChangeUsername(url, info as ChangeRequestData, sessionID),
-                    typeof(ChangeRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/change/password",
-                    async (url, info, sessionID, _) => await launcherCallbacks.ChangePassword(url, info as ChangeRequestData, sessionID),
-                    typeof(ChangeRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/change/wipe",
-                    async (url, info, sessionID, _) => await launcherCallbacks.Wipe(url, info as RegisterData, sessionID),
-                    typeof(RegisterData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/remove",
-                    async (url, info, sessionID, _) => await launcherCallbacks.RemoveProfile(url, info as RemoveProfileData, sessionID),
-                    typeof(RemoveProfileData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/compatibleTarkovVersion",
-                    async (_, _, _, _) => await launcherCallbacks.GetCompatibleTarkovVersion()
-                ),
-                new RouteAction("/launcher/server/version", async (_, _, _, _) => await launcherCallbacks.GetServerVersion()),
-                new RouteAction("/launcher/server/loadedServerMods", async (_, _, _, _) => await launcherCallbacks.GetLoadedServerMods()),
-                new RouteAction(
-                    "/launcher/server/serverModsUsedByProfile",
-                    async (url, info, sessionID, _) =>
-                        await launcherCallbacks.GetServerModsProfileUsed(url, info as EmptyRequestData, sessionID),
-                    typeof(EmptyRequestData)
-                ),
-            ]
-        ) { }
-}
+public class LauncherStaticRouter(LauncherCallbacks launcherCallbacks, JsonUtil jsonUtil)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/launcher/ping",
+                async (url, info, sessionID, _) => await launcherCallbacks.Ping(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>("/launcher/server/connect", async (_, _, _, _) => await launcherCallbacks.Connect()),
+            new RouteAction<LoginRequestData>(
+                "/launcher/profile/login",
+                async (url, info, sessionID, _) => await launcherCallbacks.Login(url, info, sessionID)
+            ),
+            new RouteAction<RegisterData>(
+                "/launcher/profile/register",
+                async (url, info, sessionID, _) => await launcherCallbacks.Register(url, info, sessionID)
+            ),
+            new RouteAction<LoginRequestData>(
+                "/launcher/profile/get",
+                async (url, info, sessionID, _) => await launcherCallbacks.Get(url, info, sessionID)
+            ),
+            new RouteAction<ChangeRequestData>(
+                "/launcher/profile/change/username",
+                async (url, info, sessionID, _) => await launcherCallbacks.ChangeUsername(url, info, sessionID)
+            ),
+            new RouteAction<ChangeRequestData>(
+                "/launcher/profile/change/password",
+                async (url, info, sessionID, _) => await launcherCallbacks.ChangePassword(url, info, sessionID)
+            ),
+            new RouteAction<RegisterData>(
+                "/launcher/profile/change/wipe",
+                async (url, info, sessionID, _) => await launcherCallbacks.Wipe(url, info, sessionID)
+            ),
+            new RouteAction<RemoveProfileData>(
+                "/launcher/profile/remove",
+                async (url, info, sessionID, _) => await launcherCallbacks.RemoveProfile(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/profile/compatibleTarkovVersion",
+                async (_, _, _, _) => await launcherCallbacks.GetCompatibleTarkovVersion()
+            ),
+            new RouteAction<EmptyRequestData>("/launcher/server/version", async (_, _, _, _) => await launcherCallbacks.GetServerVersion()),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/server/loadedServerMods",
+                async (_, _, _, _) => await launcherCallbacks.GetLoadedServerMods()
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/server/serverModsUsedByProfile",
+                async (url, info, sessionID, _) => await launcherCallbacks.GetServerModsProfileUsed(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/LauncherV2StaticRouter.cs

@@ -1,44 +1,47 @@
 using SPTarkov.DI.Annotations;
 using SPTarkov.Server.Core.Callbacks;
 using SPTarkov.Server.Core.DI;
+using SPTarkov.Server.Core.Models.Eft.Common;
 using SPTarkov.Server.Core.Models.Eft.Launcher;
 using SPTarkov.Server.Core.Utils;
 
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class LauncherV2StaticRouter : StaticRouter
-{
-    public LauncherV2StaticRouter(LauncherV2Callbacks launcherV2Callbacks, JsonUtil jsonUtil)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction("/launcher/v2/ping", async (url, _, sessionID, _) => await launcherV2Callbacks.Ping()),
-                new RouteAction("/launcher/v2/types", async (url, _, sessionID, _) => await launcherV2Callbacks.Types()),
-                new RouteAction(
-                    "/launcher/v2/login",
-                    async (url, info, sessionID, _) => await launcherV2Callbacks.Login(info as LoginRequestData),
-                    typeof(LoginRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/v2/register",
-                    async (url, info, sessionID, _) => await launcherV2Callbacks.Register(info as RegisterData),
-                    typeof(RegisterData)
-                ),
-                new RouteAction(
-                    "/launcher/v2/passwordChange",
-                    async (url, info, sessionID, _) => await launcherV2Callbacks.PasswordChange(info as ChangeRequestData),
-                    typeof(ChangeRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/v2/remove",
-                    async (url, info, sessionID, _) => await launcherV2Callbacks.Remove(info as LoginRequestData),
-                    typeof(LoginRequestData)
-                ),
-                new RouteAction("/launcher/v2/version", async (url, _, sessionID, _) => await launcherV2Callbacks.CompatibleVersion()),
-                new RouteAction("/launcher/v2/mods", async (url, _, sessionID, _) => await launcherV2Callbacks.Mods()),
-                new RouteAction("/launcher/v2/profiles", async (url, _, sessionID, _) => await launcherV2Callbacks.Profiles()),
-                new RouteAction("/launcher/v2/profile", async (url, _, sessionID, _) => await launcherV2Callbacks.Profile(sessionID)),
-            ]
-        ) { }
-}
+public class LauncherV2StaticRouter(LauncherV2Callbacks launcherV2Callbacks, JsonUtil jsonUtil)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>("/launcher/v2/ping", async (url, _, sessionID, _) => await launcherV2Callbacks.Ping()),
+            new RouteAction<EmptyRequestData>("/launcher/v2/types", async (url, _, sessionID, _) => await launcherV2Callbacks.Types()),
+            new RouteAction<LoginRequestData>(
+                "/launcher/v2/login",
+                async (url, info, sessionID, _) => await launcherV2Callbacks.Login(info)
+            ),
+            new RouteAction<RegisterData>(
+                "/launcher/v2/register",
+                async (url, info, sessionID, _) => await launcherV2Callbacks.Register(info)
+            ),
+            new RouteAction<ChangeRequestData>(
+                "/launcher/v2/passwordChange",
+                async (url, info, sessionID, _) => await launcherV2Callbacks.PasswordChange(info)
+            ),
+            new RouteAction<LoginRequestData>(
+                "/launcher/v2/remove",
+                async (url, info, sessionID, _) => await launcherV2Callbacks.Remove(info)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/v2/version",
+                async (url, _, sessionID, _) => await launcherV2Callbacks.CompatibleVersion()
+            ),
+            new RouteAction<EmptyRequestData>("/launcher/v2/mods", async (url, _, sessionID, _) => await launcherV2Callbacks.Mods()),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/v2/profiles",
+                async (url, _, sessionID, _) => await launcherV2Callbacks.Profiles()
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/v2/profile",
+                async (url, _, sessionID, _) => await launcherV2Callbacks.Profile(sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/LocationStaticRouter.cs

@@ -8,23 +8,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class LocationStaticRouter : StaticRouter
-{
-    public LocationStaticRouter(JsonUtil jsonUtil, LocationCallbacks locationCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/locations",
-                    async (url, info, sessionID, output) =>
-                        await locationCallbacks.GetLocationData(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/airdrop/loot",
-                    async (url, info, sessionID, output) =>
-                        await locationCallbacks.GetAirdropLoot(url, info as GetAirdropLootRequest, sessionID),
-                    typeof(GetAirdropLootRequest)
-                ),
-            ]
-        ) { }
-}
+public class LocationStaticRouter(JsonUtil jsonUtil, LocationCallbacks locationCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/locations",
+                async (url, info, sessionID, output) => await locationCallbacks.GetLocationData(url, info, sessionID)
+            ),
+            new RouteAction<GetAirdropLootRequest>(
+                "/client/airdrop/loot",
+                async (url, info, sessionID, output) => await locationCallbacks.GetAirdropLoot(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/MatchStaticRouter.cs

@@ -9,154 +9,121 @@ using static SPTarkov.Server.Core.Services.MatchLocationService;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class MatchStaticRouter : StaticRouter
-{
-    public MatchStaticRouter(JsonUtil jsonUtil, MatchCallbacks matchCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/match/available",
-                    async (url, info, sessionID, output) => await matchCallbacks.ServerAvailable(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/updatePing",
-                    async (url, info, sessionID, output) => await matchCallbacks.UpdatePing(url, info as UpdatePingRequestData, sessionID),
-                    typeof(UpdatePingRequestData)
-                ),
-                new RouteAction(
-                    "/client/match/join",
-                    async (url, info, sessionID, output) => await matchCallbacks.JoinMatch(url, info as MatchGroupJoinRequest, sessionID),
-                    typeof(MatchGroupJoinRequest)
-                ),
-                new RouteAction(
-                    "/client/match/exit",
-                    async (url, info, sessionID, output) => await matchCallbacks.ExitMatch(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/delete",
-                    async (url, info, sessionID, output) => await matchCallbacks.DeleteGroup(url, info as DeleteGroupRequest, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/leave",
-                    async (url, info, sessionID, output) => await matchCallbacks.LeaveGroup(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/status",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.GetGroupStatus(url, info as MatchGroupStatusRequest, sessionID),
-                    typeof(MatchGroupStatusRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/start_game",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.StartGameAsGroupLeader(url, info as MatchGroupStartGameRequest, sessionID),
-                    typeof(MatchGroupStartGameRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/exit_from_menu",
-                    async (url, info, sessionID, output) => await matchCallbacks.ExitFromMenu(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/current",
-                    async (url, info, sessionID, output) => await matchCallbacks.GroupCurrent(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/looking/start",
-                    async (url, info, sessionID, output) => await matchCallbacks.StartGroupSearch(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/looking/stop",
-                    async (url, info, sessionID, output) => await matchCallbacks.StopGroupSearch(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/invite/send",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.SendGroupInvite(url, info as MatchGroupInviteSendRequest, sessionID),
-                    typeof(MatchGroupInviteSendRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/invite/accept",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.AcceptGroupInvite(url, info as RequestIdRequest, sessionID),
-                    typeof(RequestIdRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/invite/decline",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.DeclineGroupInvite(url, info as RequestIdRequest, sessionID),
-                    typeof(RequestIdRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/invite/cancel",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.CancelGroupInvite(url, info as RequestIdRequest, sessionID),
-                    typeof(RequestIdRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/invite/cancel-all",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.CancelAllGroupInvite(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/transfer",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.TransferGroup(url, info as MatchGroupTransferRequest, sessionID),
-                    typeof(MatchGroupTransferRequest)
-                ),
-                new RouteAction(
-                    "/client/match/group/raid/ready",
-                    async (url, info, sessionID, output) => await matchCallbacks.RaidReady(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/match/group/raid/not-ready",
-                    async (url, info, sessionID, output) => await matchCallbacks.NotRaidReady(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/putMetrics",
-                    async (url, info, sessionID, output) => await matchCallbacks.PutMetrics(url, info as PutMetricsRequestData, sessionID),
-                    typeof(PutMetricsRequestData)
-                ),
-                new RouteAction(
-                    "/client/analytics/event-disconnect",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.EventDisconnect(url, info as PutMetricsRequestData, sessionID),
-                    typeof(PutMetricsRequestData)
-                ),
-                new RouteAction(
-                    "/client/getMetricsConfig",
-                    async (url, info, sessionID, output) => await matchCallbacks.GetMetrics(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/raid/configuration",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.GetRaidConfiguration(url, info as GetRaidConfigurationRequestData, sessionID),
-                    typeof(GetRaidConfigurationRequestData)
-                ),
-                new RouteAction(
-                    "/client/raid/configuration-by-profile",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.GetConfigurationByProfile(url, info as GetRaidConfigurationRequestData, sessionID),
-                    typeof(GetRaidConfigurationRequestData)
-                ),
-                new RouteAction(
-                    "/client/match/group/player/remove",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.RemovePlayerFromGroup(url, info as MatchGroupPlayerRemoveRequest, sessionID),
-                    typeof(MatchGroupPlayerRemoveRequest)
-                ),
-                new RouteAction(
-                    "/client/match/local/start",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.StartLocalRaid(url, info as StartLocalRaidRequestData, sessionID),
-                    typeof(StartLocalRaidRequestData)
-                ),
-                new RouteAction(
-                    "/client/match/local/end",
-                    async (url, info, sessionID, output) =>
-                        await matchCallbacks.EndLocalRaid(url, info as EndLocalRaidRequestData, sessionID),
-                    typeof(EndLocalRaidRequestData)
-                ),
-            ]
-        ) { }
-}
+public class MatchStaticRouter(JsonUtil jsonUtil, MatchCallbacks matchCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/match/available",
+                async (url, info, sessionID, output) => await matchCallbacks.ServerAvailable(url, info, sessionID)
+            ),
+            new RouteAction<UpdatePingRequestData>(
+                "/client/match/updatePing",
+                async (url, info, sessionID, output) => await matchCallbacks.UpdatePing(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupJoinRequest>(
+                "/client/match/join",
+                async (url, info, sessionID, output) => await matchCallbacks.JoinMatch(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/exit",
+                async (url, info, sessionID, output) => await matchCallbacks.ExitMatch(url, info, sessionID)
+            ),
+            new RouteAction<DeleteGroupRequest>(
+                "/client/match/group/delete",
+                async (url, info, sessionID, output) => await matchCallbacks.DeleteGroup(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/leave",
+                async (url, info, sessionID, output) => await matchCallbacks.LeaveGroup(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupStatusRequest>(
+                "/client/match/group/status",
+                async (url, info, sessionID, output) => await matchCallbacks.GetGroupStatus(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupStartGameRequest>(
+                "/client/match/group/start_game",
+                async (url, info, sessionID, output) => await matchCallbacks.StartGameAsGroupLeader(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/exit_from_menu",
+                async (url, info, sessionID, output) => await matchCallbacks.ExitFromMenu(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/current",
+                async (url, info, sessionID, output) => await matchCallbacks.GroupCurrent(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/looking/start",
+                async (url, info, sessionID, output) => await matchCallbacks.StartGroupSearch(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/looking/stop",
+                async (url, info, sessionID, output) => await matchCallbacks.StopGroupSearch(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupInviteSendRequest>(
+                "/client/match/group/invite/send",
+                async (url, info, sessionID, output) => await matchCallbacks.SendGroupInvite(url, info, sessionID)
+            ),
+            new RouteAction<RequestIdRequest>(
+                "/client/match/group/invite/accept",
+                async (url, info, sessionID, output) => await matchCallbacks.AcceptGroupInvite(url, info, sessionID)
+            ),
+            new RouteAction<RequestIdRequest>(
+                "/client/match/group/invite/decline",
+                async (url, info, sessionID, output) => await matchCallbacks.DeclineGroupInvite(url, info, sessionID)
+            ),
+            new RouteAction<RequestIdRequest>(
+                "/client/match/group/invite/cancel",
+                async (url, info, sessionID, output) => await matchCallbacks.CancelGroupInvite(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/invite/cancel-all",
+                async (url, info, sessionID, output) => await matchCallbacks.CancelAllGroupInvite(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupTransferRequest>(
+                "/client/match/group/transfer",
+                async (url, info, sessionID, output) => await matchCallbacks.TransferGroup(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/raid/ready",
+                async (url, info, sessionID, output) => await matchCallbacks.RaidReady(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/match/group/raid/not-ready",
+                async (url, info, sessionID, output) => await matchCallbacks.NotRaidReady(url, info, sessionID)
+            ),
+            new RouteAction<PutMetricsRequestData>(
+                "/client/putMetrics",
+                async (url, info, sessionID, output) => await matchCallbacks.PutMetrics(url, info, sessionID)
+            ),
+            new RouteAction<PutMetricsRequestData>(
+                "/client/analytics/event-disconnect",
+                async (url, info, sessionID, output) => await matchCallbacks.EventDisconnect(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/getMetricsConfig",
+                async (url, info, sessionID, output) => await matchCallbacks.GetMetrics(url, info, sessionID)
+            ),
+            new RouteAction<GetRaidConfigurationRequestData>(
+                "/client/raid/configuration",
+                async (url, info, sessionID, output) => await matchCallbacks.GetRaidConfiguration(url, info, sessionID)
+            ),
+            new RouteAction<GetRaidConfigurationRequestData>(
+                "/client/raid/configuration-by-profile",
+                async (url, info, sessionID, output) => await matchCallbacks.GetConfigurationByProfile(url, info, sessionID)
+            ),
+            new RouteAction<MatchGroupPlayerRemoveRequest>(
+                "/client/match/group/player/remove",
+                async (url, info, sessionID, output) => await matchCallbacks.RemovePlayerFromGroup(url, info, sessionID)
+            ),
+            new RouteAction<StartLocalRaidRequestData>(
+                "/client/match/local/start",
+                async (url, info, sessionID, output) => await matchCallbacks.StartLocalRaid(url, info, sessionID)
+            ),
+            new RouteAction<EndLocalRaidRequestData>(
+                "/client/match/local/end",
+                async (url, info, sessionID, output) => await matchCallbacks.EndLocalRaid(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/NotifierStaticRouter.cs

@@ -8,22 +8,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class NotifierStaticRouter : StaticRouter
-{
-    public NotifierStaticRouter(JsonUtil jsonUtil, NotifierCallbacks notifierCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/notifier/channel/create",
-                    async (url, info, sessionID, output) =>
-                        await notifierCallbacks.CreateNotifierChannel(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/profile/select",
-                    async (url, info, sessionID, output) => await notifierCallbacks.SelectProfile(url, info as UIDRequestData, sessionID),
-                    typeof(UIDRequestData)
-                ),
-            ]
-        ) { }
-}
+public class NotifierStaticRouter(JsonUtil jsonUtil, NotifierCallbacks notifierCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/notifier/channel/create",
+                async (url, info, sessionID, output) => await notifierCallbacks.CreateNotifierChannel(url, info, sessionID)
+            ),
+            new RouteAction<UIDRequestData>(
+                "/client/game/profile/select",
+                async (url, info, sessionID, output) => await notifierCallbacks.SelectProfile(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/PrestigeStaticRouter.cs

@@ -8,22 +8,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class PrestigeStaticRouter : StaticRouter
-{
-    public PrestigeStaticRouter(JsonUtil jsonUtil, PrestigeCallbacks prestigeCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/prestige/list",
-                    async (url, info, sessionID, output) => await prestigeCallbacks.GetPrestige(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/prestige/obtain",
-                    async (url, info, sessionID, output) =>
-                        await prestigeCallbacks.ObtainPrestige(url, info as ObtainPrestigeRequestList, sessionID),
-                    typeof(ObtainPrestigeRequestList)
-                ),
-            ]
-        ) { }
-}
+public class PrestigeStaticRouter(JsonUtil jsonUtil, PrestigeCallbacks prestigeCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/prestige/list",
+                async (url, info, sessionID, output) => await prestigeCallbacks.GetPrestige(url, info, sessionID)
+            ),
+            new RouteAction<ObtainPrestigeRequestList>(
+                "/client/prestige/obtain",
+                async (url, info, sessionID, output) => await prestigeCallbacks.ObtainPrestige(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/ProfileStaticRouter.cs

@@ -9,83 +9,61 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class ProfileStaticRouter : StaticRouter
-{
-    public ProfileStaticRouter(ProfileCallbacks profileCallbacks, JsonUtil jsonUtil)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/game/profile/create",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.CreateProfile(url, info as ProfileCreateRequestData, sessionID),
-                    typeof(ProfileCreateRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/profile/list",
-                    async (url, info, sessionID, output) => await profileCallbacks.GetProfileData(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/profile/savage/regenerate",
-                    async (url, info, sessionID, output) => await profileCallbacks.RegenerateScav(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/game/profile/voice/change",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.ChangeVoice(url, info as ProfileChangeVoiceRequestData, sessionID),
-                    typeof(ProfileChangeVoiceRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/profile/nickname/change",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.ChangeNickname(url, info as ProfileChangeNicknameRequestData, sessionID),
-                    typeof(ProfileChangeNicknameRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/profile/nickname/validate",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.ValidateNickname(url, info as ValidateNicknameRequestData, sessionID),
-                    typeof(ValidateNicknameRequestData)
-                ),
-                new RouteAction(
-                    "/client/game/profile/nickname/reserved",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetReservedNickname(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/profile/status",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetProfileStatus(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/profile/view",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetOtherProfile(url, info as GetOtherProfileRequest, sessionID),
-                    typeof(GetOtherProfileRequest)
-                ),
-                new RouteAction(
-                    "/client/profile/settings",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetProfileSettings(url, info as GetProfileSettingsRequest, sessionID),
-                    typeof(GetProfileSettingsRequest)
-                ),
-                new RouteAction(
-                    "/client/game/profile/search",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.SearchProfiles(url, info as SearchProfilesRequestData, sessionID),
-                    typeof(SearchProfilesRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profile/info",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetMiniProfile(url, info as GetMiniProfileRequestData, sessionID),
-                    typeof(GetMiniProfileRequestData)
-                ),
-                new RouteAction(
-                    "/launcher/profiles",
-                    async (url, info, sessionID, output) =>
-                        await profileCallbacks.GetAllMiniProfiles(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class ProfileStaticRouter(ProfileCallbacks profileCallbacks, JsonUtil jsonUtil)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<ProfileCreateRequestData>(
+                "/client/game/profile/create",
+                async (url, info, sessionID, output) => await profileCallbacks.CreateProfile(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/profile/list",
+                async (url, info, sessionID, output) => await profileCallbacks.GetProfileData(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/profile/savage/regenerate",
+                async (url, info, sessionID, output) => await profileCallbacks.RegenerateScav(url, info, sessionID)
+            ),
+            new RouteAction<ProfileChangeVoiceRequestData>(
+                "/client/game/profile/voice/change",
+                async (url, info, sessionID, output) => await profileCallbacks.ChangeVoice(url, info, sessionID)
+            ),
+            new RouteAction<ProfileChangeNicknameRequestData>(
+                "/client/game/profile/nickname/change",
+                async (url, info, sessionID, output) => await profileCallbacks.ChangeNickname(url, info, sessionID)
+            ),
+            new RouteAction<ValidateNicknameRequestData>(
+                "/client/game/profile/nickname/validate",
+                async (url, info, sessionID, output) => await profileCallbacks.ValidateNickname(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/game/profile/nickname/reserved",
+                async (url, info, sessionID, output) => await profileCallbacks.GetReservedNickname(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/profile/status",
+                async (url, info, sessionID, output) => await profileCallbacks.GetProfileStatus(url, info, sessionID)
+            ),
+            new RouteAction<GetOtherProfileRequest>(
+                "/client/profile/view",
+                async (url, info, sessionID, output) => await profileCallbacks.GetOtherProfile(url, info, sessionID)
+            ),
+            new RouteAction<GetProfileSettingsRequest>(
+                "/client/profile/settings",
+                async (url, info, sessionID, output) => await profileCallbacks.GetProfileSettings(url, info, sessionID)
+            ),
+            new RouteAction<SearchProfilesRequestData>(
+                "/client/game/profile/search",
+                async (url, info, sessionID, output) => await profileCallbacks.SearchProfiles(url, info, sessionID)
+            ),
+            new RouteAction<GetMiniProfileRequestData>(
+                "/launcher/profile/info",
+                async (url, info, sessionID, output) => await profileCallbacks.GetMiniProfile(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/launcher/profiles",
+                async (url, info, sessionID, output) => await profileCallbacks.GetAllMiniProfiles(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/QuestStaticRouter.cs

@@ -8,21 +8,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class QuestStaticRouter : StaticRouter
-{
-    public QuestStaticRouter(JsonUtil jsonUtil, QuestCallbacks questCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/quest/list",
-                    async (url, info, sessionID, output) => await questCallbacks.ListQuests(url, info as ListQuestsRequestData, sessionID),
-                    typeof(ListQuestsRequestData)
-                ),
-                new RouteAction(
-                    "/client/repeatalbeQuests/activityPeriods",
-                    async (url, info, sessionID, output) => await questCallbacks.ActivityPeriods(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class QuestStaticRouter(JsonUtil jsonUtil, QuestCallbacks questCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<ListQuestsRequestData>(
+                "/client/quest/list",
+                async (url, info, sessionID, output) => await questCallbacks.ListQuests(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/repeatalbeQuests/activityPeriods",
+                async (url, info, sessionID, output) => await questCallbacks.ActivityPeriods(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/RagfairStaticRouter.cs

@@ -8,50 +8,37 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class RagfairStaticRouter : StaticRouter
-{
-    public RagfairStaticRouter(JsonUtil jsonUtil, RagfairCallbacks ragfairCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/ragfair/search",
-                    async (url, info, sessionID, output) => await ragfairCallbacks.Search(url, info as SearchRequestData, sessionID),
-                    typeof(SearchRequestData)
-                ),
-                new RouteAction(
-                    "/client/ragfair/find",
-                    async (url, info, sessionID, output) => await ragfairCallbacks.Search(url, info as SearchRequestData, sessionID),
-                    typeof(SearchRequestData)
-                ),
-                new RouteAction(
-                    "/client/ragfair/itemMarketPrice",
-                    async (url, info, sessionID, output) =>
-                        await ragfairCallbacks.GetMarketPrice(url, info as GetMarketPriceRequestData, sessionID),
-                    typeof(GetMarketPriceRequestData)
-                ),
-                new RouteAction(
-                    "/client/ragfair/offerfees",
-                    async (url, info, sessionID, output) =>
-                        await ragfairCallbacks.StorePlayerOfferTaxAmount(url, info as StorePlayerOfferTaxAmountRequestData, sessionID),
-                    typeof(StorePlayerOfferTaxAmountRequestData)
-                ),
-                new RouteAction(
-                    "/client/reports/ragfair/send",
-                    async (url, info, sessionID, output) =>
-                        await ragfairCallbacks.SendReport(url, info as SendRagfairReportRequestData, sessionID),
-                    typeof(SendRagfairReportRequestData)
-                ),
-                new RouteAction(
-                    "/client/items/prices",
-                    async (url, info, sessionID, output) => await ragfairCallbacks.GetFleaPrices(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/ragfair/offer/findbyid",
-                    async (url, info, sessionID, output) =>
-                        await ragfairCallbacks.GetFleaOfferById(url, info as GetRagfairOfferByIdRequest, sessionID),
-                    typeof(GetRagfairOfferByIdRequest)
-                ),
-            ]
-        ) { }
-}
+public class RagfairStaticRouter(JsonUtil jsonUtil, RagfairCallbacks ragfairCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<SearchRequestData>(
+                "/client/ragfair/search",
+                async (url, info, sessionID, output) => await ragfairCallbacks.Search(url, info, sessionID)
+            ),
+            new RouteAction<SearchRequestData>(
+                "/client/ragfair/find",
+                async (url, info, sessionID, output) => await ragfairCallbacks.Search(url, info, sessionID)
+            ),
+            new RouteAction<GetMarketPriceRequestData>(
+                "/client/ragfair/itemMarketPrice",
+                async (url, info, sessionID, output) => await ragfairCallbacks.GetMarketPrice(url, info, sessionID)
+            ),
+            new RouteAction<StorePlayerOfferTaxAmountRequestData>(
+                "/client/ragfair/offerfees",
+                async (url, info, sessionID, output) => await ragfairCallbacks.StorePlayerOfferTaxAmount(url, info, sessionID)
+            ),
+            new RouteAction<SendRagfairReportRequestData>(
+                "/client/reports/ragfair/send",
+                async (url, info, sessionID, output) => await ragfairCallbacks.SendReport(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/items/prices",
+                async (url, info, sessionID, output) => await ragfairCallbacks.GetFleaPrices(url, info, sessionID)
+            ),
+            new RouteAction<GetRagfairOfferByIdRequest>(
+                "/client/ragfair/offer/findbyid",
+                async (url, info, sessionID, output) => await ragfairCallbacks.GetFleaOfferById(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/TraderStaticRouter.cs

@@ -7,22 +7,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class TraderStaticRouter : StaticRouter
-{
-    public TraderStaticRouter(JsonUtil jsonUtil, TraderCallbacks traderCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/trading/api/traderSettings",
-                    async (url, info, sessionID, output) =>
-                        await traderCallbacks.GetTraderSettings(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/singleplayer/moddedTraders",
-                    async (url, info, sessionID, output) =>
-                        await traderCallbacks.GetModdedTraderData(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class TraderStaticRouter(JsonUtil jsonUtil, TraderCallbacks traderCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/trading/api/traderSettings",
+                async (url, info, sessionID, output) => await traderCallbacks.GetTraderSettings(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/singleplayer/moddedTraders",
+                async (url, info, sessionID, output) => await traderCallbacks.GetModdedTraderData(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Routers/Static/WeatherStaticRouter.cs

@@ -7,20 +7,17 @@ using SPTarkov.Server.Core.Utils;
 namespace SPTarkov.Server.Core.Routers.Static;
 
 [Injectable]
-public class WeatherStaticRouter : StaticRouter
-{
-    public WeatherStaticRouter(JsonUtil jsonUtil, WeatherCallbacks weatherCallbacks)
-        : base(
-            jsonUtil,
-            [
-                new RouteAction(
-                    "/client/weather",
-                    async (url, info, sessionID, output) => await weatherCallbacks.GetWeather(url, info as EmptyRequestData, sessionID)
-                ),
-                new RouteAction(
-                    "/client/localGame/weather",
-                    async (url, info, sessionID, output) => await weatherCallbacks.GetLocalWeather(url, info as EmptyRequestData, sessionID)
-                ),
-            ]
-        ) { }
-}
+public class WeatherStaticRouter(JsonUtil jsonUtil, WeatherCallbacks weatherCallbacks)
+    : StaticRouter(
+        jsonUtil,
+        [
+            new RouteAction<EmptyRequestData>(
+                "/client/weather",
+                async (url, info, sessionID, output) => await weatherCallbacks.GetWeather(url, info, sessionID)
+            ),
+            new RouteAction<EmptyRequestData>(
+                "/client/localGame/weather",
+                async (url, info, sessionID, output) => await weatherCallbacks.GetLocalWeather(url, info, sessionID)
+            ),
+        ]
+    ) { }

Libraries/SPTarkov.Server.Core/Servers/Http/SptHttpListener.cs

@@ -25,14 +25,8 @@ public class SptHttpListener(
     ServerLocalisationService serverLocalisationService
 ) : IHttpListener
 {
-    // We want to read 1KB at a time, for most request this is already big enough
-    private const int BodyReadBufferSize = 1024 * 1;
-
     private static readonly ImmutableHashSet<string> SupportedMethods = ["GET", "PUT", "POST"];
 
-    protected readonly HttpRouter _router = httpRouter;
-    protected readonly IEnumerable<ISerializer> _serializers = serializers;
-
     public bool CanHandle(MongoId _, HttpRequest req)
     {
         return SupportedMethods.Contains(req.Method);
@@ -60,33 +54,16 @@ public class SptHttpListener(
                 var requestCompressed = req.Method == "PUT" || requestIsCompressed;
 
                 string body;
-                using MemoryStream bufferStream = new();
-
-                var buffer = new byte[BodyReadBufferSize];
-                int bytesRead;
-
-                while ((bytesRead = await req.Body.ReadAsync(buffer)) > 0)
-                {
-                    await bufferStream.WriteAsync(buffer.AsMemory(0, bytesRead));
-                }
-
-                bufferStream.Position = 0;
 
                 if (requestCompressed)
                 {
-                    await using var deflateStream = new ZLibStream(bufferStream, CompressionMode.Decompress);
-                    await using var decompressedStream = new MemoryStream();
-                    await deflateStream.CopyToAsync(decompressedStream);
-                    decompressedStream.Position = 0;
-
-                    using var reader = new StreamReader(decompressedStream, Encoding.UTF8);
+                    await using var deflateStream = new ZLibStream(req.Body, CompressionMode.Decompress);
+                    using var reader = new StreamReader(deflateStream, Encoding.UTF8);
                     body = await reader.ReadToEndAsync();
                 }
                 else
                 {
-                    // No decompression needed, decode directly from the bufferStream's buffer
-                    bufferStream.Position = 0;
-                    using var reader = new StreamReader(bufferStream, Encoding.UTF8);
+                    using var reader = new StreamReader(req.Body, Encoding.UTF8);
                     body = await reader.ReadToEndAsync();
                 }
 
@@ -139,7 +116,7 @@ public class SptHttpListener(
         }
 
         // Not debug, minority of requests need a serializer to do the job (IMAGE/BUNDLE/NOTIFY)
-        var serialiser = _serializers.FirstOrDefault(x => x.CanHandle(output));
+        var serialiser = serializers.FirstOrDefault(x => x.CanHandle(output));
         if (serialiser != null)
         {
             await serialiser.Serialize(sessionID, req, resp, bodyInfo);
@@ -179,7 +156,7 @@ public class SptHttpListener(
 
     public async ValueTask<string> GetResponse(MongoId sessionId, HttpRequest req, string? body)
     {
-        var output = await _router.GetResponse(req, sessionId, body);
+        var output = await httpRouter.GetResponse(req, sessionId, body);
 
         // Route doesn't exist or response is not properly set up
         if (string.IsNullOrEmpty(output))
@@ -203,30 +180,23 @@ public class SptHttpListener(
         resp.StatusCode = 200;
         resp.ContentType = "application/json";
         resp.Headers.Append("Set-Cookie", $"PHPSESSID={sessionID.ToString()}");
+
         if (!string.IsNullOrEmpty(output))
         {
             await resp.WriteAsync(output);
         }
-
-        await resp.StartAsync();
-        await resp.CompleteAsync();
     }
 
-    public async Task SendZlibJson(HttpResponse resp, string? output, MongoId sessionID)
+    public async Task SendZlibJson(HttpResponse resp, string output, MongoId sessionID)
     {
-        using (var ms = new MemoryStream())
+        resp.StatusCode = 200;
+        resp.ContentType = "application/json";
+        resp.Headers.Append("Set-Cookie", $"PHPSESSID={sessionID.ToString()}");
+
+        await using (var deflateStream = new ZLibStream(resp.Body, CompressionLevel.SmallestSize))
         {
-            await using (var deflateStream = new ZLibStream(ms, CompressionLevel.SmallestSize))
-            {
-                await deflateStream.WriteAsync(Encoding.UTF8.GetBytes(output));
-            }
-
-            var bytes = ms.ToArray();
-            await resp.Body.WriteAsync(bytes);
+            await deflateStream.WriteAsync(Encoding.UTF8.GetBytes(output));
         }
-
-        await resp.StartAsync();
-        await resp.CompleteAsync();
     }
 
     private record Response(string Method, string jsonData);

Libraries/SPTarkov.Server.Core/Servers/HttpServer.cs

@@ -1,6 +1,6 @@
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Primitives;
-using SPTarkov.Common.Extensions;
+using System.Net;
+using System.Net.Sockets;
+using Microsoft.AspNetCore.Http;
 using SPTarkov.DI.Annotations;
 using SPTarkov.Server.Core.Models.Common;
 using SPTarkov.Server.Core.Models.Spt.Config;
@@ -20,7 +20,7 @@ public class HttpServer(
     IEnumerable<IHttpListener> httpListeners
 )
 {
-    private readonly HttpConfig _httpConfig = configServer.GetConfig<HttpConfig>();
+    protected readonly HttpConfig HttpConfig = configServer.GetConfig<HttpConfig>();
 
     public async Task HandleRequest(HttpContext context)
     {
@@ -39,18 +39,16 @@ public class HttpServer(
             profileActivityService.SetActivityTimestamp(sessionId);
         }
 
-        // Extract header for original IP detection
-        var realIp = context.GetHeaderIfExists("x-real-ip");
-        var clientIp = GetClientIp(context, realIp);
+        var realIp = context.Connection.RemoteIpAddress ?? IPAddress.Parse("127.0.0.1");
 
-        if (_httpConfig.LogRequests)
+        if (HttpConfig.LogRequests)
         {
-            LogRequest(context, clientIp, IsLocalRequest(clientIp));
+            LogRequest(context, realIp, IsPrivateOrLocalAddress(realIp));
         }
 
         try
         {
-            var listener = httpListeners.FirstOrDefault(l => l.CanHandle(sessionId, context.Request));
+            var listener = httpListeners.FirstOrDefault(listener => listener.CanHandle(sessionId, context.Request));
 
             if (listener != null)
             {
@@ -76,7 +74,7 @@ public class HttpServer(
     /// <param name="context">HttpContext of request</param>
     /// <param name="clientIp">Ip of requester</param>
     /// <param name="isLocalRequest">Is this local request</param>
-    protected void LogRequest(HttpContext context, string clientIp, bool isLocalRequest)
+    protected void LogRequest(HttpContext context, IPAddress clientIp, bool isLocalRequest)
     {
         if (isLocalRequest)
         {
@@ -88,32 +86,50 @@ public class HttpServer(
         }
     }
 
-    protected static string GetClientIp(HttpContext context, StringValues? realIp)
-    {
-        if (realIp.HasValue)
-        {
-            return realIp.Value.First();
-        }
-
-        var forwardedFor = context.GetHeaderIfExists("x-forwarded-for");
-        return forwardedFor.HasValue
-            ? forwardedFor.Value.First()!.Split(",")[0].Trim()
-            : context.Connection.RemoteIpAddress!.ToString().Split(":").Last();
-    }
-
     /// <summary>
     ///     Check against hardcoded values that determine it's from a local address
     /// </summary>
     /// <param name="remoteAddress"> Address to check </param>
     /// <returns> True if its local </returns>
-    protected bool IsLocalRequest(string? remoteAddress)
+    protected bool IsPrivateOrLocalAddress(IPAddress remoteAddress)
     {
-        if (remoteAddress == null)
+        if (IPAddress.IsLoopback(remoteAddress))
         {
-            return false;
+            return true;
         }
 
-        return remoteAddress.StartsWith("127.0.0") || remoteAddress.StartsWith("192.168.") || remoteAddress.StartsWith("localhost");
+        if (remoteAddress.AddressFamily == AddressFamily.InterNetwork)
+        {
+            var bytes = remoteAddress.GetAddressBytes();
+
+            switch (bytes[0])
+            {
+                case 10:
+                    return true; // 10.0.0.0/8 (private)
+
+                case 169:
+                    return bytes[1] == 254; // 169.254.0.0/16 (APIPA/link-local)
+
+                case 172:
+                    return bytes[1] >= 16 && bytes[1] <= 31; // 172.16.0.0/12 (private)
+
+                case 192:
+                    return bytes[1] == 168; // 192.168.0.0/16 (private)
+
+                default:
+                    return false;
+            }
+        }
+
+        if (remoteAddress.AddressFamily == AddressFamily.InterNetworkV6)
+        {
+            if (remoteAddress.IsIPv6LinkLocal)
+            {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     protected Dictionary<string, string> GetCookies(HttpRequest req)
@@ -130,6 +146,6 @@ public class HttpServer(
 
     public string ListeningUrl()
     {
-        return $"https://{_httpConfig.Ip}:{_httpConfig.Port}";
+        return $"https://{HttpConfig.Ip}:{HttpConfig.Port}";
     }
 }

SPTarkov.Server/Program.cs

@@ -3,6 +3,7 @@ using System.Net.Sockets;
 using System.Runtime.InteropServices;
 using System.Security.Authentication;
 using System.Text;
+using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.AspNetCore.Server.Kestrel.Https;
 using SPTarkov.Common.Semver;
 using SPTarkov.Common.Semver.Implementations;
@@ -78,6 +79,11 @@ public static class Program
         var loggerFinalizer = app.Services.GetService<ISptLogger<App>>()!;
         try
         {
+            // Handle edge cases where reverse proxies might pass X-Forwarded-For, use this as the actual IP address
+            app.UseForwardedHeaders(
+                new ForwardedHeadersOptions { ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto }
+            );
+
             SetConsoleOutputMode();
 
             await app.RunAsync();