Merge pull request #2 from CWXDEV/main

Added more types, some are unfinished, ill come back to these tomorrow

.gitignore

@@ -30,6 +30,9 @@ bld/
 [Oo]bj/
 [Ll]og/
 
+# Rider specific
+.idea
+
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot

.idea/.idea.server-csharp/.idea/.gitignore

@@ -1,13 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Rider ignored files
-/.idea.server-csharp.iml
-/modules.xml
-/projectSettingsUpdater.xml
-/contentModel.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/.idea.server-csharp/.idea/encodings.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Encoding" addBOMForNewFiles="with BOM under Windows, with no BOM otherwise" />
-</project>

.idea/.idea.server-csharp/.idea/indexLayout.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="UserContentModel">
-    <attachedFolders />
-    <explicitIncludes />
-    <explicitExcludes />
-  </component>
-</project>

.idea/.idea.server-csharp/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

Core/Models/Spt/Callbacks/BotCallbacks.cs

@@ -0,0 +1,26 @@
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Callbacks;
+
+public class BotCallbacks
+{
+    public string GetBotLimit(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBotDifficulty(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<BotBase>> GenerateBots(string url, GenerateBotsRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBotCap()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/BundleCallbacks.cs

@@ -0,0 +1,19 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class BundleCallbacks
+{
+    public object SendBundle(string sessionID, object req, object res, object body)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBundles(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBundle(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/CustomizationCallbacks.cs

@@ -0,0 +1,24 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class CustomizationCallbacks
+{
+    public GetBodyResponseData<object> GetSuits(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<Suit>> GetTraderSuits(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterResponse WearClothing(PmcData pmcData, WearClothingRequestData body, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterResponse BuyClothing(PmcData pmcData, BuyClothingRequestData body, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/DialogCallbacks.cs

@@ -0,0 +1,79 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class DialogCallbacks
+{
+    public GetBodyResponseData<GetFriendListDataResponse> GetFriendList(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> GetChatServerList(string url, GetChatServerListRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<DialogueInfo>> GetMailDialogList(string url, GetMailDialogListRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<GetMailDialogViewResponseData> GetMailDialogView(string url, GetMailDialogViewRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> GetMailDialogInfo(string url, GetMailDialogInfoRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> RemoveDialog(string url, RemoveDialogRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> PinDialog(string url, PinDialogRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public GetBodyResponseData<List<object>> UnpinDialog(string url, PinDialogRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public GetBodyResponseData<List<object>> SetRead(string url, SetDialogReadRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<GetAllAttachmentsResponse> GetAllAttachments(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> ListOutbox(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> ListInbox(string url, EmptyRequestData info, string sessionID)
+    {
+        
+    }
+
+    public NullResponseData SendFriendRequest(string url, FriendRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<int> SendMessage(string url, SendMessageRequest info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Update()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/GameCallbacks.cs

@@ -0,0 +1,44 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class GameCallbacks
+{
+    public NullResponseData VersionValidata(string url, VersionValidaterequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> GameStart(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> GameLogout(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<GameConfigResponse> GetGameConfig(string url, GameEmptyCrcRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> GetServer(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> ValidateGameVersion(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> GameKeepalive(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetVersion(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/HandbookCallbacks.cs

@@ -0,0 +1,9 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class HandbookCallbacks
+{
+    public void Load()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/HealthCallbacks.cs

@@ -0,0 +1,29 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class HealthCallbacks
+{
+    public SptProfile OnLoad(string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object SyncHealth(string url, SyncHealthRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object OffraidEat(PmcData pmcData, OffraidEatRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object OffraidHeal(PmcData pmcData, OffraidHealRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object HealthTreatment(PmcData pmcData, HealthTreatmentRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/HideoutCallbacks.cs

@@ -0,0 +1,54 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class HideoutCallbacks
+{
+    public ItemEventRouterRepsonse Upgrade(PmcData pmcData, HideoutUpgraderequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse UpgradeComplete(PmcData pmcData, HideoutUpgradeCompleterequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse PutItemsInAreaSlots(PmcData pmcData, HideoutPutItemInRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse TakeItemsFromAreaSlots(PmcData pmcData, HideoutTakeItemOutRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse ToggleArea(PmcData pmcData, HideoutToggleAreaRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse SingleProductionStart(PmcData pmcData, HideoutSingleProductionStartRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse ScavCaseProductionStart(PmcData pmcData, HideoutScavCaseStartRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse ContinuousProductionStart(PmcData pmcData, HideoutContinuousProductionRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterRepsonse TakeProduction(PmcData pmcData, HideoutTakeProductionRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Update(int timeSinceLastRun)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/HttpCallbacks.cs

@@ -0,0 +1,19 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class HttpCallbacks
+{
+    public void Load()
+    {
+        throw new NotImplementedException();
+    }
+
+    public void SendImage(string sessionID, object req, object resp, object body)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetImage()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/InsuranceCallbacks.cs

@@ -0,0 +1,24 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class InsuranceCallbacks
+{
+    public SptProfile OnLoad(string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object GetInsuranceCost(string url, GetInsuranceCostRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object Insure(PmcData pmcData, InsureRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool Update(int secondsSinceLastRun)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/InventoryCallbacks.cs

@@ -0,0 +1,84 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class InventoryCallbacks
+{
+    public ItemEventRouterResponse MoveItem(PmcData pmcData, InventoryMoveRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse RemoveItem(PmcData pmcData, InventoryRemoveRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse SplitItem(PmcData pmcData, InventorySplitRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse MergeItem(PmcData pmcData, InventoryMergeRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse TransferItem(PmcData pmcData, InventoryTransferRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse SwapItem(PmcData pmcData, InventorySwapRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse FoldItem(PmcData pmcData, InventoryFoldRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse ToggleItem(PmcData pmcData, InventoryToggleRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse TagItem(PmcData pmcData, InventoryTagRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse BindItem(PmcData pmcData, InventoryBindRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse ExamineItem(PmcData pmcData, InventoryExamineRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse ReadEncyclopedia(PmcData pmcData, InventoryReadEncyclopediaRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse SortInventory(PmcData pmcData, InventorySortRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse CreateMapMarker(PmcData pmcData, InventoryCreateMarkerRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse DeleteMapMarker(PmcData pmcData, InventoryDeleteMarkerRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+    
+    public ItemEventRouterResponse EditMapMarker(PmcData pmcData, InventoryEditMarkerRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/ItemEventCallbacks.cs

@@ -0,0 +1,9 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class ItemEventCallbacks
+{
+    public GetBodyResponseData<ItemEventRouterResponse> HandleEvents(string url, ItemEventRouterRequest info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/LauncherCallbacks.cs

@@ -0,0 +1,69 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class LauncherCallbacks
+{
+    public string Connect()
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Login(string url, LoginRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Register(string url, RegisterData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Get(string url, LoginRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string ChangeUsername(string url, ChangeRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string ChangePassword(string url, ChangeRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Wipe(string url, RegisterData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetMiniProfile(string url, GetMiniProfileRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetAllMiniProfiles(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetServerVersion()
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Ping(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string RemoveProfile(string url, RemoveProfileData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetCompatibleTarkovVersion()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/LocationCallbacks.cs

@@ -0,0 +1,16 @@
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Callbacks;
+
+public class LocationCallbacks
+{
+    public GetBodyResponseData<LocationsGenerateAllResponse> GetLocationData(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<LocationBase> GetLocation(string url, GetLocationRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/ModCallbacks.cs

@@ -0,0 +1,24 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class ModCallbacks
+{
+    public void Load()
+    {
+        throw new NotImplementedException();
+    }
+
+    public void SendBundle(string sessionID, object req, object resp, object body)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBundles(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetBundle(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/NoteCallbacks.cs

@@ -0,0 +1,19 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class NoteCallbacks
+{
+    public ItemEventRouterResponse AddNote(PmcData pmcData, NoteActionData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterResponse EditNote(PmcData pmcData, NoteActionData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ItemEventRouterResponse DeleteNote(PmcData pmcData, NoteActionData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/NotifierCallbacks.cs

@@ -0,0 +1,35 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class NotifierCallbacks
+{
+    /**
+     * If we don't have anything to send, it's ok to not send anything back
+     * because notification requests can be long-polling. In fact, we SHOULD wait
+     * until we actually have something to send because otherwise we'd spam the client
+     * and the client would abort the connection due to spam.
+     */
+    public void SendNotification(string sessionID, object req, object resp, object data)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<List<object>> GetNotifier(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<NotifierChannel> CreateNotifierChannel(string url, EmptyRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public GetBodyResponseData<object> SelectProfile(string url, UIDRequestData info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Notify(string url, object info, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Callbacks/PresetBuildCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class PresetBuildCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/PresetCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class PresetCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/ProfileCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class ProfileCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/QuestCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class QuestCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/RagfairCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class RagfairCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/RepairCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class RepairCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/SaveCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class SaveCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/TradeCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class TradeCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/TraderCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class TraderCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/WeatherCallbacks.cs

@@ -0,0 +1,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class WeatherCallbacks
+{
+    
+}

Core/Models/Spt/Config/AirdropConfig.cs

@@ -0,0 +1,128 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class AirdropConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-airdrop";
+
+    [JsonPropertyName("airdropTypeWeightings")]
+    public Dictionary<SptAirdropTypeEnum, double> AirdropTypeWeightings { get; set; }
+
+    /// <summary>
+    /// What rewards will the loot crate contain, keyed by drop type e.g. mixed/weaponArmor/foodMedical/barter
+    /// </summary>
+    [JsonPropertyName("loot")]
+    public Dictionary<string, AirdropLoot> Loot { get; set; }
+
+    [JsonPropertyName("customAirdropMapping")]
+    public Dictionary<string, SptAirdropTypeEnum> CustomAirdropMapping { get; set; }
+}
+
+/// <summary>
+/// Chance map will have an airdrop occur out of 100 - locations not included count as 0%
+/// </summary>
+public class AirdropChancePercent
+{
+    [JsonPropertyName("bigmap")]
+    public double Bigmap { get; set; }
+    
+    [JsonPropertyName("woods")]
+    public double Woods { get; set; }
+    
+    [JsonPropertyName("lighthouse")]
+    public double Lighthouse { get; set; }
+    
+    [JsonPropertyName("shoreline")]
+    public double Shoreline { get; set; }
+    
+    [JsonPropertyName("interchange")]
+    public double Interchange { get; set; }
+    
+    [JsonPropertyName("reserve")]
+    public double Reserve { get; set; }
+    
+    [JsonPropertyName("tarkovStreets")]
+    public double TarkovStreets { get; set; }
+    
+    [JsonPropertyName("sandbox")]
+    public double Sandbox { get; set; }
+}
+
+/// <summary>
+/// Loot inside crate
+/// </summary>
+public class AirdropLoot
+{
+    [JsonPropertyName("Icon")]
+    public AirdropTypeEnum Icon { get; set; }
+
+    /// <summary>
+    /// Min/max of weapons inside crate
+    /// </summary>
+    [JsonPropertyName("weaponPresetCount")]
+    public MinMax? WeaponPresetCount { get; set; }
+
+    /// <summary>
+    /// Min/max of armors (head/chest/rig) inside crate
+    /// </summary>
+    [JsonPropertyName("armorPresetCount")]
+    public MinMax? ArmorPresetCount { get; set; }
+
+    /// <summary>
+    /// Min/max of items inside crate
+    /// </summary>
+    [JsonPropertyName("itemCount")]
+    public MinMax ItemCount { get; set; }
+
+    /// <summary>
+    /// Min/max of sealed weapon boxes inside crate
+    /// </summary>
+    [JsonPropertyName("weaponCrateCount")]
+    public MinMax WeaponCrateCount { get; set; }
+
+    /// <summary>
+    /// Items to never allow - tpls
+    /// </summary>
+    [JsonPropertyName("itemBlacklist")]
+    public List<string> ItemBlacklist { get; set; }
+
+    /// <summary>
+    /// Item type (parentId) to allow inside crate
+    /// </summary>
+    [JsonPropertyName("itemTypeWhitelist")]
+    public List<string> ItemTypeWhitelist { get; set; }
+
+    /// <summary>
+    /// Item type/ item tpls to limit count of inside crate - key: item base type: value: max count
+    /// </summary>
+    [JsonPropertyName("itemLimits")]
+    public Dictionary<string, double> ItemLimits { get; set; }
+
+    /// <summary>
+    /// Items to limit stack size of key: item tpl value: min/max stack size
+    /// </summary>
+    [JsonPropertyName("itemStackLimits")]
+    public Dictionary<string, MinMax> ItemStackLimits { get; set; }
+
+    /// <summary>
+    /// Armor levels to allow inside crate e.g. [4,5,6]
+    /// </summary>
+    [JsonPropertyName("armorLevelWhitelist")]
+    public List<int>? ArmorLevelWhitelist { get; set; }
+
+    /// <summary>
+    /// Should boss items be added to airdrop crate
+    /// </summary>
+    [JsonPropertyName("allowBossItems")]
+    public bool AllowBossItems { get; set; }
+
+    [JsonPropertyName("useForcedLoot")]
+    public bool? UseForcedLoot { get; set; }
+
+    [JsonPropertyName("forcedLoot")]
+    public Dictionary<string, MinMax>? ForcedLoot { get; set; }
+}

Core/Models/Spt/Config/BackupConfig.cs

@@ -0,0 +1,30 @@
+namespace Core.Models.Spt.Config;
+
+using System.Text.Json.Serialization;
+
+public class BackupConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-backup";
+
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+
+    [JsonPropertyName("maxBackups")]
+    public int MaxBackups { get; set; }
+
+    [JsonPropertyName("directory")]
+    public string Directory { get; set; }
+
+    [JsonPropertyName("backupInterval")]
+    public BackupConfigInterval BackupInterval { get; set; }
+}
+
+public class BackupConfigInterval
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+
+    [JsonPropertyName("intervalMinutes")]
+    public int IntervalMinutes { get; set; }
+}

Core/Models/Spt/Config/BaseConfig.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; }
+}
+
+public class RunIntervalValues
+{
+    [JsonPropertyName("inRaid")]
+    public int InRaid { get; set; }
+    
+    [JsonPropertyName("outOfRaid")]
+    public int OutOfRaid { get; set; }
+}

Core/Models/Spt/Config/BotConfig.cs

@@ -0,0 +1,525 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Config;
+
+public class BotConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-bot";
+    
+    /** How many variants of each bot should be generated on raid start */
+    [JsonPropertyName("presetBatch")]
+    public PresetBatch PresetBatch { get; set; }
+    
+    /** Bot roles that should not have PMC types (pmcBEAR/pmcUSEC) added as enemies to */
+    [JsonPropertyName("botsToNotAddPMCsAsEnemiesTo")]
+    public List<string> BotsToNotAddPMCsAsEnemiesTo { get; set; }
+    
+    /** What bot types should be classified as bosses */
+    [JsonPropertyName("bosses")]
+    public List<string> Bosses { get; set; }
+    
+    /** Control weapon/armor durability min/max values for each bot type */
+    [JsonPropertyName("durability")]
+    public BotDurability Durability { get; set; }
+    
+    /** Controls the percentage values of randomization item resources */
+    [JsonPropertyName("lootItemResourceRandomization")]
+    public Dictionary<string, RandomisedResourceDetails> LootItemResourceRandomization { get; set; }
+    
+    /** Control what bots are added to a bots revenge list key: bottype, value: bottypes to revenge on seeing their death */
+    [JsonPropertyName("revenge")]
+    public Dictionary<string, List<string>> Revenge { get; set; }
+    
+    /** Control how many items are allowed to spawn on a bot
+     * key: bottype, value: <key: itemTpl: value: max item count> */
+    [JsonPropertyName("itemSpawnLimits")]
+    public Dictionary<string, Dictionary<string, int>> ItemSpawnLimits { get; set; }
+    
+    /** Blacklist/whitelist items on a bot */
+    [JsonPropertyName("equipment")]
+    public Dictionary<string, EquipmentFilters> Equipment { get; set; }
+    
+    /** Show a bots botType value after their name */
+    [JsonPropertyName("showTypeInNickname")]
+    public bool ShowTypeInNickname { get; set; }
+    
+    /** What ai brain should a normal scav use per map */
+    [JsonPropertyName("assaultBrainType")]
+    public Dictionary<string, Dictionary<string, int>> AssaultBrainType { get; set; }
+    
+    /** What ai brain should a player scav use per map */
+    [JsonPropertyName("playerScavBrainType")]
+    public Dictionary<string, Dictionary<string, int>> PlayerScavBrainType { get; set; }
+    
+    /** Max number of bots that can be spawned in a raid at any one time */
+    [JsonPropertyName("maxBotCap")]
+    public Dictionary<string, int> MaxBotCap { get; set; }
+    
+    /** Chance scav has fake pscav name e.g. Scav name (player name) */
+    [JsonPropertyName("chanceAssaultScavHasPlayerScavName")]
+    public int ChanceAssaultScavHasPlayerScavName { get; set; }
+    
+    /** How many stacks of secret ammo should a bot have in its bot secure container */
+    [JsonPropertyName("secureContainerAmmoStackCount")]
+    public int SecureContainerAmmoStackCount { get; set; }
+    
+    /** Bot roles in this array will be given a dog tag on generation */
+    [JsonPropertyName("botRolesWithDogTags")]
+    public List<string> BotRolesWithDogTags { get; set; }
+    
+    /** Settings to control the items that get added into wallets on bots */
+    [JsonPropertyName("walletLoot")]
+    public WalletLootSettings WalletLoot { get; set; }
+    
+    /** Currency weights, Keyed by botrole / currency */
+    [JsonPropertyName("currencyStackSize")]
+    public Dictionary<string, Dictionary<string, Dictionary<string, int>>> CurrencyStackSize { get; set; }
+    
+    /** Tpls for low profile gas blocks */
+    [JsonPropertyName("lowProfileGasBlockTpls")]
+    public List<string> LowProfileGasBlockTpls { get; set; }
+    
+    /** What bottypes should be excluded from having loot generated on them (backpack/pocket/vest) does not disable food/drink/special/ */
+    [JsonPropertyName("disableLootOnBotTypes")]
+    public List<string> DisableLootOnBotTypes { get; set; }
+    
+    [JsonPropertyName("assaultToBossConversion")]
+    public AssaultToBossConversion AssaultToBossConversion { get; set; }
+    
+    /** Max length a bots name can be */
+    [JsonPropertyName("botNameLengthLimit")]
+    public int BotNameLengthLimit { get; set; }
+    
+    /** Bot roles that must have a unique name when generated vs other bots in raid */
+    [JsonPropertyName("botRolesThatMustHaveUniqueName")]
+    public List<string> BotRolesThatMustHaveUniqueName { get; set; }
+}
+
+public class AssaultToBossConversion
+{
+    [JsonPropertyName("bossConvertEnabled")]
+    public bool BossConvertEnabled { get; set; }
+    
+    [JsonPropertyName("bossesToConvertToWeights")]
+    public Dictionary<string, int> BossesToConvertToWeights { get; set; }
+    
+    [JsonPropertyName("bossConvertMinMax")]
+    public Dictionary<string, MinMax> BossConvertMinMax { get; set; }
+}
+
+/** Number of bots to generate and store in cache on raid start per bot type */
+public class PresetBatch
+{
+    [JsonPropertyName("assault")]
+    public int Assault { get; set; }
+    
+    [JsonPropertyName("bossBully")]
+    public int BossBully { get; set; }
+    
+    [JsonPropertyName("bossGluhar")]
+    public int BossGluhar { get; set; }
+    
+    [JsonPropertyName("bossKilla")]
+    public int BossKilla { get; set; }
+    
+    [JsonPropertyName("bossKojaniy")]
+    public int BossKojaniy { get; set; }
+    
+    [JsonPropertyName("bossSanitar")]
+    public int BossSanitar { get; set; }
+    
+    [JsonPropertyName("bossTagilla")]
+    public int BossTagilla { get; set; }
+    
+    [JsonPropertyName("bossKnight")]
+    public int BossKnight { get; set; }
+    
+    [JsonPropertyName("bossTest")]
+    public int BossTest { get; set; }
+    
+    [JsonPropertyName("cursedAssault")]
+    public int CursedAssault { get; set; }
+    
+    [JsonPropertyName("followerBully")]
+    public int FollowerBully { get; set; }
+    
+    [JsonPropertyName("followerGluharAssault")]
+    public int FollowerGluharAssault { get; set; }
+    
+    [JsonPropertyName("followerGluharScout")]
+    public int FollowerGluharScout { get; set; }
+    
+    [JsonPropertyName("followerGluharSecurity")]
+    public int FollowerGluharSecurity { get; set; }
+    
+    [JsonPropertyName("followerGluharSnipe")]
+    public int FollowerGluharSnipe { get; set; }
+    
+    [JsonPropertyName("followerKojaniy")]
+    public int FollowerKojaniy { get; set; }
+    
+    [JsonPropertyName("followerSanitar")]
+    public int FollowerSanitar { get; set; }
+    
+    [JsonPropertyName("followerTagilla")]
+    public int FollowerTagilla { get; set; }
+    
+    [JsonPropertyName("followerBirdEye")]
+    public int FollowerBirdEye { get; set; }
+    
+    [JsonPropertyName("followerBigPipe")]
+    public int FollowerBigPipe { get; set; }
+    
+    [JsonPropertyName("followerTest")]
+    public int FollowerTest { get; set; }
+    
+    [JsonPropertyName("followerBoar")]
+    public int FollowerBoar { get; set; }
+    
+    [JsonPropertyName("marksman")]
+    public int Marksman { get; set; }
+    
+    [JsonPropertyName("pmcBot")]
+    public int PmcBot { get; set; }
+    
+    [JsonPropertyName("sectantPriest")]
+    public int SectantPriest { get; set; }
+    
+    [JsonPropertyName("sectantWarrior")]
+    public int SectantWarrior { get; set; }
+    
+    [JsonPropertyName("gifter")]
+    public int Gifter { get; set; }
+    
+    [JsonPropertyName("test")]
+    public int Test { get; set; }
+    
+    [JsonPropertyName("exUsec")]
+    public int ExUsec { get; set; }
+    
+    [JsonPropertyName("arenaFighterEvent")]
+    public int ArenaFighterEvent { get; set; }
+    
+    [JsonPropertyName("arenaFighter")]
+    public int ArenaFighter { get; set; }
+    
+    [JsonPropertyName("crazyAssaultEvent")]
+    public int CrazyAssaultEvent { get; set; }
+    
+    [JsonPropertyName("bossBoar")]
+    public int BossBoar { get; set; }
+    
+    [JsonPropertyName("bossBoarSniper")]
+    public int BossBoarSniper { get; set; }
+    
+    [JsonPropertyName("pmcUSEC")]
+    public int PmcUSEC { get; set; }
+    
+    [JsonPropertyName("pmcBEAR")]
+    public int PmcBEAR { get; set; }
+}
+
+public class WalletLootSettings
+{
+    /// <summary>
+    /// Chance wallets have loot in them
+    /// </summary>
+    [JsonPropertyName("chancePercent")]
+    public float ChancePercent { get; set; }
+    
+    [JsonPropertyName("itemCount")]
+    public MinMax ItemCount { get; set; }
+    
+    [JsonPropertyName("stackSizeWeight")]
+    public Dictionary<string, float> StackSizeWeight { get; set; }
+    
+    [JsonPropertyName("currencyWeight")]
+    public Dictionary<string, float> CurrencyWeight { get; set; }
+    
+    /// <summary>
+    /// What wallets will have money in them
+    /// </summary>
+    [JsonPropertyName("walletTplPool")]
+    public List<string> WalletTplPool { get; set; }
+}
+
+public class EquipmentFilters
+{
+    /// <summary>
+    /// Limits for mod types per weapon .e.g. scopes
+    /// </summary>
+    [JsonPropertyName("weaponModLimits")]
+    public ModLimits WeaponModLimits { get; set; }
+    
+    /// <summary>
+    /// Whitelist for weapon sight types allowed per gun
+    /// </summary>
+    [JsonPropertyName("weaponSightWhitelist")]
+    public Dictionary<string, List<string>> WeaponSightWhitelist { get; set; }
+    
+    /// <summary>
+    /// Chance face shield is down/active
+    /// </summary>
+    [JsonPropertyName("faceShieldIsActiveChancePercent")]
+    public float? FaceShieldIsActiveChancePercent { get; set; }
+    
+    /// <summary>
+    /// Chance gun flashlight is active during the day
+    /// </summary>
+    [JsonPropertyName("lightIsActiveDayChancePercent")]
+    public float? LightIsActiveDayChancePercent { get; set; }
+    
+    /// <summary>
+    /// Chance gun flashlight is active during the night
+    /// </summary>
+    [JsonPropertyName("lightIsActiveNightChancePercent")]
+    public float? LightIsActiveNightChancePercent { get; set; }
+    
+    /// <summary>
+    /// Chance gun laser is active during the day
+    /// </summary>
+    [JsonPropertyName("laserIsActiveChancePercent")]
+    public float? LaserIsActiveChancePercent { get; set; }
+    
+    /// <summary>
+    /// Chance NODS are down/active during the day
+    /// </summary>
+    [JsonPropertyName("NvgIsActiveChanceDayPercent")]
+    public float? NvgIsActiveChanceDayPercent { get; set; }
+    
+    /// <summary>
+    /// Chance NODS are down/active during the night
+    /// </summary>
+    [JsonPropertyName("nvgIsActiveChanceNightPercent")]
+    public float? NvgIsActiveChanceNightPercent { get; set; }
+    
+    [JsonPropertyName("forceOnlyArmoredRigWhenNoArmor")]
+    public bool? ForceOnlyArmoredRigWhenNoArmor { get; set; }
+    
+    /// <summary>
+    /// Should plates be filtered by level
+    /// </summary>
+    [JsonPropertyName("filterPlatesByLevel")]
+    public bool? FilterPlatesByLevel { get; set; }
+    
+    /// <summary>
+    /// What additional slot ids should be seen as required when choosing a mod to add to a weapon
+    /// </summary>
+    [JsonPropertyName("weaponSlotIdsToMakeRequired")]
+    public List<string>? WeaponSlotIdsToMakeRequired { get; set; }
+    
+    /// <summary>
+    /// Adjust weighting/chances of items on bot by level of bot
+    /// </summary>
+    [JsonPropertyName("randomisation")]
+    public List<RandomisationDetails> Randomisation { get; set; }
+    
+    /// <summary>
+    /// Blacklist equipment by level of bot
+    /// </summary>
+    [JsonPropertyName("blacklist")]
+    public List<EquipmentFilterDetails> Blacklist { get; set; }
+    
+    /// <summary>
+    /// Whitelist equipment by level of bot
+    /// </summary>
+    [JsonPropertyName("whitelist")]
+    public List<EquipmentFilterDetails> Whitelist { get; set; }
+    
+    /// <summary>
+    /// Adjust equipment/ammo
+    /// </summary>
+    [JsonPropertyName("weightingAdjustmentsByBotLevel")]
+    public List<WeightingAdjustmentDetails> WeightingAdjustmentsByBotLevel { get; set; }
+    
+    /// <summary>
+    /// Same as weightingAdjustments but based on player level instead of bot level
+    /// </summary>
+    [JsonPropertyName("weightingAdjustmentsByPlayerLevel")]
+    public List<WeightingAdjustmentDetails>? WeightingAdjustmentsByPlayerLevel { get; set; }
+    
+    /// <summary>
+    /// Should the stock mod be forced to spawn on bot
+    /// </summary>
+    [JsonPropertyName("forceStock")]
+    public bool? ForceStock { get; set; }
+    
+    [JsonPropertyName("armorPlateWeighting")]
+    public List<ArmorPlateWeights>? ArmorPlateWeighting { get; set; }
+    
+    [JsonPropertyName("forceRigWhenNoVest")]
+    public bool? ForceRigWhenNoVest { get; set; }
+}
+
+public class ModLimits
+{
+    /// <summary>
+    /// How many scopes are allowed on a weapon - hard coded to work with OPTIC_SCOPE, ASSAULT_SCOPE, COLLIMATOR, COMPACT_COLLIMATOR
+    /// </summary>
+    [JsonPropertyName("scopeLimit")]
+    public int? ScopeLimit { get; set; }
+    
+    /// <summary>
+    /// How many lasers or lights are allowed on a weapon - hard coded to work with TACTICAL_COMBO, and FLASHLIGHT
+    /// </summary>
+    [JsonPropertyName("lightLaserLimit")]
+    public int? LightLaserLimit { get; set; }
+}
+
+public class RandomisationDetails
+{
+    /// <summary>
+    /// Between what levels do these randomisation setting apply to
+    /// </summary>
+    [JsonPropertyName("levelRange")]
+    public MinMax LevelRange { get; set; }
+    
+    [JsonPropertyName("generation")]
+    public Dictionary<string, GenerationData>? Generation { get; set; }
+    
+    /// <summary>
+    /// Mod slots that should be fully randomised -ignores mods from bottype.json and instead creates a pool using items.json
+    /// </summary>
+    [JsonPropertyName("randomisedWeaponModSlots")]
+    public List<string>? RandomisedWeaponModSlots { get; set; }
+    
+    /// <summary>
+    /// Armor slots that should be randomised e.g. 'Headwear, Armband'
+    /// </summary>
+    [JsonPropertyName("randomisedArmorSlots")]
+    public List<string>? RandomisedArmorSlots { get; set; }
+    
+    /// <summary>
+    /// Equipment chances
+    /// </summary>
+    [JsonPropertyName("equipment")]
+    public Dictionary<string, float>? Equipment { get; set; }
+    
+    /// <summary>
+    /// Weapon mod chances
+    /// </summary>
+    [JsonPropertyName("weaponMods")]
+    public Dictionary<string, float>? WeaponMods { get; set; }
+    
+    /// <summary>
+    /// Equipment mod chances
+    /// </summary>
+    [JsonPropertyName("equipmentMods")]
+    public Dictionary<string, float>? EquipmentMods { get; set; }
+    
+    [JsonPropertyName("nighttimeChanges")]
+    public NighttimeChanges? NighttimeChanges { get; set; }
+    
+    /// <summary>
+    /// Key = weapon tpl, value = min size of magazine allowed
+    /// </summary>
+    [JsonPropertyName("minimumMagazineSize")]
+    public Dictionary<string, float>? MinimumMagazineSize { get; set; }
+}
+
+public class NighttimeChanges
+{
+    /// <summary>
+    /// Applies changes to values stored in equipmentMods
+    /// </summary>
+    [JsonPropertyName("equipmentModsModifiers")]
+    public Dictionary<string, float> EquipmentModsModifiers { get; set; }
+    //public Dictionary<string, float> WeaponModsModifiers { get; set; } //TODO
+}
+
+public class EquipmentFilterDetails
+{
+    /// <summary>
+    /// Between what levels do these equipment filter setting apply to
+    /// </summary>
+    [JsonPropertyName("levelRange")]
+    public MinMax LevelRange { get; set; }
+    
+    /// <summary>
+    /// Key: mod slot name e.g. mod_magazine, value: item tpls
+    /// </summary>
+    [JsonPropertyName("equipment")]
+    public Dictionary<string, List<string>>? Equipment { get; set; }
+    
+    /// <summary>
+    /// Key: equipment slot name e.g. FirstPrimaryWeapon, value: item tpls
+    /// </summary>
+    [JsonPropertyName("gear")]
+    public Dictionary<string, List<string>>? Gear { get; set; }
+    
+    /// <summary>
+    /// Key: cartridge type e.g. Caliber23x75, value: item tpls
+    /// </summary>
+    [JsonPropertyName("cartridge")]
+    public Dictionary<string, List<string>>? Cartridge { get; set; }
+}
+
+public class WeightingAdjustmentDetails
+{
+    /// <summary>
+    /// Between what levels do these weight settings apply to
+    /// </summary>
+    [JsonPropertyName("levelRange")]
+    public MinMax LevelRange { get; set; }
+    
+    /// <summary>
+    /// Key: ammo type e.g. Caliber556x45NATO, value: item tpl + weight
+    /// </summary>
+    [JsonPropertyName("ammo")]
+    public AdjustmentDetails? Ammo { get; set; }
+    
+    /// <summary>
+    /// Key: equipment slot e.g. TacticalVest, value: item tpl + weight
+    /// </summary>
+    [JsonPropertyName("equipment")]
+    public AdjustmentDetails? Equipment { get; set; }
+    
+    /// <summary>
+    /// Key: clothing slot e.g. feet, value: item tpl + weight
+    /// </summary>
+    [JsonPropertyName("clothing")]
+    public AdjustmentDetails? Clothing { get; set; }
+}
+
+public class AdjustmentDetails
+{
+    [JsonPropertyName("add")]
+    public Dictionary<string, Dictionary<string, float>> Add { get; set; }
+    
+    [JsonPropertyName("edit")]
+    public Dictionary<string, Dictionary<string, float>> Edit { get; set; }
+}
+
+public class ArmorPlateWeights : Dictionary<string, object>
+{
+    [JsonPropertyName("levelRange")]
+    public MinMax LevelRange { get; set; }
+}
+
+public class RandomisedResourceDetails
+{
+    [JsonPropertyName("food")]
+    public RandomisedResourceValues Food { get; set; }
+    
+    [JsonPropertyName("meds")]
+    public RandomisedResourceValues Meds { get; set; }
+}
+
+public class RandomisedResourceValues
+{
+    /// <summary>
+    /// Minimum percent of item to randomized between min and max resource
+    /// </summary>
+    [JsonPropertyName("resourcePercent")]
+    public float ResourcePercent { get; set; }
+    
+    /// <summary>
+    /// Chance for randomization to not occur
+    /// </summary>
+    [JsonPropertyName("chanceMaxResourcePercent")]
+    public float ChanceMaxResourcePercent { get; set; }
+}

Core/Models/Spt/Config/BotDurability.cs

@@ -0,0 +1,115 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class BotDurability 
+{
+    [JsonPropertyName("default")]
+    public DefaultDurability Default { get; set; }
+
+    [JsonPropertyName("pmc")]
+    public PmcDurability Pmc { get; set; }
+
+    [JsonPropertyName("boss")]
+    public BotDurability Boss { get; set; }
+
+    [JsonPropertyName("follower")]
+    public BotDurability Follower { get; set; }
+
+    [JsonPropertyName("assault")]
+    public BotDurability Assault { get; set; }
+
+    [JsonPropertyName("cursedassault")]
+    public BotDurability CursedAssault { get; set; }
+
+    [JsonPropertyName("marksman")]
+    public BotDurability Marksman { get; set; }
+
+    [JsonPropertyName("pmcbot")]
+    public BotDurability PmcBot { get; set; }
+
+    [JsonPropertyName("arenafighterevent")]
+    public BotDurability ArenaFighterEvent { get; set; }
+
+    [JsonPropertyName("arenafighter")]
+    public BotDurability ArenaFighter { get; set; }
+
+    [JsonPropertyName("crazyassaultevent")]
+    public BotDurability CrazyAssaultEvent { get; set; }
+
+    [JsonPropertyName("exusec")]
+    public BotDurability Exusec { get; set; }
+
+    [JsonPropertyName("gifter")]
+    public BotDurability Gifter { get; set; }
+
+    [JsonPropertyName("sectantpriest")]
+    public BotDurability SectantPriest { get; set; }
+
+    [JsonPropertyName("sectantwarrior")]
+    public BotDurability SectantWarrior { get; set; }
+}
+
+/** Durability values to be used when a more specific bot type can't be found */
+public class DefaultDurability 
+{
+    [JsonPropertyName("armor")]
+    public ArmorDurability Armor { get; set; }
+
+    [JsonPropertyName("weapon")]
+    public WeaponDurability Weapon { get; set; }
+}
+
+public class PmcDurability 
+{
+    [JsonPropertyName("armor")]
+    public PmcDurabilityArmor Armor { get; set; }
+
+    [JsonPropertyName("weapon")]
+    public WeaponDurability Weapon { get; set; }
+}
+
+public class PmcDurabilityArmor 
+{
+    [JsonPropertyName("lowestMaxPercent")]
+    public double LowestMaxPercent { get; set; }
+
+    [JsonPropertyName("highestMaxPercent")]
+    public double HighestMaxPercent { get; set; }
+
+    [JsonPropertyName("maxDelta")]
+    public double MaxDelta { get; set; }
+
+    [JsonPropertyName("minDelta")]
+    public double MinDelta { get; set; }
+}
+
+public class ArmorDurability 
+{
+    [JsonPropertyName("maxDelta")]
+    public double MaxDelta { get; set; }
+
+    [JsonPropertyName("minDelta")]
+    public double MinDelta { get; set; }
+
+    [JsonPropertyName("minLimitPercent")]
+    public double MinLimitPercent { get; set; }
+}
+
+public class WeaponDurability 
+{
+    [JsonPropertyName("lowestMax")]
+    public double LowestMax { get; set; }
+
+    [JsonPropertyName("highestMax")]
+    public double HighestMax { get; set; }
+
+    [JsonPropertyName("maxDelta")]
+    public double MaxDelta { get; set; }
+
+    [JsonPropertyName("minDelta")]
+    public double MinDelta { get; set; }
+
+    [JsonPropertyName("minLimitPercent")]
+    public double MinLimitPercent { get; set; }
+}

Core/Models/Spt/Config/CoreConfig.cs

@@ -0,0 +1,197 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class CoreConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-core";
+
+    [JsonPropertyName("sptVersion")]
+    public string SptVersion { get; set; }
+
+    [JsonPropertyName("projectName")]
+    public string ProjectName { get; set; }
+
+    [JsonPropertyName("compatibleTarkovVersion")]
+    public string CompatibleTarkovVersion { get; set; }
+
+    [JsonPropertyName("serverName")]
+    public string ServerName { get; set; }
+
+    [JsonPropertyName("profileSaveIntervalSeconds")]
+    public int ProfileSaveIntervalInSeconds { get; set; }
+
+    [JsonPropertyName("sptFriendNickname")]
+    public string SptFriendNickname { get; set; }
+
+    [JsonPropertyName("allowProfileWipe")]
+    public bool AllowProfileWipe { get; set; }
+
+    [JsonPropertyName("bsgLogging")]
+    public BsgLogging BsgLogging { get; set; }
+
+    [JsonPropertyName("release")]
+    public Release Release { get; set; }
+
+    [JsonPropertyName("fixes")]
+    public GameFixes Fixes { get; set; }
+
+    [JsonPropertyName("survey")]
+    public SurveyResponseData Survey { get; set; }
+
+    [JsonPropertyName("features")]
+    public ServerFeatures Features { get; set; }
+
+    /** Commit hash build server was created from */
+    [JsonPropertyName("commit")]
+    public string? Commit { get; set; }
+
+    /** Timestamp of server build */
+    [JsonPropertyName("buildTime")]
+    public string? BuildTime { get; set; }
+
+    /** Server locale keys that will be added to the bottom of the startup watermark */
+    [JsonPropertyName("customWatermarkLocaleKeys")]
+    public List<string>? CustomWatermarkLocaleKeys { get; set; }
+}
+
+public class BsgLogging
+{
+    /**
+     * verbosity of what to log, yes I know this is backwards, but its how nlog deals with ordinals.
+     * complain to them about it! In all cases, better exceptions will be logged.
+     * WARNING: trace-info logging will quickly create log files in the megabytes.
+     * 0 - trace
+     * 1 - debug
+     * 2 - info
+     * 3 - warn
+     * 4 - error
+     * 5 - fatal
+     * 6 - off
+     */
+    [JsonPropertyName("verbosity")]
+    public int Verbosity { get; set; }
+
+    // Should we send the logging to the server
+    [JsonPropertyName("sendToServer")]
+    public bool SendToServer { get; set; }
+}
+
+public class Release
+{
+    // Disclaimer outlining the intended usage of bleeding edge
+    [JsonPropertyName("betaDisclaimerText")]
+    public string? BetaDisclaimerText { get; set; }
+
+    // Text logged when users agreed to terms
+    [JsonPropertyName("betaDisclaimerAcceptText")]
+    public string BetaDisclaimerAcceptText { get; set; }
+
+    // Server mods loaded message
+    [JsonPropertyName("serverModsLoadedText")]
+    public string ServerModsLoadedText { get; set; }
+
+    // Server mods loaded debug message text
+    [JsonPropertyName("serverModsLoadedDebugText")]
+    public string ServerModsLoadedDebugText { get; set; }
+
+    // Client mods loaded message
+    [JsonPropertyName("clientModsLoadedText")]
+    public string ClientModsLoadedText { get; set; }
+
+    // Client mods loaded debug message text
+    [JsonPropertyName("clientModsLoadedDebugText")]
+    public string ClientModsLoadedDebugText { get; set; }
+
+    // Illegal plugins log message
+    [JsonPropertyName("illegalPluginsLoadedText")]
+    public string IllegalPluginsLoadedText { get; set; }
+
+    // Illegal plugins exception
+    [JsonPropertyName("illegalPluginsExceptionText")]
+    public string IllegalPluginsExceptionText { get; set; }
+
+    // Summary of release changes
+    [JsonPropertyName("releaseSummaryText")]
+    public string? ReleaseSummaryText { get; set; }
+
+    // Enables the cool watermark in-game
+    [JsonPropertyName("isBeta")]
+    public bool? IsBeta { get; set; }
+
+    // Whether mods are enabled
+    [JsonPropertyName("isModdable")]
+    public bool? IsModdable { get; set; }
+
+    // Are mods loaded on the server?
+    [JsonPropertyName("isModded")]
+    public bool IsModded { get; set; }
+
+    // How long before the messagebox times out and closes the game
+    [JsonPropertyName("betaDisclaimerTimeoutDelay")]
+    public int BetaDisclaimerTimeoutDelay { get; set; }
+}
+
+public class GameFixes
+{
+    /** Shotguns use a different value than normal guns causing huge pellet dispersion  */
+    [JsonPropertyName("fixShotgunDispersion")]
+    public bool FixShotgunDispersion { get; set; }
+
+    /** Remove items added by mods when the mod no longer exists - can fix dead profiles stuck at game load */
+    [JsonPropertyName("removeModItemsFromProfile")]
+    public bool RemoveModItemsFromProfile { get; set; }
+
+    /** Remove invalid traders from profile - trader data can be leftover when player removes trader mod */
+    [JsonPropertyName("removeInvalidTradersFromProfile")]
+    public bool RemoveInvalidTradersFromProfile { get; set; }
+
+    /** Fix issues that cause the game to not start due to inventory item issues */
+    [JsonPropertyName("fixProfileBreakingInventoryItemIssues")]
+    public bool FixProfileBreakingInventoryItemIssues { get; set; }
+}
+
+public class ServerFeatures
+{
+    /* Controls whether or not the server attempts to download mod dependencies not included in the server's executable */
+    [JsonPropertyName("autoInstallModDependencies")]
+    public bool AutoInstallModDependencies { get; set; }
+
+    [JsonPropertyName("compressProfile")]
+    public bool CompressProfile { get; set; }
+
+    [JsonPropertyName("chatbotFeatures")]
+    public ChatbotFeatures ChatbotFeatures { get; set; }
+
+    /** Keyed to profile type e.g. "Standard" or "SPT Developer" */
+    [JsonPropertyName("createNewProfileTypesBlacklist")]
+    public List<string> CreateNewProfileTypesBlacklist { get; set; }
+}
+
+public class ChatbotFeatures
+{
+    [JsonPropertyName("sptFriendEnabled")]
+    public bool SptFriendEnabled { get; set; }
+
+    [JsonPropertyName("sptFriendGiftsEnabled")]
+    public bool SptFriendGiftsEnabled { get; set; }
+
+    [JsonPropertyName("commandoEnabled")]
+    public bool CommandoEnabled { get; set; }
+
+    [JsonPropertyName("commandoFeatures")]
+    public CommandoFeatures CommandoFeatures { get; set; }
+
+    [JsonPropertyName("commandUseLimits")]
+    public Dictionary<string, int> CommandUseLimits { get; set; }
+
+    [JsonPropertyName("ids")]
+    public Dictionary<string, string> Ids { get; set; }
+}
+
+public class CommandoFeatures
+{
+    [JsonPropertyName("giveCommandEnabled")]
+    public bool GiveCommandEnabled { get; set; }
+}

Core/Models/Spt/Config/GiftsConfig.cs

@@ -0,0 +1,65 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Spt.Dialog;
+
+namespace Core.Models.Spt.Config;
+
+public class Gift
+{
+    /// <summary>
+    /// Items to send to player
+    /// </summary>
+    [JsonPropertyName("items")]
+    public List<Item> Items { get; set; }
+
+    /// <summary>
+    /// Who is sending the gift to player
+    /// </summary>
+    [JsonPropertyName("sender")]
+    public GiftSenderType Sender { get; set; }
+
+    /// <summary>
+    /// Optional - supply a users id to send from, not necessary when sending from SYSTEM or TRADER
+    /// </summary>
+    [JsonPropertyName("senderId")]
+    public string? SenderId { get; set; }
+
+    [JsonPropertyName("senderDetails")]
+    public UserDialogInfo SenderDetails { get; set; }
+
+    /// <summary>
+    /// Optional - supply a trader type to send from, not necessary when sending from SYSTEM or USER
+    /// </summary>
+    [JsonPropertyName("trader")]
+    public Traders? Trader { get; set; }
+
+    [JsonPropertyName("messageText")]
+    public string MessageText { get; set; }
+
+    /// <summary>
+    /// Optional - if sending text from the client locale file
+    /// </summary>
+    [JsonPropertyName("localeTextId")]
+    public string? LocaleTextId { get; set; }
+
+    /// <summary>
+    /// Optional - Used by Seasonal events to send on specific day
+    /// </summary>
+    [JsonPropertyName("timestampToSend")]
+    public long? TimestampToSend { get; set; }
+
+    [JsonPropertyName("associatedEvent")]
+    public SeasonalEventType AssociatedEvent { get; set; }
+
+    [JsonPropertyName("collectionTimeHours")]
+    public int CollectionTimeHours { get; set; }
+
+    /// <summary>
+    /// Optional, can be used to change profile settings like level/skills
+    /// </summary>
+    [JsonPropertyName("profileChangeEvents")]
+    public List<ProfileChangeEvent>? ProfileChangeEvents { get; set; }
+
+    [JsonPropertyName("maxToSendPlayer")]
+    public int? MaxToSendPlayer { get; set; }
+}

Core/Models/Spt/Config/HealthConfig.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class HealthConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-health";
+
+    [JsonPropertyName("healthMultipliers")]
+    public HealthMultipliers HealthMultipliers { get; set; }
+
+    [JsonPropertyName("save")]
+    public HealthSave Save { get; set; }
+}
+
+public class HealthMultipliers
+{
+    [JsonPropertyName("death")]
+    public double Death { get; set; }
+
+    [JsonPropertyName("blacked")]
+    public double Blacked { get; set; }
+}
+
+public class HealthSave
+{
+    [JsonPropertyName("health")]
+    public bool Health { get; set; }
+
+    [JsonPropertyName("effects")]
+    public bool Effects { get; set; }
+}

Core/Models/Spt/Config/HideoutConfig.cs

@@ -0,0 +1,142 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class HideoutConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-hideout";
+
+    /// <summary>
+    /// How many seconds should pass before hideout crafts / fuel usage is checked and processed
+    /// </summary>
+    [JsonPropertyName("runIntervalSeconds")]
+    public int RunIntervalSeconds { get; set; }
+
+    /// <summary>
+    /// Default values used to hydrate `RunIntervalSeconds` with
+    /// </summary>
+    [JsonPropertyName("runIntervalValues")]
+    public RunIntervalValues RunIntervalValues { get; set; }
+
+    [JsonPropertyName("hoursForSkillCrafting")]
+    public int HoursForSkillCrafting { get; set; }
+    
+    [JsonPropertyName("expCraftAmount")]
+    public int ExpCraftAmount { get; set; }
+    
+    [JsonPropertyName("overrideCraftTimeSeconds")]
+    public int OverrideCraftTimeSeconds { get; set; }
+    
+    [JsonPropertyName("overrideBuildTimeSeconds")]
+    public int OverrideBuildTimeSeconds { get; set; }
+
+    /// <summary>
+    /// Only process a profile's hideout crafts when it has been active in the last x minutes
+    /// </summary>
+    [JsonPropertyName("updateProfileHideoutWhenActiveWithinMinutes")]
+    public int UpdateProfileHideoutWhenActiveWithinMinutes { get; set; }
+
+    [JsonPropertyName("cultistCircle")]
+    public CultistCircleSettings CultistCircle { get; set; }
+}
+
+public class CultistCircleSettings
+{
+    [JsonPropertyName("maxRewardItemCount")]
+    public int MaxRewardItemCount { get; set; }
+    
+    [JsonPropertyName("maxAttemptsToPickRewardsWithinBudget")]
+    public int MaxAttemptsToPickRewardsWithinBudget { get; set; }
+    
+    [JsonPropertyName("rewardPriceMultiplerMinMax")]
+    public MinMax RewardPriceMultiplerMinMax { get; set; }
+
+    /// <summary>
+    /// The odds that meeting the highest threshold gives you a bonus to crafting time
+    /// </summary>
+    [JsonPropertyName("bonusAmountMultiplier")]
+    public double BonusAmountMultiplier { get; set; }
+    
+    [JsonPropertyName("bonusChanceMultiplier")]
+    public double BonusChanceMultiplier { get; set; }
+
+    /// <summary>
+    /// What is considered a "high-value" item
+    /// </summary>
+    [JsonPropertyName("highValueThresholdRub")]
+    public int HighValueThresholdRub { get; set; }
+
+    /// <summary>
+    /// Hideout/task reward crafts have a unique craft time
+    /// </summary>
+    [JsonPropertyName("hideoutTaskRewardTimeSeconds")]
+    public int HideoutTaskRewardTimeSeconds { get; set; }
+
+    /// <summary>
+    /// Rouble amount player needs to sacrifice to get chance of hideout/task rewards
+    /// </summary>
+    [JsonPropertyName("hideoutCraftSacrificeThresholdRub")]
+    public int HideoutCraftSacrificeThresholdRub { get; set; }
+    
+    [JsonPropertyName("craftTimeThreshholds")]
+    public List<CraftTimeThreshhold> CraftTimeThreshholds { get; set; }
+    
+    /// <summary>
+    /// -1 means no override, value in seconds
+    /// </summary>
+    [JsonPropertyName("craftTimeOverride")]
+    public int CraftTimeOverride { get; set; }
+
+    /// <summary>
+    /// Specific reward pool when player sacrifices specific item(s)
+    /// </summary>
+    [JsonPropertyName("directRewards")]
+    public List<DirectRewardSettings> DirectRewards { get; set; }
+
+    /// <summary>
+    /// Overrides for reward stack sizes, keyed by item tpl
+    /// </summary>
+    [JsonPropertyName("directRewardStackSize")]
+    public Dictionary<string, MinMax> DirectRewardStackSize { get; set; }
+
+    /// <summary>
+    /// Item tpls to exclude from the reward pool
+    /// </summary>
+    [JsonPropertyName("rewardItemBlacklist")]
+    public List<string> RewardItemBlacklist { get; set; }
+
+    /// <summary>
+    /// Item tpls to include in the reward pool
+    /// </summary>
+    [JsonPropertyName("additionalRewardItemPool")]
+    public List<string> AdditionalRewardItemPool { get; set; }
+
+    [JsonPropertyName("currencyRewards")]
+    public Dictionary<string, MinMax> CurrencyRewards { get; set; }
+}
+
+public class CraftTimeThreshhold : MinMax
+{
+    [JsonPropertyName("craftTimeSeconds")]
+    public int CraftTimeSeconds { get; set; }
+}
+
+public class DirectRewardSettings
+{
+    [JsonPropertyName("reward")]
+    public List<string> Reward { get; set; }
+    
+    [JsonPropertyName("requiredItems")]
+    public List<string> RequiredItems { get; set; }
+    
+    [JsonPropertyName("craftTimeSeconds")]
+    public int CraftTimeSeconds { get; set; }
+
+    /// <summary>
+    /// Is the reward a one time reward or can it be given multiple times
+    /// </summary>
+    [JsonPropertyName("repeatable")]
+    public bool Repeatable { get; set; }
+}

Core/Models/Spt/Config/HttpConfig.cs

@@ -0,0 +1,39 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class HttpConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-http";
+
+    /// <summary>
+    /// Address used by webserver
+    /// </summary>
+    [JsonPropertyName("ip")]
+    public string Ip { get; set; }
+
+    [JsonPropertyName("port")]
+    public int Port { get; set; }
+
+    /// <summary>
+    /// Address used by game client to connect to
+    /// </summary>
+    [JsonPropertyName("backendIp")]
+    public string BackendIp { get; set; }
+
+    [JsonPropertyName("backendPort")]
+    public string BackendPort { get; set; }
+
+    [JsonPropertyName("webSocketPingDelayMs")]
+    public int WebSocketPingDelayMs { get; set; }
+
+    [JsonPropertyName("logRequests")]
+    public bool LogRequests { get; set; }
+
+    /// <summary>
+    /// e.g. "SPT_Data/Server/images/traders/579dc571d53a0658a154fbec.png": "SPT_Data/Server/images/traders/NewTraderImage.png"
+    /// </summary>
+    [JsonPropertyName("serverImagePathOverride")]
+    public Dictionary<string, string> ServerImagePathOverride { get; set; }
+}

Core/Models/Spt/Config/InRaidConfig.cs

@@ -0,0 +1,87 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class InRaidConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-inraid";
+
+    /** Overrides to apply to the pre-raid settings screen */
+    [JsonPropertyName("raidMenuSettings")]
+    public RaidMenuSettings RaidMenuSettings { get; set; }
+
+    /** What effects should be saved post-raid */
+    [JsonPropertyName("save")]
+    public RaidSave Save { get; set; }
+
+    /** Names of car extracts */
+    [JsonPropertyName("carExtracts")]
+    public List<string> CarExtracts { get; set; }
+
+    /** Names of coop extracts */
+    [JsonPropertyName("coopExtracts")]
+    public List<string> CoopExtracts { get; set; }
+
+    /** Fence rep gain from a single car extract */
+    [JsonPropertyName("carExtractBaseStandingGain")]
+    public double CarExtractBaseStandingGain { get; set; }
+
+    /** Fence rep gain from a single coop extract */
+    [JsonPropertyName("coopExtractBaseStandingGain")]
+    public double CoopExtractBaseStandingGain { get; set; }
+
+    /** Fence rep gain when successfully extracting as pscav */
+    [JsonPropertyName("scavExtractStandingGain")]
+    public double ScavExtractStandingGain { get; set; }
+
+    /** The likelihood of PMC eliminating a minimum of 2 scavs while you engage them as a pscav. */
+    [JsonPropertyName("pmcKillProbabilityForScavGain")]
+    public double PmcKillProbabilityForScavGain { get; set; }
+
+    /** On death should items in your secure keep their Find in raid status regardless of how you finished the raid */
+    [JsonPropertyName("keepFiRSecureContainerOnDeath")]
+    public bool KeepFiRSecureContainerOnDeath { get; set; }
+
+    /** If enabled always keep found in raid status on items */
+    [JsonPropertyName("alwaysKeepFoundInRaidonRaidEnd")]
+    public bool AlwaysKeepFoundInRaidOnRaidEnd { get; set; }
+
+    /** Percentage chance a player scav hot is hostile to the player when scavving */
+    [JsonPropertyName("playerScavHostileChancePercent")]
+    public double PlayerScavHostileChancePercent { get; set; }
+}
+
+public class RaidMenuSettings
+{
+    [JsonPropertyName("aiAmount")]
+    public string AiAmount { get; set; }
+
+    [JsonPropertyName("aiDifficulty")]
+    public string AiDifficulty { get; set; }
+
+    [JsonPropertyName("bossEnabled")]
+    public bool BossEnabled { get; set; }
+
+    [JsonPropertyName("scavWars")]
+    public bool ScavWars { get; set; }
+
+    [JsonPropertyName("taggedAndCursed")]
+    public bool TaggedAndCursed { get; set; }
+
+    [JsonPropertyName("enablePve")]
+    public bool EnablePve { get; set; }
+
+    [JsonPropertyName("randomWeather")]
+    public bool RandomWeather { get; set; }
+
+    [JsonPropertyName("randomTime")]
+    public bool RandomTime { get; set; }
+}
+
+public class RaidSave
+{
+    /** Should loot gained from raid be saved */
+    [JsonPropertyName("loot")]
+    public bool Loot { get; set; }
+}

Core/Models/Spt/Config/InsuranceConfig.cs

@@ -0,0 +1,56 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class InsuranceConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-insurance";
+
+    /// <summary>
+    /// Chance item is returned as insurance, keyed by trader id
+    /// </summary>
+    [JsonPropertyName("returnChancePercent")]
+    public Dictionary<string, double> ReturnChancePercent { get; set; }
+
+    /// <summary>
+    /// Item slots that should never be returned as insurance
+    /// </summary>
+    [JsonPropertyName("blacklistedEquipment")]
+    public List<string> BlacklistedEquipment { get; set; }
+
+    /// <summary>
+    /// Some slots should always be removed, e.g. 'cartridges'
+    /// </summary>
+    [JsonPropertyName("slotIdsToAlwaysRemove")]
+    public List<string> SlotIdsToAlwaysRemove { get; set; }
+
+    /// <summary>
+    /// Override to control how quickly insurance is processed/returned in seconds
+    /// </summary>
+    [JsonPropertyName("returnTimeOverrideSeconds")]
+    public double ReturnTimeOverrideSeconds { get; set; }
+
+    /// <summary>
+    /// Override to control how long insurance returns stay in mail before expiring - in seconds
+    /// </summary>
+    [JsonPropertyName("storageTimeOverrideSeconds")]
+    public double StorageTimeOverrideSeconds { get; set; }
+
+    /// <summary>
+    /// How often server should process insurance in seconds
+    /// </summary>
+    [JsonPropertyName("runIntervalSeconds")]
+    public double RunIntervalSeconds { get; set; }
+
+    // Lowest rouble price for an attachment to be allowed to be taken
+    [JsonPropertyName("minAttachmentRoublePriceToBeTaken")]
+    public double MinAttachmentRoublePriceToBeTaken { get; set; }
+
+    // Chance out of 100% no attachments from a parent are taken
+    [JsonPropertyName("chanceNoAttachmentsTakenPercent")]
+    public double ChanceNoAttachmentsTakenPercent { get; set; }
+
+    [JsonPropertyName("simulateItemsBeingTaken")]
+    public bool SimulateItemsBeingTaken { get; set; }
+}

Core/Models/Spt/Config/InventoryConfig.cs

@@ -0,0 +1,72 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class InventoryConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-inventory";
+    
+    /** Should new items purchased by flagged as found in raid */
+    [JsonPropertyName("newItemsMarkedFound")]
+    public bool NewItemsMarkedFound { get; set; }
+    
+    [JsonPropertyName("randomLootContainers")]
+    public Dictionary<string, RewardDetails> RandomLootContainers { get; set; }
+    
+    [JsonPropertyName("sealedAirdropContainer")]
+    public SealedAirdropContainerSettings SealedAirdropContainer { get; set; }
+    
+    /** Contains item tpls that the server should consider money and treat the same as roubles/euros/dollars */
+    [JsonPropertyName("customMoneyTpls")]
+    public List<string> CustomMoneyTpls { get; set; }
+    
+    /** Multipliers for skill gain when inside menus, NOT in-game */
+    [JsonPropertyName("skillGainMultiplers")]
+    public Dictionary<string, double> SkillGainMultipliers { get; set; }
+    
+    /** Container Tpls that should be deprioritised when choosing where to take money from for payments */
+    [JsonPropertyName("deprioritisedMoneyContainers")]
+    public List<string> DeprioritisedMoneyContainers { get; set; }
+}
+
+public class RewardDetails
+{
+    [JsonPropertyName("rewardCount")]
+    public int RewardCount { get; set; }
+    
+    [JsonPropertyName("foundInRaid")]
+    public bool FoundInRaid { get; set; }
+    
+    [JsonPropertyName("rewardTplPool")]
+    public Dictionary<string, int>? RewardTplPool { get; set; }
+    
+    [JsonPropertyName("rewardTypePool")]
+    public List<string>? RewardTypePool { get; set; }
+}
+
+public class SealedAirdropContainerSettings
+{
+    [JsonPropertyName("weaponRewardWeight")]
+    public Dictionary<string, double> WeaponRewardWeight { get; set; }
+    
+    [JsonPropertyName("defaultPresetsOnly")]
+    public bool DefaultPresetsOnly { get; set; }
+    
+    /** Should contents be flagged as found in raid when opened */
+    [JsonPropertyName("foundInRaid")]
+    public bool FoundInRaid { get; set; }
+    
+    [JsonPropertyName("weaponModRewardLimits")]
+    public Dictionary<string, MinMax> WeaponModRewardLimits { get; set; }
+    
+    [JsonPropertyName("rewardTypeLimits")]
+    public Dictionary<string, MinMax> RewardTypeLimits { get; set; }
+    
+    [JsonPropertyName("ammoBoxWhitelist")]
+    public List<string> AmmoBoxWhitelist { get; set; }
+    
+    [JsonPropertyName("allowBossItems")]
+    public bool AllowBossItems { get; set; }
+}

Core/Models/Spt/Config/ItemConfig.cs

@@ -0,0 +1,47 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class ItemConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-item";
+
+    /** Items that should be globally blacklisted */
+    [JsonPropertyName("blacklist")]
+    public List<string> Blacklist { get; set; }
+
+    /** Items that should not be lootable from any location */
+    [JsonPropertyName("lootableItemBlacklist")]
+    public List<string> LootableItemBlacklist { get; set; }
+
+    /** items that should not be given as rewards */
+    [JsonPropertyName("rewardItemBlacklist")]
+    public List<string> RewardItemBlacklist { get; set; }
+
+    /** Item base types that should not be given as rewards */
+    [JsonPropertyName("rewardItemTypeBlacklist")]
+    public List<string> RewardItemTypeBlacklist { get; set; }
+
+    /** Items that can only be found on bosses */
+    [JsonPropertyName("bossItems")]
+    public List<string> BossItems { get; set; }
+
+    [JsonPropertyName("handbookPriceOverride")]
+    public Dictionary<string, HandbookPriceOverride> HandbookPriceOverride { get; set; }
+
+    /** Presets to add to the globals.json `ItemPresets` dictionary on server start */
+    [JsonPropertyName("customItemGlobalPresets")]
+    public List<Preset> CustomItemGlobalPresets { get; set; }
+}
+
+public class HandbookPriceOverride
+{
+    /** Price in roubles */
+    [JsonPropertyName("price")]
+    public decimal Price { get; set; }
+
+    /** NOT parentId from items.json, but handbook.json */
+    [JsonPropertyName("parentId")]
+    public string ParentId { get; set; }
+}

Core/Models/Spt/Config/LocaleConfig.cs

@@ -0,0 +1,24 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class LocaleConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-locale";
+    
+    /** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */
+    [JsonPropertyName("gameLocale")]
+    public string GameLocale { get; set; }
+
+    /** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */
+    [JsonPropertyName("serverLocale")]
+    public string ServerLocale { get; set; }
+
+    /** Languages server can be translated into */
+    [JsonPropertyName("serverSupportedLocales")]
+    public List<string> ServerSupportedLocales { get; set; }
+
+    [JsonPropertyName("fallbacks")]
+    public Dictionary<string, string> Fallbacks { get; set; }
+}

Core/Models/Spt/Config/LocationConfig.cs

@@ -0,0 +1,319 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class LocationConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-location";
+
+    /// <summary>
+    /// Rogues are classified as bosses and spawn immediately, this can result in no scavs spawning, delay rogues spawning to allow scavs to spawn first
+    /// </summary>
+    [JsonPropertyName("rogueLighthouseSpawnTimeSettings")]
+    public RogueLighthouseSpawnTimeSettings RogueLighthouseSpawnTimeSettings { get; set; }
+
+    /// <summary>
+    /// When a map has hit max alive bots, any wave that should spawn will be reduced to 1 bot in size and placed in a spawn queue, this splits waves into smaller sizes to reduce the impact of this behaviour
+    /// </summary>
+    [JsonPropertyName("splitWaveIntoSingleSpawnsSettings")]
+    public SplitWaveSettings SplitWaveIntoSingleSpawnsSettings { get; set; }
+
+    [JsonPropertyName("looseLootMultiplier")]
+    public LootMultiplier LooseLootMultiplier { get; set; }
+    
+    [JsonPropertyName("staticLootMultiplier")]
+    public LootMultiplier StaticLootMultiplier { get; set; }
+
+    /// <summary>
+    /// Custom bot waves to add to a locations base json on game start if addCustomBotWavesToMaps is true
+    /// </summary>
+    [JsonPropertyName("customWaves")]
+    public CustomWaves CustomWaves { get; set; }
+
+    /// <summary>
+    /// Open zones to add to map
+    /// </summary>
+    [JsonPropertyName("openZones")]
+    public Dictionary<string, List<string>> OpenZones { get; set; }
+
+    /// <summary>
+    /// Key = map id, value = item tpls that should only have one forced loot spawn position
+    /// </summary>
+    [JsonPropertyName("forcedLootSingleSpawnById")]
+    public Dictionary<string, List<string>> ForcedLootSingleSpawnById { get; set; }
+
+    /// <summary>
+    /// How many attempts should be taken to fit an item into a container before giving up
+    /// </summary>
+    [JsonPropertyName("fitLootIntoContainerAttempts")]
+    public int FitLootIntoContainerAttempts { get; set; }
+
+    /// <summary>
+    /// Add all possible zones to each maps `OpenZones` property
+    /// </summary>
+    [JsonPropertyName("addOpenZonesToAllMaps")]
+    public bool AddOpenZonesToAllMaps { get; set; }
+
+    /// <summary>
+    /// Allow addition of custom bot waves designed by SPT to be added to maps - defined in configs/location.json.customWaves
+    /// </summary>
+    [JsonPropertyName("addCustomBotWavesToMaps")]
+    public bool AddCustomBotWavesToMaps { get; set; }
+
+    /// <summary>
+    /// Should the limits defined inside botTypeLimits to be applied to locations on game start
+    /// </summary>
+    [JsonPropertyName("enableBotTypeLimits")]
+    public bool EnableBotTypeLimits { get; set; }
+
+    /// <summary>
+    /// Add limits to a locations base.MinMaxBots array if enableBotTypeLimits is true
+    /// </summary>
+    [JsonPropertyName("botTypeLimits")]
+    public Dictionary<string, List<BotTypeLimit>> BotTypeLimits { get; set; }
+    
+    /// <summary>
+    /// Container randomisation settings
+    /// </summary>
+    [JsonPropertyName("containerRandomisationSettings")]
+    public ContainerRandomisationSettings ContainerRandomisationSettings { get; set; }
+
+    /// <summary>
+    /// How full must a random loose magazine be %
+    /// </summary>
+    [JsonPropertyName("minFillLooseMagazinePercent")]
+    public int MinFillLooseMagazinePercent { get; set; }
+
+    /// <summary>
+    /// How full must a random static magazine be %
+    /// </summary>
+    [JsonPropertyName("minFillStaticMagazinePercent")]
+    public int MinFillStaticMagazinePercent { get; set; }
+
+    [JsonPropertyName("allowDuplicateItemsInStaticContainers")]
+    public bool AllowDuplicateItemsInStaticContainers { get; set; }
+
+    /// <summary>
+    /// Chance loose magazines have ammo in them TODO - rename to dynamicMagazineLootHasAmmoChancePercent
+    /// </summary>
+    [JsonPropertyName("magazineLootHasAmmoChancePercent")]
+    public int MagazineLootHasAmmoChancePercent { get; set; }
+
+    /// <summary>
+    /// Chance static magazines have ammo in them
+    /// </summary>
+    [JsonPropertyName("staticMagazineLootHasAmmoChancePercent")]
+    public int StaticMagazineLootHasAmmoChancePercent { get; set; }
+
+    /// <summary>
+    /// Key: map, value: loose loot ids to ignore
+    /// </summary>
+    [JsonPropertyName("looseLootBlacklist")]
+    public Dictionary<string, List<string>> LooseLootBlacklist { get; set; }
+
+    /// <summary>
+    /// Key: map, value: settings to control how long scav raids are
+    /// </summary>
+    [JsonPropertyName("scavRaidTimeSettings")]
+    public ScavRaidTimeSettings ScavRaidTimeSettings { get; set; }
+
+    /// <summary>
+    /// Settings to adjust mods for lootable equipment in raid
+    /// </summary>
+    [JsonPropertyName("equipmentLootSettings")]
+    public EquipmentLootSettings EquipmentLootSettings { get; set; }
+
+    /// <summary>
+    /// Min percentage to set raider spawns at, -1 makes no changes
+    /// </summary>
+    [JsonPropertyName("reserveRaiderSpawnChanceOverrides")]
+    public ReserveRaiderSpawnChanceOverrides ReserveRaiderSpawnChanceOverrides { get; set; }
+
+    /// <summary>
+    /// Map ids players cannot visit
+    /// </summary>
+    [JsonPropertyName("nonMaps")]
+    public List<string> NonMaps { get; set; }
+}
+
+public class ReserveRaiderSpawnChanceOverrides
+{
+    [JsonPropertyName("nonTriggered")]
+    public int NonTriggered { get; set; }
+    
+    [JsonPropertyName("triggered")]
+    public int Triggered { get; set; }
+}
+
+public class EquipmentLootSettings
+{
+    // Percentage chance item will be added to equipment
+    [JsonPropertyName("modSpawnChancePercent")]
+    public Dictionary<string, int> ModSpawnChancePercent { get; set; }
+}
+
+public class FixEmptyBotWavesSettings
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+    
+    [JsonPropertyName("ignoreMaps")]
+    public List<string> IgnoreMaps { get; set; }
+}
+
+public class RogueLighthouseSpawnTimeSettings
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+    
+    [JsonPropertyName("waitTimeSeconds")]
+    public int WaitTimeSeconds { get; set; }
+}
+
+public class SplitWaveSettings
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+    
+    [JsonPropertyName("ignoreMaps")]
+    public List<string> IgnoreMaps { get; set; }
+    
+    [JsonPropertyName("waveSizeThreshold")]
+    public int WaveSizeThreshold { get; set; }
+}
+
+public class CustomWaves
+{
+    /** Bosses spawn on raid start */
+    [JsonPropertyName("boss")]
+    public Dictionary<string, List<BossLocationSpawn>> Boss { get; set; }
+    
+    [JsonPropertyName("normal")]
+    public Dictionary<string, List<Wave>> Normal { get; set; }
+}
+
+public class BotTypeLimit : MinMax
+{
+    [JsonPropertyName("type")]
+    public string Type { get; set; }
+}
+
+/** Multiplier to apply to the loot count for a given map */
+public class LootMultiplier
+{
+    [JsonPropertyName("bigmap")]
+    public int BigMap { get; set; }
+    
+    [JsonPropertyName("develop")]
+    public int Develop { get; set; }
+    
+    [JsonPropertyName("factory4_day")]
+    public int Factory4Day { get; set; }
+    
+    [JsonPropertyName("factory4_night")]
+    public int Factory4Night { get; set; }
+    
+    [JsonPropertyName("interchange")]
+    public int Interchange { get; set; }
+    
+    [JsonPropertyName("laboratory")]
+    public int Laboratory { get; set; }
+    
+    [JsonPropertyName("rezervbase")]
+    public int RezervBase { get; set; }
+    
+    [JsonPropertyName("shoreline")]
+    public int Shoreline { get; set; }
+    
+    [JsonPropertyName("woods")]
+    public int Woods { get; set; }
+    
+    [JsonPropertyName("hideout")]
+    public int Hideout { get; set; }
+    
+    [JsonPropertyName("lighthouse")]
+    public int Lighthouse { get; set; }
+    
+    [JsonPropertyName("privatearea")]
+    public int PrivateArea { get; set; }
+    
+    [JsonPropertyName("suburbs")]
+    public int Suburbs { get; set; }
+    
+    [JsonPropertyName("tarkovstreets")]
+    public int TarkovStreets { get; set; }
+    
+    [JsonPropertyName("terminal")]
+    public int Terminal { get; set; }
+    
+    [JsonPropertyName("town")]
+    public int Town { get; set; }
+    
+    [JsonPropertyName("sandbox")]
+    public int Sandbox { get; set; }
+}
+
+public class ContainerRandomisationSettings
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+    
+    /** What maps can use the container randomisation feature */
+    [JsonPropertyName("maps")]
+    public Dictionary<string, bool> Maps { get; set; }
+    
+    /** Some container types don't work when randomised */
+    [JsonPropertyName("containerTypesToNotRandomise")]
+    public List<string> ContainerTypesToNotRandomise { get; set; }
+    
+    [JsonPropertyName("containerGroupMinSizeMultiplier")]
+    public double ContainerGroupMinSizeMultiplier { get; set; }
+    
+    [JsonPropertyName("containerGroupMaxSizeMultiplier")]
+    public double ContainerGroupMaxSizeMultiplier { get; set; }
+}
+
+public class ScavRaidTimeSettings
+{
+    [JsonPropertyName("settings")]
+    public ScavRaidTimeConfigSettings Settings { get; set; }
+    
+    [JsonPropertyName("maps")]
+    public Dictionary<string, ScavRaidTimeLocationSettings> Maps { get; set; }
+}
+
+public class ScavRaidTimeConfigSettings
+{
+    [JsonPropertyName("trainArrivalDelayObservedSeconds")]
+    public int TrainArrivalDelayObservedSeconds { get; set; }
+}
+
+public class ScavRaidTimeLocationSettings
+{
+    /** Should loot be reduced by same percent length of raid is reduced by */
+    [JsonPropertyName("reduceLootByPercent")]
+    public bool ReduceLootByPercent { get; set; }
+    
+    /** Smallest % of container loot that should be spawned */
+    [JsonPropertyName("minStaticLootPercent")]
+    public double MinStaticLootPercent { get; set; }
+    
+    /** Smallest % of loose loot that should be spawned */
+    [JsonPropertyName("minDynamicLootPercent")]
+    public double MinDynamicLootPercent { get; set; }
+    
+    /** Chance raid time is reduced */
+    [JsonPropertyName("reducedChancePercent")]
+    public double ReducedChancePercent { get; set; }
+    
+    /** How much should raid time be reduced - weighted */
+    [JsonPropertyName("reductionPercentWeights")]
+    public Dictionary<string, double> ReductionPercentWeights { get; set; }
+    
+    /** Should bot waves be removed / spawn times be adjusted */
+    [JsonPropertyName("adjustWaves")]
+    public bool AdjustWaves { get; set; }
+}

Core/Models/Spt/Config/LootConfig.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class LootConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-loot";
+
+    /** Spawn positions to add into a map, key=mapid */
+    [JsonPropertyName("looseLoot")]
+    public Dictionary<string, Spawnpoint[]> LooseLoot { get; set; }
+
+    /** Loose loot probability adjustments to apply on game start */
+    [JsonPropertyName("looseLootSpawnPointAdjustments")]
+    public Dictionary<string, Dictionary<string, double>> LooseLootSpawnPointAdjustments { get; set; }
+}

Core/Models/Spt/Config/LostOnDeathConfig.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class LostOnDeathConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-lostondeath";
+    
+    /** What equipment in each slot should be lost on death */
+    [JsonPropertyName("equipment")]
+    public LostEquipment Equipment { get; set; }
+    
+    /** Should special slot items be removed from quest inventory on death e.g. wifi camera/markers */
+    [JsonPropertyName("specialSlotItems")]
+    public bool SpecialSlotItems { get; set; }
+    
+    /** Should quest items be removed from quest inventory on death */
+    [JsonPropertyName("questItems")]
+    public bool QuestItems { get; set; }
+}
+
+public class LostEquipment
+{
+    [JsonPropertyName("ArmBand")]
+    public bool ArmBand { get; set; }
+    
+    [JsonPropertyName("Headwear")]
+    public bool Headwear { get; set; }
+    
+    [JsonPropertyName("Earpiece")]
+    public bool Earpiece { get; set; }
+    
+    [JsonPropertyName("FaceCover")]
+    public bool FaceCover { get; set; }
+    
+    [JsonPropertyName("ArmorVest")]
+    public bool ArmorVest { get; set; }
+    
+    [JsonPropertyName("Eyewear")]
+    public bool Eyewear { get; set; }
+    
+    [JsonPropertyName("TacticalVest")]
+    public bool TacticalVest { get; set; }
+    
+    [JsonPropertyName("PocketItems")]
+    public bool PocketItems { get; set; }
+    
+    [JsonPropertyName("Backpack")]
+    public bool Backpack { get; set; }
+    
+    [JsonPropertyName("Holster")]
+    public bool Holster { get; set; }
+    
+    [JsonPropertyName("FirstPrimaryWeapon")]
+    public bool FirstPrimaryWeapon { get; set; }
+    
+    [JsonPropertyName("SecondPrimaryWeapon")]
+    public bool SecondPrimaryWeapon { get; set; }
+    
+    [JsonPropertyName("Scabbard")]
+    public bool Scabbard { get; set; }
+}

Core/Models/Spt/Config/MatchConfig.cs

@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class MatchConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-match";
+    
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+}

Core/Models/Spt/Config/PlayerScavConfig.cs

@@ -0,0 +1,61 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Config;
+
+public class PlayerScavConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-playerscav";
+
+    [JsonPropertyName("karmaLevel")]
+    public Dictionary<string, KarmaLevel> KarmaLevel { get; set; }
+}
+
+public class KarmaLevel
+{
+    [JsonPropertyName("botTypeForLoot")]
+    public string BotTypeForLoot { get; set; }
+
+    [JsonPropertyName("modifiers")]
+    public Modifiers Modifiers { get; set; }
+
+    [JsonPropertyName("itemLimits")]
+    public ItemLimits ItemLimits { get; set; }
+
+    [JsonPropertyName("equipmentBlacklist")]
+    public Dictionary<string, string[]> EquipmentBlacklist { get; set; }
+
+    [JsonPropertyName("lootItemsToAddChancePercent")]
+    public Dictionary<string, double> LootItemsToAddChancePercent { get; set; }
+}
+
+public class Modifiers
+{
+    [JsonPropertyName("equipment")]
+    public Dictionary<string, double> Equipment { get; set; }
+
+    [JsonPropertyName("mod")]
+    public Dictionary<string, double> Mod { get; set; }
+}
+
+public class ItemLimits
+{
+    [JsonPropertyName("healing")]
+    public GenerationData Healing { get; set; }
+
+    [JsonPropertyName("drugs")]
+    public GenerationData Drugs { get; set; }
+
+    [JsonPropertyName("stims")]
+    public GenerationData Stims { get; set; }
+
+    [JsonPropertyName("looseLoot")]
+    public GenerationData LooseLoot { get; set; }
+
+    [JsonPropertyName("magazines")]
+    public GenerationData Magazines { get; set; }
+
+    [JsonPropertyName("grenades")]
+    public GenerationData Grenades { get; set; }
+}

Core/Models/Spt/Config/PmcChatResponse.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Config;
+
+public class PmcChatResponse : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-pmcchatresponse";
+
+    [JsonPropertyName("victim")]
+    public ResponseSettings Victim { get; set; }
+
+    [JsonPropertyName("killer")]
+    public ResponseSettings Killer { get; set; }
+}
+
+public class ResponseSettings
+{
+    [JsonPropertyName("responseChancePercent")]
+    public double ResponseChancePercent { get; set; }
+
+    [JsonPropertyName("responseTypeWeights")]
+    public Dictionary<string, double> ResponseTypeWeights { get; set; }
+
+    [JsonPropertyName("stripCapitalisationChancePercent")]
+    public double StripCapitalisationChancePercent { get; set; }
+
+    [JsonPropertyName("allCapsChancePercent")]
+    public double AllCapsChancePercent { get; set; }
+
+    [JsonPropertyName("appendBroToMessageEndChancePercent")]
+    public double AppendBroToMessageEndChancePercent { get; set; }
+}

Core/Models/Spt/Config/PmcConfig.cs

@@ -0,0 +1,162 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+using Core.Models.Eft.Common;
+using Core.Models.Enums;
+
+namespace Core.Models.Spt.Config;
+
+public class PmcConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-pmc";
+    
+    /** What game version should the PMC have */
+    [JsonPropertyName("gameVersionWeight")]
+    public Dictionary<string, double> GameVersionWeight { get; set; }
+    
+    /** What account type should the PMC have */
+    [JsonPropertyName("accountTypeWeight")]
+    public Dictionary<MemberCategory, double> AccountTypeWeight { get; set; }
+    
+    /** Global whitelist/blacklist of vest loot for PMCs */
+    [JsonPropertyName("vestLoot")]
+    public SlotLootSettings VestLoot { get; set; }
+    
+    /** Global whitelist/blacklist of pocket loot for PMCs */
+    [JsonPropertyName("pocketLoot")]
+    public SlotLootSettings PocketLoot { get; set; }
+    
+    /** Global whitelist/blacklist of backpack loot for PMCs */
+    [JsonPropertyName("backpackLoot")]
+    public SlotLootSettings BackpackLoot { get; set; }
+    
+    [JsonPropertyName("globalLootBlacklist")]
+    public List<string> GlobalLootBlacklist { get; set; }
+    
+    /** Use difficulty defined in config/bot.json/difficulty instead of chosen difficulty dropdown value */
+    [JsonPropertyName("useDifficultyOverride")]
+    public bool UseDifficultyOverride { get; set; }
+    
+    /** Difficulty override e.g. "AsOnline/Hard" */
+    [JsonPropertyName("difficulty")]
+    public string Difficulty { get; set; }
+    
+    /** Chance out of 100 to have a complete gun in backpack */
+    [JsonPropertyName("looseWeaponInBackpackChancePercent")]
+    public double LooseWeaponInBackpackChancePercent { get; set; }
+    
+    /** Chance out of 100 to have an enhancement applied to PMC weapon */
+    [JsonPropertyName("weaponHasEnhancementChancePercent")]
+    public double WeaponHasEnhancementChancePercent { get; set; }
+    
+    /** MinMax count of weapons to have in backpack */
+    [JsonPropertyName("looseWeaponInBackpackLootMinMax")]
+    public MinMax LooseWeaponInBackpackLootMinMax { get; set; }
+    
+    /** Percentage chance PMC will be USEC */
+    [JsonPropertyName("isUsec")]
+    public double IsUsec { get; set; }
+    
+    /** WildSpawnType enum value USEC PMCs use */
+    [JsonPropertyName("usecType")]
+    public string UsecType { get; set; }
+    
+    /** WildSpawnType enum value BEAR PMCs use */
+    [JsonPropertyName("bearType")]
+    public string BearType { get; set; }
+    
+    /** What 'brain' does a PMC use, keyed by map and side (USEC/BEAR) key: map location, value: type for usec/bear */
+    [JsonPropertyName("pmcType")]
+    public Dictionary<string, Dictionary<string, Dictionary<string, double>>> PmcType { get; set; }
+    
+    [JsonPropertyName("maxBackpackLootTotalRub")]
+    public List<IMinMaxLootValue> MaxBackpackLootTotalRub { get; set; }
+    
+    [JsonPropertyName("maxPocketLootTotalRub")]
+    public double MaxPocketLootTotalRub { get; set; }
+    
+    [JsonPropertyName("maxVestLootTotalRub")]
+    public double MaxVestLootTotalRub { get; set; }
+    
+    /** Percentage chance a bot from a wave is converted into a PMC, first key = map, second key = bot wildspawn type (assault/exusec), value: min+max chance to be converted */
+    [JsonPropertyName("convertIntoPmcChance")]
+    public Dictionary<string, Dictionary<string, MinMax>> ConvertIntoPmcChance { get; set; }
+    
+    /** How many levels above player level can a PMC be */
+    [JsonPropertyName("botRelativeLevelDeltaMax")]
+    public double BotRelativeLevelDeltaMax { get; set; }
+    
+    /** How many levels below player level can a PMC be */
+    [JsonPropertyName("botRelativeLevelDeltaMin")]
+    public double BotRelativeLevelDeltaMin { get; set; }
+    
+    /** Force a number of healing items into PMCs secure container to ensure they can heal */
+    [JsonPropertyName("forceHealingItemsIntoSecure")]
+    public bool ForceHealingItemsIntoSecure { get; set; }
+    
+    [JsonPropertyName("hostilitySettings")]
+    public Dictionary<string, HostilitySettings> HostilitySettings { get; set; }
+    
+    [JsonPropertyName("allPMCsHavePlayerNameWithRandomPrefixChance")]
+    public double AllPMCsHavePlayerNameWithRandomPrefixChance { get; set; }
+    
+    [JsonPropertyName("locationSpecificPmcLevelOverride")]
+    public Dictionary<string, MinMax> LocationSpecificPmcLevelOverride { get; set; }
+    
+    /** Should secure container loot from usec.json/bear.json be added to pmc bots secure */
+    [JsonPropertyName("addSecureContainerLootFromBotConfig")]
+    public bool AddSecureContainerLootFromBotConfig { get; set; }
+}
+
+public class HostilitySettings
+{
+    /** Bot roles that are 100% an enemy */
+    [JsonPropertyName("additionalEnemyTypes")]
+    public List<string>? AdditionalEnemyTypes { get; set; }
+    
+    /** Objects that determine the % chance another bot type is an enemy */
+    [JsonPropertyName("chancedEnemies")]
+    public List<ChancedEnemy>? ChancedEnemies { get; set; }
+    
+    [JsonPropertyName("bearEnemyChance")]
+    public double? BearEnemyChance { get; set; }
+    
+    [JsonPropertyName("usecEnemyChance")]
+    public double? UsecEnemyChance { get; set; }
+    
+    [JsonPropertyName("savageEnemyChance")]
+    public double? SavageEnemyChance { get; set; }
+    
+    /** Bot roles that are 100% a friendly */
+    [JsonPropertyName("additionalFriendlyTypes")]
+    public List<string>? AdditionalFriendlyTypes { get; set; }
+    
+    [JsonPropertyName("savagePlayerBehaviour")]
+    public string? SavagePlayerBehaviour { get; set; }
+}
+
+public class PmcTypes
+{
+    [JsonPropertyName("usec")]
+    public string Usec { get; set; }
+    
+    [JsonPropertyName("bear")]
+    public string Bear { get; set; }
+}
+
+public class SlotLootSettings
+{
+    /** Item Type whitelist */
+    [JsonPropertyName("whitelist")]
+    public List<string> Whitelist { get; set; }
+    
+    /** Item tpl blacklist */
+    [JsonPropertyName("blacklist")]
+    public List<string> Blacklist { get; set; }
+}
+
+public class IMinMaxLootValue : MinMax
+{
+    [JsonPropertyName("value")]
+    public double Value { get; set; }
+}

Core/Models/Spt/Config/QuestConfig.cs

@@ -0,0 +1,371 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+using Core.Models.Enums;
+
+namespace Core.Models.Spt.Config;
+
+public class QuestConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-quest";
+
+    // Hours to get/redeem items from quest mail keyed by profile type
+    [JsonPropertyName("mailRedeemTimeHours")]
+    public Dictionary<string, double> MailRedeemTimeHours { get; set; }
+
+    [JsonPropertyName("questTemplateIds")]
+    public PlayerTypeQuestIds QuestTemplateIds { get; set; }
+
+    /** Show non-seasonal quests be shown to player */
+    [JsonPropertyName("showNonSeasonalEventQuests")]
+    public bool ShowNonSeasonalEventQuests { get; set; }
+
+    [JsonPropertyName("eventQuests")]
+    public Dictionary<string, EventQuestData> EventQuests { get; set; }
+
+    [JsonPropertyName("repeatableQuests")]
+    public List<RepeatableQuestConfig> RepeatableQuests { get; set; }
+
+    [JsonPropertyName("locationIdMap")]
+    public Dictionary<string, string> LocationIdMap { get; set; }
+
+    [JsonPropertyName("bearOnlyQuests")]
+    public List<string> BearOnlyQuests { get; set; }
+
+    [JsonPropertyName("usecOnlyQuests")]
+    public List<string> UsecOnlyQuests { get; set; }
+
+    /** Quests that the keyed game version do not see/access */
+    [JsonPropertyName("profileBlacklist")]
+    public Dictionary<string, List<string>> ProfileBlacklist { get; set; }
+
+    /** key=questid, gameversions that can see/access quest */
+    [JsonPropertyName("profileWhitelist")]
+    public Dictionary<string, List<string>> ProfileWhitelist { get; set; }
+}
+
+public class PlayerTypeQuestIds
+{
+    [JsonPropertyName("pmc")]
+    public QuestTypeIds Pmc { get; set; }
+
+    [JsonPropertyName("scav")]
+    public QuestTypeIds Scav { get; set; }
+}
+
+public class QuestTypeIds
+{
+    [JsonPropertyName("Elimination")]
+    public string Elimination { get; set; }
+
+    [JsonPropertyName("Completion")]
+    public string Completion { get; set; }
+
+    [JsonPropertyName("Exploration")]
+    public string Exploration { get; set; }
+}
+
+public class EventQuestData
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+
+    [JsonPropertyName("season")]
+    public SeasonalEventType Season { get; set; }
+
+    [JsonPropertyName("startTimestamp")]
+    public long StartTimestamp { get; set; }
+
+    [JsonPropertyName("endTimestamp")]
+    public long EndTimestamp { get; set; }
+
+    [JsonPropertyName("yearly")]
+    public bool Yearly { get; set; }
+}
+
+public class RepeatableQuestConfig
+{
+    [JsonPropertyName("id")]
+    public string Id { get; set; }
+
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+
+    [JsonPropertyName("side")]
+    public string Side { get; set; }
+
+    [JsonPropertyName("types")]
+    public List<string> Types { get; set; }
+
+    [JsonPropertyName("resetTime")]
+    public long ResetTime { get; set; }
+
+    [JsonPropertyName("numQuests")]
+    public int NumQuests { get; set; }
+
+    [JsonPropertyName("minPlayerLevel")]
+    public int MinPlayerLevel { get; set; }
+
+    [JsonPropertyName("rewardScaling")]
+    public RewardScaling RewardScaling { get; set; }
+
+    [JsonPropertyName("locations")]
+    public Dictionary<ELocationName, List<string>> Locations { get; set; }
+
+    [JsonPropertyName("traderWhitelist")]
+    public List<TraderWhitelist> TraderWhitelist { get; set; }
+
+    [JsonPropertyName("questConfig")]
+    public RepeatableQuestTypesConfig QuestConfig { get; set; }
+
+    /** Item base types to block when generating rewards */
+    [JsonPropertyName("rewardBaseTypeBlacklist")]
+    public List<string> RewardBaseTypeBlacklist { get; set; }
+
+    /** Item tplIds to ignore when generating rewards */
+    [JsonPropertyName("rewardBlacklist")]
+    public List<string> RewardBlacklist { get; set; }
+
+    [JsonPropertyName("rewardAmmoStackMinSize")]
+    public int RewardAmmoStackMinSize { get; set; }
+
+    [JsonPropertyName("freeChangesAvailable")]
+    public int FreeChangesAvailable { get; set; }
+
+    [JsonPropertyName("freeChanges")]
+    public int FreeChanges { get; set; }
+
+    [JsonPropertyName("keepDailyQuestTypeOnReplacement")]
+    public bool KeepDailyQuestTypeOnReplacement { get; set; }
+}
+
+public class RewardScaling
+{
+    [JsonPropertyName("levels")]
+    public List<int> Levels { get; set; }
+
+    [JsonPropertyName("experience")]
+    public List<int> Experience { get; set; }
+
+    [JsonPropertyName("roubles")]
+    public List<int> Roubles { get; set; }
+
+    [JsonPropertyName("gpCoins")]
+    public List<int> GpCoins { get; set; }
+
+    [JsonPropertyName("items")]
+    public List<int> Items { get; set; }
+
+    [JsonPropertyName("reputation")]
+    public List<int> Reputation { get; set; }
+
+    [JsonPropertyName("rewardSpread")]
+    public int RewardSpread { get; set; }
+
+    [JsonPropertyName("skillRewardChance")]
+    public List<int> SkillRewardChance { get; set; }
+
+    [JsonPropertyName("skillPointReward")]
+    public List<int> SkillPointReward { get; set; }
+}
+
+public class TraderWhitelist
+{
+    [JsonPropertyName("traderId")]
+    public string TraderId { get; set; }
+
+    [JsonPropertyName("questTypes")]
+    public List<string> QuestTypes { get; set; }
+
+    [JsonPropertyName("rewardBaseWhitelist")]
+    public List<string> RewardBaseWhitelist { get; set; }
+
+    [JsonPropertyName("rewardCanBeWeapon")]
+    public bool RewardCanBeWeapon { get; set; }
+
+    [JsonPropertyName("weaponRewardChancePercent")]
+    public double WeaponRewardChancePercent { get; set; }
+}
+
+public class RepeatableQuestTypesConfig
+{
+    [JsonPropertyName("Exploration")]
+    public Exploration Exploration { get; set; }
+
+    [JsonPropertyName("Completion")]
+    public Completion Completion { get; set; }
+
+    [JsonPropertyName("Pickup")]
+    public Pickup Pickup { get; set; }
+
+    [JsonPropertyName("Elimination")]
+    public List<EliminationConfig> Elimination { get; set; }
+}
+
+public class Exploration : BaseQuestConfig
+{
+    [JsonPropertyName("maxExtracts")]
+    public int MaximumExtracts { get; set; }
+
+    [JsonPropertyName("maxExtractsWithSpecificExit")]
+    public int MaximumExtractsWithSpecificExit { get; set; }
+
+    [JsonPropertyName("specificExits")]
+    public SpecificExits SpecificExits { get; set; }
+}
+
+public class SpecificExits
+{
+    [JsonPropertyName("probability")]
+    public int Probability { get; set; }
+
+    [JsonPropertyName("passageRequirementWhitelist")]
+    public List<string> PassageRequirementWhitelist { get; set; }
+}
+
+public class Completion : BaseQuestConfig
+{
+    [JsonPropertyName("minRequestedAmount")]
+    public int MinimumRequestedAmount { get; set; }
+
+    [JsonPropertyName("maxRequestedAmount")]
+    public int MaximumRequestedAmount { get; set; }
+
+    [JsonPropertyName("uniqueItemCount")]
+    public int UniqueItemCount { get; set; }
+
+    [JsonPropertyName("minRequestedBulletAmount")]
+    public int MinimumRequestedBulletAmount { get; set; }
+
+    [JsonPropertyName("maxRequestedBulletAmount")]
+    public int MaximumRequestedBulletAmount { get; set; }
+
+    [JsonPropertyName("useWhitelist")]
+    public bool UseWhitelist { get; set; }
+
+    [JsonPropertyName("useBlacklist")]
+    public bool UseBlacklist { get; set; }
+}
+
+public class Pickup : BaseQuestConfig
+{
+    [JsonPropertyName("ItemTypeToFetchWithMaxCount")]
+    public List<PickupTypeWithMaxCount> ItemTypeToFetchWithMaxCount { get; set; }
+}
+
+public class PickupTypeWithMaxCount
+{
+    [JsonPropertyName("itemType")]
+    public string ItemType { get; set; }
+
+    [JsonPropertyName("maxPickupCount")]
+    public int MaximumPickupCount { get; set; }
+
+    [JsonPropertyName("minPickupCount")]
+    public int MinimumPickupCount { get; set; }
+}
+
+public class EliminationConfig : BaseQuestConfig
+{
+    [JsonPropertyName("levelRange")]
+    public MinMax LevelRange { get; set; }
+
+    [JsonPropertyName("targets")]
+    public List<Target> Targets { get; set; }
+
+    [JsonPropertyName("bodyPartProb")]
+    public double BodyPartProbability { get; set; }
+
+    [JsonPropertyName("bodyParts")]
+    public List<BodyPart> BodyParts { get; set; }
+
+    [JsonPropertyName("specificLocationProb")]
+    public double SpecificLocationProbability { get; set; }
+
+    [JsonPropertyName("distLocationBlacklist")]
+    public List<string> DistLocationBlacklist { get; set; }
+
+    [JsonPropertyName("distProb")]
+    public double DistanceProbability { get; set; }
+
+    [JsonPropertyName("maxDist")]
+    public double MaxDistance { get; set; }
+
+    [JsonPropertyName("minDist")]
+    public double MinDistance { get; set; }
+
+    [JsonPropertyName("maxKills")]
+    public int MaxKills { get; set; }
+
+    [JsonPropertyName("minKills")]
+    public int MinKills { get; set; }
+
+    [JsonPropertyName("minBossKills")]
+    public int MinBossKills { get; set; }
+
+    [JsonPropertyName("maxBossKills")]
+    public int MaxBossKills { get; set; }
+
+    [JsonPropertyName("minPmcKills")]
+    public int MinPmcKills { get; set; }
+
+    [JsonPropertyName("maxPmcKills")]
+    public int MaxPmcKills { get; set; }
+
+    [JsonPropertyName("weaponCategoryRequirementProb")]
+    public double WeaponCategoryRequirementProbability { get; set; }
+
+    [JsonPropertyName("weaponCategoryRequirements")]
+    public List<WeaponRequirement> WeaponCategoryRequirements { get; set; }
+
+    [JsonPropertyName("weaponRequirementProb")]
+    public double WeaponRequirementProbability { get; set; }
+
+    [JsonPropertyName("weaponRequirements")]
+    public List<WeaponRequirement> WeaponRequirements { get; set; }
+}
+
+public class BaseQuestConfig
+{
+    [JsonPropertyName("possibleSkillRewards")]
+    public List<string> PossibleSkillRewards { get; set; }
+}
+
+public class Target : ProbabilityObject
+{
+    [JsonPropertyName("data")]
+    public BossInfo Data { get; set; }
+}
+
+public class BossInfo
+{
+    [JsonPropertyName("isBoss")]
+    public bool IsBoss { get; set; }
+
+    [JsonPropertyName("isPmc")]
+    public bool IsPmc { get; set; }
+}
+
+public class BodyPart : ProbabilityObject
+{
+    [JsonPropertyName("data")]
+    public string[] Data { get; set; }
+}
+
+public class WeaponRequirement : ProbabilityObject
+{
+    [JsonPropertyName("data")]
+    public string[] Data { get; set; }
+}
+
+public class ProbabilityObject
+{
+    [JsonPropertyName("key")]
+    public string Key { get; set; }
+
+    [JsonPropertyName("relativeProbability")]
+    public double RelativeProbability { get; set; }
+
+    [JsonPropertyName("data")]
+    public object Data { get; set; }
+}

Core/Models/Spt/Config/RagfairConfig.cs

@@ -0,0 +1,393 @@
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+using System.Text.Json.Serialization;
+
+public class RagfairConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-ragfair";
+
+    /** How many seconds should pass before expired offers and processed + player offers checked if sold */
+    [JsonPropertyName("runIntervalSeconds")]
+    public int RunIntervalSeconds { get; set; }
+
+    /** Default values used to hydrate `runIntervalSeconds` with */
+    [JsonPropertyName("runIntervalValues")]
+    public RunIntervalValues RunIntervalValues { get; set; }
+
+    /** Player listing settings */
+    [JsonPropertyName("sell")]
+    public Sell Sell { get; set; }
+
+    /** Trader ids + should their assorts be listed on flea */
+    [JsonPropertyName("traders")]
+    public Dictionary<string, bool> Traders { get; set; }
+
+    [JsonPropertyName("dynamic")]
+    public Dynamic Dynamic { get; set; }
+
+    [JsonPropertyName("tieredFlea")]
+    public TieredFlea TieredFlea { get; set; }
+}
+
+public class Sell
+{
+    /** Should a fee be deducted from player when listing an item for sale */
+    [JsonPropertyName("fees")]
+    public bool Fees { get; set; }
+
+    /** Settings to control chances of offer being sold */
+    [JsonPropertyName("chance")]
+    public Chance Chance { get; set; }
+
+    /** Settings to control how long it takes for a player offer to sell */
+    [JsonPropertyName("time")]
+    public MinMax Time { get; set; }
+
+    /** Seconds from clicking remove to remove offer from market */
+    [JsonPropertyName("expireSeconds")]
+    public int ExpireSeconds { get; set; }
+}
+
+public class Chance
+{
+    /** Base chance percent to sell an item */
+    [JsonPropertyName("base")]
+    public int Base { get; set; }
+
+    /** Value to multiply the sell chance by */
+    [JsonPropertyName("sellMultiplier")]
+    public int SellMultiplier { get; set; }
+
+    /** Max possible sell chance % for a player listed offer */
+    [JsonPropertyName("maxSellChancePercent")]
+    public int MaxSellChancePercent { get; set; }
+
+    /** Min possible sell chance % for a player listed offer */
+    [JsonPropertyName("minSellChancePercent")]
+    public int MinSellChancePercent { get; set; }
+}
+
+public class Dynamic
+{
+    [JsonPropertyName("purchasesAreFoundInRaid")]
+    // Should a purchased dynamic offers items be flagged as found in raid
+    public bool PurchasesAreFoundInRaid { get; set; }
+
+    [JsonPropertyName("useTraderPriceForOffersIfHigher")]
+    /** Use the highest trader price for an offer if its greater than the price in templates/prices.json */
+    public bool UseTraderPriceForOffersIfHigher { get; set; }
+
+    [JsonPropertyName("barter")]
+    /** Barter offer specific settings */
+    public BarterDetails Barter { get; set; }
+
+    [JsonPropertyName("pack")]
+    public PackDetails Pack { get; set; }
+
+    [JsonPropertyName("offerAdjustment")]
+    /** Dynamic offer price below handbook adjustment values */
+    public OfferAdjustment OfferAdjustment { get; set; }
+
+    [JsonPropertyName("expiredOfferThreshold")]
+    /** How many offers should expire before an offer regeneration occurs */
+    public int ExpiredOfferThreshold { get; set; }
+
+    [JsonPropertyName("offerItemCount")]
+    /** How many offers should be listed */
+    public MinMax OfferItemCount { get; set; }
+
+    [JsonPropertyName("priceRanges")]
+    /** How much should the price of an offer vary by (percent 0.8 = 80%, 1.2 = 120%) */
+    public PriceRanges PriceRanges { get; set; }
+
+    [JsonPropertyName("showDefaultPresetsOnly")]
+    /** Should default presets to listed only or should non-standard presets found in globals.json be listed too */
+    public bool ShowDefaultPresetsOnly { get; set; }
+
+    [JsonPropertyName("ignoreQualityPriceVarianceBlacklist")]
+    /** Tpls that should not use the variable price system when their quality is < 100% (lower dura/uses = lower price) */
+    public List<string> IgnoreQualityPriceVarianceBlacklist { get; set; }
+
+    [JsonPropertyName("endTimeSeconds")]
+    public MinMax EndTimeSeconds { get; set; }
+
+    [JsonPropertyName("condition")]
+    /** Settings to control the durability range of item items listed on flea */
+    public Condition Condition { get; set; }
+
+    [JsonPropertyName("stackablePercent")]
+    /** Size stackable items should be listed for in percent of max stack size */
+    public MinMax StackablePercent { get; set; }
+
+    [JsonPropertyName("nonStackableCount")]
+    /** Items that cannot be stacked can have multiples sold in one offer, what range of values can be listed */
+    public MinMax NonStackableCount { get; set; }
+
+    [JsonPropertyName("rating")]
+    /** Range of rating offers for items being listed */
+    public MinMax Rating { get; set; }
+
+    [JsonPropertyName("armor")]
+    /** Armor specific flea settings */
+    public ArmorSettings Armor { get; set; }
+
+    [JsonPropertyName("itemPriceMultiplier")]
+    /** A multipler to apply to individual tpls price just prior to item quality adjustment */
+    public Dictionary<string, double> ItemPriceMultiplier { get; set; }
+
+    [JsonPropertyName("currencies")]
+    /** Percentages to sell offers in each currency */
+    public Dictionary<string, double> Currencies { get; set; }
+
+    [JsonPropertyName("showAsSingleStack")]
+    /** Item tpls that should be forced to sell as a single item */
+    public List<string> ShowAsSingleStack { get; set; }
+
+    [JsonPropertyName("removeSeasonalItemsWhenNotInEvent")]
+    /** Should christmas/halloween items be removed from flea when not within the seasonal bounds */
+    public bool RemoveSeasonalItemsWhenNotInEvent { get; set; }
+
+    [JsonPropertyName("blacklist")]
+    /** Flea blacklist settings */
+    public RagfairBlacklist Blacklist { get; set; }
+
+    [JsonPropertyName("unreasonableModPrices")]
+    /** Dict of price limits keyed by item type */
+    public Dictionary<string, UnreasonableModPrices> UnreasonableModPrices { get; set; }
+
+    [JsonPropertyName("itemPriceOverrideRouble")]
+    /** Custom rouble prices for items to override values from prices.json */
+    public Dictionary<string, double> ItemPriceOverrideRouble { get; set; }
+}
+
+public class PriceRanges
+{
+    [JsonPropertyName("default")]
+    public MinMax Default { get; set; }
+
+    [JsonPropertyName("preset")]
+    public MinMax Preset { get; set; }
+
+    [JsonPropertyName("pack")]
+    public MinMax Pack { get; set; }
+}
+
+public class BarterDetails
+{
+    /** Percentage change an offer is listed as a barter */
+    [JsonPropertyName("chancePercent")]
+    public double ChancePercent { get; set; }
+
+    /** Min number of required items for a barter requirement */
+    [JsonPropertyName("itemCountMin")]
+    public int ItemCountMin { get; set; }
+
+    /** Max number of required items for a barter requirement */
+    [JsonPropertyName("itemCountMax")]
+    public int ItemCountMax { get; set; }
+
+    /** How much can the total price of requested items vary from the item offered */
+    [JsonPropertyName("priceRangeVariancePercent")]
+    public double PriceRangeVariancePercent { get; set; }
+
+    /** Min rouble price for an offer to be considered for turning into a barter */
+    [JsonPropertyName("minRoubleCostToBecomeBarter")]
+    public double MinRoubleCostToBecomeBarter { get; set; }
+
+    /** Should barter offers only single stack */
+    [JsonPropertyName("makeSingleStackOnly")]
+    public bool MakeSingleStackOnly { get; set; }
+
+    /** Item Tpls to never be turned into a barter */
+    [JsonPropertyName("itemTypeBlacklist")]
+    public List<string> ItemTypeBlacklist { get; set; }
+}
+
+public class PackDetails
+{
+    /** Percentage change an offer is listed as a pack */
+    [JsonPropertyName("chancePercent")]
+    public double ChancePercent { get; set; }
+
+    /** Min number of required items for a pack */
+    [JsonPropertyName("itemCountMin")]
+    public int ItemCountMin { get; set; }
+
+    /** Max number of required items for a pack */
+    [JsonPropertyName("itemCountMax")]
+    public int ItemCountMax { get; set; }
+
+    /** item types to allow being a pack */
+    [JsonPropertyName("itemTypeWhitelist")]
+    public List<string> ItemTypeWhitelist { get; set; }
+}
+
+public class OfferAdjustment
+{
+    /// <summary>
+    /// Shuld offer price be adjusted when below handbook price
+    /// </summary>
+    [JsonPropertyName("adjustPriceWhenBelowHandbookPrice")]
+    public bool AdjustPriceWhenBelowHandbookPrice { get; set; }
+
+    /// <summary>
+    /// How big a percentage difference does price need to vary from handbook to be considered for adjustment
+    /// </summary>
+    [JsonPropertyName("maxPriceDifferenceBelowHandbookPercent")]
+    public double MaxPriceDifferenceBelowHandbookPercent { get; set; }
+
+    /// <summary>
+    /// How much to multiply the handbook price to get the new price
+    /// </summary>
+    [JsonPropertyName("handbookPriceMultipier")]
+    public double HandbookPriceMultiplier { get; set; }
+
+    /// <summary>
+    /// What is the minimum rouble price to consider adjusting price of item
+    /// </summary>
+    [JsonPropertyName("priceThreshholdRub")]
+    public double PriceThresholdRub { get; set; }
+}
+
+public class Condition
+{
+    /// <summary>
+    /// Percentage change durability is altered
+    /// </summary>
+    [JsonPropertyName("conditionChance")]
+    public double ConditionChance { get; set; }
+
+    [JsonPropertyName("current")]
+    public MinMax Current { get; set; }
+
+    [JsonPropertyName("max")]
+    public MinMax Max { get; set; }
+}
+
+public class RagfairBlacklist
+{
+    /// <summary>
+    /// Damaged ammo packs
+    /// </summary>
+    [JsonPropertyName("damagedAmmoPacks")]
+    public bool DamagedAmmoPacks { get; set; }
+
+    /// <summary>
+    /// Custom blacklist for item Tpls
+    /// </summary>
+    [JsonPropertyName("custom")]
+    public List<string> Custom { get; set; }
+
+    /// <summary>
+    /// BSG blacklist a large number of items from flea, true = use blacklist
+    /// </summary>
+    [JsonPropertyName("enableBsgList")]
+    public bool EnableBsgList { get; set; }
+
+    /// <summary>
+    /// Should quest items be blacklisted from flea
+    /// </summary>
+    [JsonPropertyName("enableQuestList")]
+    public bool EnableQuestList { get; set; }
+
+    /// <summary>
+    /// Should trader items that are blacklisted by bsg be listed on flea
+    /// </summary>
+    [JsonPropertyName("traderItems")]
+    public bool TraderItems { get; set; }
+
+    /// <summary>
+    /// Maximum level an armor plate can be found in a flea-listed armor item
+    /// </summary>
+    [JsonPropertyName("armorPlate")]
+    public ArmorPlateBlacklistSettings ArmorPlate { get; set; }
+
+    /// <summary>
+    /// Should specific categories be blacklisted from the flea, true = use blacklist
+    /// </summary>
+    [JsonPropertyName("enableCustomItemCategoryList")]
+    public bool EnableCustomItemCategoryList { get; set; }
+
+    /// <summary>
+    /// Custom category blacklist for parent Ids
+    /// </summary>
+    [JsonPropertyName("customItemCategoryList")]
+    public List<string> CustomItemCategoryList { get; set; }
+}
+
+public class ArmorPlateBlacklistSettings
+{
+    /// <summary>
+    /// Max level of plates an armor can have without being removed
+    /// </summary>
+    [JsonPropertyName("maxProtectionLevel")]
+    public int MaxProtectionLevel { get; set; }
+
+    /// <summary>
+    /// Item slots to NOT remove from items on flea
+    /// </summary>
+    [JsonPropertyName("ignoreSlots")]
+    public List<string> IgnoreSlots { get; set; }
+}
+
+public class UnreasonableModPrices
+{
+    /// <summary>
+    /// Enable a system that adjusts very high ragfair prices to be below a max multiple of items the handbook values
+    /// </summary>
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+
+    /// <summary>
+    /// Multipler to start adjusting item values from, e.g. a value of 10 means any value over 10x the handbook price gets adjusted
+    /// </summary>
+    [JsonPropertyName("handbookPriceOverMultiplier")]
+    public int HandbookPriceOverMultiplier { get; set; }
+
+    /// <summary>
+    /// The new multiplier for items found using above property, e.g. a value of 4 means set items price to 4x handbook price
+    /// </summary>
+    [JsonPropertyName("newPriceHandbookMultiplier")]
+    public int NewPriceHandbookMultiplier { get; set; }
+}
+
+public class ArmorSettings
+{
+    /// <summary>
+    /// % chance / 100 that armor plates will be removed from an offer before listing
+    /// </summary>
+    [JsonPropertyName("removeRemovablePlateChance")]
+    public int RemoveRemovablePlateChance { get; set; }
+
+    /// <summary>
+    /// What slots are to be removed when removeRemovablePlateChance is true
+    /// </summary>
+    [JsonPropertyName("plateSlotIdToRemovePool")]
+    public List<string> PlateSlotIdToRemovePool { get; set; }
+}
+
+public class TieredFlea
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+
+    /// <summary>
+    /// key: tpl, value: playerlevel
+    /// </summary>
+    [JsonPropertyName("unlocksTpl")]
+    public Dictionary<string, int> UnlocksTpl { get; set; }
+
+    /// <summary>
+    /// key: item type id, value: playerlevel
+    /// </summary>
+    [JsonPropertyName("unlocksType")]
+    public Dictionary<string, int> UnlocksType { get; set; }
+
+    public bool AmmoTiersEnabled { get; set; }
+
+    [JsonPropertyName("ammoTplUnlocks")]
+    public Dictionary<string, int> AmmoTplUnlocks { get; set; }
+}

Core/Models/Spt/Config/RepairConfig.cs

@@ -0,0 +1,110 @@
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+using System.Text.Json.Serialization;
+
+public class RepairConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-repair";
+
+    [JsonPropertyName("priceMultiplier")]
+    public double PriceMultiplier { get; set; }
+
+    [JsonPropertyName("applyRandomizeDurabilityLoss")]
+    public bool ApplyRandomizeDurabilityLoss { get; set; }
+
+    [JsonPropertyName("weaponSkillRepairGain")]
+    public double WeaponSkillRepairGain { get; set; }
+
+    [JsonPropertyName("armorKitSkillPointGainPerRepairPointMultiplier")]
+    public double ArmorKitSkillPointGainPerRepairPointMultiplier { get; set; }
+
+    /** INT gain multiplier per repaired item type */
+    [JsonPropertyName("repairKitIntellectGainMultiplier")]
+    public IntellectGainValues RepairKitIntellectGainMultiplier { get; set; }
+
+    // ** How much INT can be given to player per repair action */
+    [JsonPropertyName("maxIntellectGainPerRepair")]
+    public MaxIntellectGainValues MaxIntellectGainPerRepair { get; set; }
+
+    [JsonPropertyName("weaponTreatment")]
+    public WeaponTreatmentRepairValues WeaponTreatment { get; set; }
+
+    [JsonPropertyName("repairKit")]
+    public RepairKit RepairKit { get; set; }
+}
+
+public class IntellectGainValues
+{
+    [JsonPropertyName("weapon")]
+    public double Weapon { get; set; }
+
+    [JsonPropertyName("armor")]
+    public double Armor { get; set; }
+}
+
+public class MaxIntellectGainValues
+{
+    [JsonPropertyName("kit")]
+    public double Kit { get; set; }
+
+    [JsonPropertyName("trader")]
+    public double Trader { get; set; }
+}
+
+public class WeaponTreatmentRepairValues
+{
+    /** The chance to gain more weapon maintenance skill */
+    [JsonPropertyName("critSuccessChance")]
+    public double CritSuccessChance { get; set; }
+
+    [JsonPropertyName("critSuccessAmount")]
+    public double CritSuccessAmount { get; set; }
+
+    /** The chance to gain less weapon maintenance skill  */
+    [JsonPropertyName("critFailureChance")]
+    public double CritFailureChance { get; set; }
+
+    [JsonPropertyName("critFailureAmount")]
+    public double CritFailureAmount { get; set; }
+
+    /** The multiplier used for calculating weapon maintenance XP */
+    [JsonPropertyName("pointGainMultiplier")]
+    public double PointGainMultiplier { get; set; }
+}
+
+public class RepairKit
+{
+    [JsonPropertyName("armor")]
+    public BonusSettings Armor { get; set; }
+
+    [JsonPropertyName("weapon")]
+    public BonusSettings Weapon { get; set; }
+}
+
+public class BonusSettings
+{
+    [JsonPropertyName("rarityWeight")]
+    public Dictionary<string, double> RarityWeight { get; set; }
+
+    [JsonPropertyName("bonusTypeWeight")]
+    public Dictionary<string, double> BonusTypeWeight { get; set; }
+
+    [JsonPropertyName("common")]
+    public Dictionary<string, BonusValues> Common { get; set; }
+
+    [JsonPropertyName("rare")]
+    public Dictionary<string, BonusValues> Rare { get; set; }
+}
+
+public class BonusValues
+{
+    [JsonPropertyName("valuesMinMax")]
+    public MinMax ValuesMinMax { get; set; }
+
+    /** What dura is buff active between (min max of current max) */
+    [JsonPropertyName("activeDurabilityPercentMinMax")]
+    public MinMax ActiveDurabilityPercentMinMax { get; set; }
+}

Core/Models/Spt/Config/ScavCaseConfig.cs

@@ -0,0 +1,80 @@
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+using System.Text.Json.Serialization;
+
+public class ScavCaseConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-scavcase";
+
+    [JsonPropertyName("rewardItemValueRangeRub")]
+    public Dictionary<string, MinMax> RewardItemValueRangeRub { get; set; }
+
+    [JsonPropertyName("moneyRewards")]
+    public MoneyRewards MoneyRewards { get; set; }
+
+    [JsonPropertyName("ammoRewards")]
+    public AmmoRewards AmmoRewards { get; set; }
+
+    [JsonPropertyName("rewardItemParentBlacklist")]
+    public List<string> RewardItemParentBlacklist { get; set; }
+
+    [JsonPropertyName("rewardItemBlacklist")]
+    public List<string> RewardItemBlacklist { get; set; }
+
+    [JsonPropertyName("allowMultipleMoneyRewardsPerRarity")]
+    public bool AllowMultipleMoneyRewardsPerRarity { get; set; }
+
+    [JsonPropertyName("allowMultipleAmmoRewardsPerRarity")]
+    public bool AllowMultipleAmmoRewardsPerRarity { get; set; }
+
+    [JsonPropertyName("allowBossItemsAsRewards")]
+    public bool AllowBossItemsAsRewards { get; set; }
+}
+
+public class MoneyRewards
+{
+    [JsonPropertyName("moneyRewardChancePercent")]
+    public int MoneyRewardChancePercent { get; set; }
+
+    [JsonPropertyName("rubCount")]
+    public MoneyLevels RubCount { get; set; }
+
+    [JsonPropertyName("usdCount")]
+    public MoneyLevels UsdCount { get; set; }
+
+    [JsonPropertyName("eurCount")]
+    public MoneyLevels EurCount { get; set; }
+
+    [JsonPropertyName("gpCount")]
+    public MoneyLevels GpCount { get; set; }
+}
+
+public class MoneyLevels
+{
+    [JsonPropertyName("common")]
+    public MinMax Common { get; set; }
+
+    [JsonPropertyName("rare")]
+    public MinMax Rare { get; set; }
+
+    [JsonPropertyName("superrare")]
+    public MinMax SuperRare { get; set; }
+}
+
+public class AmmoRewards
+{
+    [JsonPropertyName("ammoRewardChancePercent")]
+    public int AmmoRewardChancePercent { get; set; }
+
+    [JsonPropertyName("ammoRewardBlacklist")]
+    public Dictionary<string, List<string>> AmmoRewardBlacklist { get; set; }
+
+    [JsonPropertyName("ammoRewardValueRangeRub")]
+    public Dictionary<string, MinMax> AmmoRewardValueRangeRub { get; set; }
+
+    [JsonPropertyName("minStackSize")]
+    public int MinStackSize { get; set; }
+}

Core/Models/Spt/Config/SeasonalEventConfig.cs

@@ -0,0 +1,104 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class SeasonalEventConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-seasonalevents";
+    
+    [JsonPropertyName("enableSeasonalEventDetection")]
+    public bool EnableSeasonalEventDetection { get; set; }
+    
+    /** event / botType / equipSlot / itemid */
+    [JsonPropertyName("eventGear")]
+    public Dictionary<string, Dictionary<string, Dictionary<string, Dictionary<string, int>>>> EventGear { get; set; }
+    
+    /** event / bot type / equipSlot / itemid */
+    [JsonPropertyName("eventLoot")]
+    public Dictionary<string, Dictionary<string, Dictionary<string, Dictionary<string, int>>>> EventLoot { get; set; }
+    
+    public List<SeasonalEvent> Events { get; set; }
+    
+    [JsonPropertyName("eventBotMapping")]
+    public Dictionary<string, string> EventBotMapping { get; set; }
+    
+    [JsonPropertyName("eventBossSpawns")]
+    public Dictionary<string, Dictionary<string, List<BossLocationSpawn>>> EventBossSpawns { get; set; }
+    
+    [JsonPropertyName("eventWaves")]
+    public Dictionary<string, Dictionary<string, List<Wave>>> EventWaves { get; set; }
+    
+    [JsonPropertyName("gifterSettings")]
+    public List<GifterSetting> GifterSettings { get; set; }
+    
+    /** key = event, second key = map name */
+    [JsonPropertyName("hostilitySettingsForEvent")]
+    public Dictionary<string, Dictionary<string, List<AdditionalHostilitySettings>>> HostilitySettingsForEvent { get; set; }
+    
+    /** Ids of containers on locations that only have christmas loot */
+    [JsonPropertyName("christmasContainerIds")]
+    public List<string> ChristmasContainerIds { get; set; }
+    
+    /** Season - botType - location (body/feet/hands/head) */
+    [JsonPropertyName("botAppearanceChanges")]
+    public Dictionary<SeasonalEventType, Dictionary<string, Dictionary<string, Dictionary<string, int>>>> BotAppearanceChanges { get; set; }
+}
+
+public class SeasonalEvent
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+    
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+    
+    [JsonPropertyName("type")]
+    public SeasonalEventType Type { get; set; }
+    
+    [JsonPropertyName("startDay")]
+    public int StartDay { get; set; }
+    
+    [JsonPropertyName("startMonth")]
+    public int StartMonth { get; set; }
+    
+    [JsonPropertyName("endDay")]
+    public int EndDay { get; set; }
+    
+    [JsonPropertyName("endMonth")]
+    public int EndMonth { get; set; }
+    
+    [JsonPropertyName("settings")]
+    public Dictionary<string, object> Settings { get; set; } // TODO: Type was Record<string, ISeasonalEventSettings | IZombieSettings>
+}
+
+public class SeasonalEventSettings
+{
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+}
+
+public class ZombieSettings : SeasonalEventSettings
+{
+    [JsonPropertyName("mapInfectionAmount")]
+    public Dictionary<string, int> MapInfectionAmount { get; set; }
+    
+    [JsonPropertyName("disableBosses")]
+    public List<string> DisableBosses { get; set; }
+    
+    [JsonPropertyName("disableWaves")]
+    public List<string> DisableWaves { get; set; }
+}
+
+public class GifterSetting
+{
+    [JsonPropertyName("map")]
+    public string Map { get; set; }
+    
+    [JsonPropertyName("zones")]
+    public string Zones { get; set; }
+    
+    [JsonPropertyName("spawnChance")]
+    public int SpawnChance { get; set; }
+}

Core/Models/Spt/Config/TraderConfig.cs

@@ -0,0 +1,173 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class TraderConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-trader";
+    
+    [JsonPropertyName("updateTime")]
+    public List<UpdateTime> UpdateTime { get; set; }
+    
+    [JsonPropertyName("updateTimeDefault")]
+    public int UpdateTimeDefault { get; set; }
+    
+    [JsonPropertyName("purchasesAreFoundInRaid")]
+    public bool PurchasesAreFoundInRaid { get; set; }
+    
+    /** Should trader reset times be set based on server start time (false = bsg time - on the hour) */
+    [JsonPropertyName("tradersResetFromServerStart")]
+    public bool TradersResetFromServerStart { get; set; }
+    
+    [JsonPropertyName("traderPriceMultipler")]
+    public double TraderPriceMultipler { get; set; }
+    
+    [JsonPropertyName("fence")]
+    public FenceConfig Fence { get; set; }
+    
+    [JsonPropertyName("moddedTraders")]
+    public ModdedTraders ModdedTraders { get; set; }
+}
+
+public class UpdateTime
+{
+    [JsonPropertyName("traderId")]
+    public string TraderId { get; set; }
+    
+    /** Seconds between trader resets */
+    [JsonPropertyName("seconds")]
+    public MinMax Seconds { get; set; }
+}
+
+public class FenceConfig
+{
+    [JsonPropertyName("discountOptions")]
+    public DiscountOptions DiscountOptions { get; set; }
+    
+    [JsonPropertyName("partialRefreshTimeSeconds")]
+    public int PartialRefreshTimeSeconds { get; set; }
+    
+    [JsonPropertyName("partialRefreshChangePercent")]
+    public double PartialRefreshChangePercent { get; set; }
+    
+    [JsonPropertyName("assortSize")]
+    public int AssortSize { get; set; }
+    
+    [JsonPropertyName("weaponPresetMinMax")]
+    public MinMax WeaponPresetMinMax { get; set; }
+    
+    [JsonPropertyName("equipmentPresetMinMax")]
+    public MinMax EquipmentPresetMinMax { get; set; }
+    
+    [JsonPropertyName("itemPriceMult")]
+    public double ItemPriceMult { get; set; }
+    
+    [JsonPropertyName("presetPriceMult")]
+    public double PresetPriceMult { get; set; }
+    
+    [JsonPropertyName("armorMaxDurabilityPercentMinMax")]
+    public ItemDurabilityCurrentMax ArmorMaxDurabilityPercentMinMax { get; set; }
+    
+    [JsonPropertyName("weaponDurabilityPercentMinMax")]
+    public ItemDurabilityCurrentMax WeaponDurabilityPercentMinMax { get; set; }
+    
+    /** Keyed to plate protection level */
+    [JsonPropertyName("chancePlateExistsInArmorPercent")]
+    public Dictionary<string, double> ChancePlateExistsInArmorPercent { get; set; }
+    
+    /** Key: item tpl */
+    [JsonPropertyName("itemStackSizeOverrideMinMax")]
+    public Dictionary<string, MinMax> ItemStackSizeOverrideMinMax { get; set; }
+    
+    [JsonPropertyName("itemTypeLimits")]
+    public Dictionary<string, int> ItemTypeLimits { get; set; }
+    
+    /** Prevent duplicate offers of items of specific categories by parentId */
+    [JsonPropertyName("preventDuplicateOffersOfCategory")]
+    public List<string> PreventDuplicateOffersOfCategory { get; set; }
+    
+    [JsonPropertyName("regenerateAssortsOnRefresh")]
+    public bool RegenerateAssortsOnRefresh { get; set; }
+    
+    /** Max rouble price before item is not listed on flea */
+    [JsonPropertyName("itemCategoryRoublePriceLimit")]
+    public Dictionary<string, double> ItemCategoryRoublePriceLimit { get; set; }
+    
+    /** Each slotid with % to be removed prior to listing on fence */
+    [JsonPropertyName("presetSlotsToRemoveChancePercent")]
+    public Dictionary<string, double> PresetSlotsToRemoveChancePercent { get; set; }
+    
+    /** Block seasonal items from appearing when season is inactive */
+    [JsonPropertyName("blacklistSeasonalItems")]
+    public bool BlacklistSeasonalItems { get; set; }
+    
+    /** Max pen value allowed to be listed on flea - affects ammo + ammo boxes */
+    [JsonPropertyName("ammoMaxPenLimit")]
+    public double AmmoMaxPenLimit { get; set; }
+    
+    [JsonPropertyName("blacklist")]
+    public List<string> Blacklist { get; set; }
+    
+    [JsonPropertyName("coopExtractGift")]
+    public CoopExtractReward CoopExtractGift { get; set; }
+    
+    [JsonPropertyName("btrDeliveryExpireHours")]
+    public int BtrDeliveryExpireHours { get; set; }
+    
+    /** Smallest value player rep with fence can fall to */
+    [JsonPropertyName("playerRepMin")]
+    public double PlayerRepMin { get; set; }
+    
+    /** Highest value player rep with fence can climb to */
+    [JsonPropertyName("playerRepMax")]
+    public double PlayerRepMax { get; set; }
+}
+
+public class ItemDurabilityCurrentMax
+{
+    [JsonPropertyName("current")]
+    public MinMax Current { get; set; }
+    
+    [JsonPropertyName("max")]
+    public MinMax Max { get; set; }
+}
+
+public class CoopExtractReward : LootRequest
+{
+    [JsonPropertyName("sendGift")]
+    public bool SendGift { get; set; }
+    
+    [JsonPropertyName("messageLocaleIds")]
+    public List<string> MessageLocaleIds { get; set; }
+    
+    [JsonPropertyName("giftExpiryHours")]
+    public int GiftExpiryHours { get; set; }
+}
+
+public class DiscountOptions
+{
+    [JsonPropertyName("assortSize")]
+    public int AssortSize { get; set; }
+    
+    [JsonPropertyName("itemPriceMult")]
+    public double ItemPriceMult { get; set; }
+    
+    [JsonPropertyName("presetPriceMult")]
+    public double PresetPriceMult { get; set; }
+    
+    [JsonPropertyName("weaponPresetMinMax")]
+    public MinMax WeaponPresetMinMax { get; set; }
+    
+    [JsonPropertyName("equipmentPresetMinMax")]
+    public MinMax EquipmentPresetMinMax { get; set; }
+}
+
+/** Custom trader data needed client side for things such as the clothing service */
+public class ModdedTraders
+{
+    /** Trader Ids to enable the clothing service for */
+    [JsonPropertyName("clothingService")]
+    public List<string> ClothingService { get; set; }
+}

Core/Models/Spt/Config/WeatherConfig.cs

@@ -0,0 +1,105 @@
+using System.Text.Json.Serialization;
+using Core.Models.Common;
+
+namespace Core.Models.Spt.Config;
+
+public class WeatherConfig : BaseConfig
+{
+    [JsonPropertyName("kind")]
+    public string Kind { get; set; } = "spt-weather";
+
+    [JsonPropertyName("acceleration")]
+    public double Acceleration { get; set; }
+
+    [JsonPropertyName("weather")]
+    public WeatherValues Weather { get; set; }
+
+    [JsonPropertyName("seasonDates")]
+    public List<SeasonDateTimes> SeasonDates { get; set; }
+
+    [JsonPropertyName("overrideSeason")]
+    public Season? OverrideSeason { get; set; }
+}
+
+public class SeasonDateTimes
+{
+    [JsonPropertyName("seasonType")]
+    public Season SeasonType { get; set; }
+
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+
+    [JsonPropertyName("startDay")]
+    public int StartDay { get; set; }
+
+    [JsonPropertyName("startMonth")]
+    public int StartMonth { get; set; }
+
+    [JsonPropertyName("endDay")]
+    public int EndDay { get; set; }
+
+    [JsonPropertyName("endMonth")]
+    public int EndMonth { get; set; }
+}
+
+public class WeatherValues
+{
+    [JsonPropertyName("seasonValues")]
+    public Dictionary<string, SeasonalValues> SeasonValues { get; set; }
+
+    /** How many hours to generate weather data into the future */
+    [JsonPropertyName("generateWeatherAmountHours")]
+    public int GenerateWeatherAmountHours { get; set; }
+
+    /** Length of each weather period */
+    [JsonPropertyName("timePeriod")]
+    public WeatherSettings<int> TimePeriod { get; set; }
+}
+
+public class SeasonalValues
+{
+    [JsonPropertyName("clouds")]
+    public WeatherSettings<string> Clouds { get; set; }
+
+    [JsonPropertyName("windSpeed")]
+    public WeatherSettings<double> WindSpeed { get; set; }
+
+    [JsonPropertyName("windDirection")]
+    public WeatherSettings<WindDirection> WindDirection { get; set; }
+
+    [JsonPropertyName("windGustiness")]
+    public MinMax WindGustiness { get; set; }
+
+    [JsonPropertyName("rain")]
+    public WeatherSettings<double> Rain { get; set; }
+
+    [JsonPropertyName("rainIntensity")]
+    public MinMax RainIntensity { get; set; }
+
+    [JsonPropertyName("fog")]
+    public WeatherSettings<string> Fog { get; set; }
+
+    [JsonPropertyName("temp")]
+    public TempDayNight Temp { get; set; }
+
+    [JsonPropertyName("pressure")]
+    public MinMax Pressure { get; set; }
+}
+
+public class TempDayNight
+{
+    [JsonPropertyName("day")]
+    public MinMax Day { get; set; }
+
+    [JsonPropertyName("night")]
+    public MinMax Night { get; set; }
+}
+
+public class WeatherSettings<T>
+{
+    [JsonPropertyName("values")]
+    public List<T> Values { get; set; }
+
+    [JsonPropertyName("weights")]
+    public List<double> Weights { get; set; }
+}

Core/Models/Spt/Controllers/BotController.cs

@@ -0,0 +1,41 @@
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Controllers;
+
+public class BotController
+{
+    public int GetBotLimit(string type)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object GetBotDifficulty(string type, string difficulty) // TODO: return type was: IBotCore | IDifficultyCategories
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsBotPmc(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsBotBoss(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsBotFollower(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    public List<BotBase> Generate(GenerateBotsRequestData info, bool playerscav)
+    {
+        throw new NotImplementedException();
+    }
+
+    public int GetBotCap()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Dialog/SendMessageDetails.cs

@@ -0,0 +1,106 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Dialog;
+
+public class SendMessageDetails
+{
+    /// <summary>
+    /// Player id
+    /// </summary>
+    [JsonPropertyName("recipientId")]
+    public string RecipientId { get; set; }
+
+    /// <summary>
+    /// Who is sending this message
+    /// </summary>
+    [JsonPropertyName("sender")]
+    public MessageType Sender { get; set; }
+
+    /// <summary>
+    /// Optional - leave blank to use sender value
+    /// </summary>
+    [JsonPropertyName("dialogType")]
+    public MessageType? DialogType { get; set; }
+
+    /// <summary>
+    /// Optional - if sender is USER these details are used
+    /// </summary>
+    [JsonPropertyName("senderDetails")]
+    public IUserDialogInfo? SenderDetails { get; set; }
+
+    /// <summary>
+    /// Optional - the trader sending the message
+    /// </summary>
+    [JsonPropertyName("trader")]
+    public Traders? Trader { get; set; }
+
+    /// <summary>
+    /// Optional - used in player/system messages, otherwise templateId is used
+    /// </summary>
+    [JsonPropertyName("messageText")]
+    public string? MessageText { get; set; }
+
+    /// <summary>
+    /// Optional - Items to send to player
+    /// </summary>
+    [JsonPropertyName("items")]
+    public List<Item>? Items { get; set; }
+
+    /// <summary>
+    /// Optional - How long items will be stored in mail before expiry
+    /// </summary>
+    [JsonPropertyName("itemsMaxStorageLifetimeSeconds")]
+    public int? ItemsMaxStorageLifetimeSeconds { get; set; }
+
+    /// <summary>
+    /// Optional - Used when sending messages from traders who send text from locale json
+    /// </summary>
+    [JsonPropertyName("templateId")]
+    public string? TemplateId { get; set; }
+
+    /// <summary>
+    /// Optional - ragfair related
+    /// </summary>
+    [JsonPropertyName("systemData")]
+    public SystemData? SystemData { get; set; }
+
+    /// <summary>
+    /// Optional - Used by ragfair messages
+    /// </summary>
+    [JsonPropertyName("ragfairDetails")]
+    public MessageContentRagfair? RagfairDetails { get; set; }
+
+    /// <summary>
+    /// OPTIONAL - allows modification of profile settings via mail
+    /// </summary>
+    [JsonPropertyName("profileChangeEvents")]
+    public List<ProfileChangeEvent>? ProfileChangeEvents { get; set; }
+}
+
+public class ProfileChangeEvent
+{
+    [JsonPropertyName("_id")]
+    public string Id { get; set; }
+
+    [JsonPropertyName("Type")]
+    public ProfileChangeEventType Type { get; set; }
+
+    [JsonPropertyName("value")]
+    public int Value { get; set; }
+
+    [JsonPropertyName("entity")]
+    public string? Entity { get; set; }
+}
+
+public enum ProfileChangeEventType
+{
+    TraderSalesSum,
+    TraderStanding,
+    ProfileLevel,
+    SkillPoints,
+    ExamineAllItems,
+    UnlockTrader,
+    AssortmentUnlockRule,
+    HideoutAreaLevel
+}

Core/Models/Spt/Fence/CreateFenceAssortsResult.cs

@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Fence;
+
+public class CreateFenceAssortsResult
+{
+    [JsonPropertyName("sptItems")]
+    public List<List<Item>> SptItems { get; set; }
+
+    [JsonPropertyName("barter_scheme")]
+    public Dictionary<string, List<List<BarterScheme>>> BarterScheme { get; set; }
+
+    [JsonPropertyName("loyal_level_items")]
+    public Dictionary<string, int> LoyalLevelItems { get; set; }
+}

Core/Models/Spt/Fence/FenceAssortGenerationValues.cs

@@ -0,0 +1,24 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Fence;
+
+public class FenceAssortGenerationValues
+{
+    [JsonPropertyName("normal")]
+    public GenerationAssortValues Normal { get; set; }
+
+    [JsonPropertyName("discount")]
+    public GenerationAssortValues Discount { get; set; }
+}
+
+public class GenerationAssortValues
+{
+    [JsonPropertyName("item")]
+    public int Item { get; set; }
+
+    [JsonPropertyName("weaponPreset")]
+    public int WeaponPreset { get; set; }
+
+    [JsonPropertyName("equipmentPreset")]
+    public int EquipmentPreset { get; set; }
+}

Core/Models/Spt/Generators/BotGenerator.cs

@@ -0,0 +1,11 @@
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Generators;
+
+public class BotGenerator
+{
+    public PmcInventory GenerateInventory(Inventory templateInventory, Chances equipmentChances, Generation generation, string botRole, bool isPmc)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/LocationGenerator.cs

@@ -0,0 +1,18 @@
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Generators;
+
+public class LocationGenerator
+{
+    public StaticContainerProps GenerateContainerLoot(StaticContainerProps containerIn, List<StaticForcedProps> staticForced,
+        Dictionary<string, StaticLootDetails> staticLootDist, Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist, string locationName)
+    {
+        throw new NotImplementedException();
+    }
+
+    public List<SpawnpointTemplate> GenerateDynamicLoot(LooseLoot dynamicLootDist, Dictionary<string, List<StaticAmmoDetails>> staticAmmoDist,
+        string locationName)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/PMCLootGenerator.cs

@@ -0,0 +1,14 @@
+namespace Core.Models.Spt.Generators;
+
+public class PMCLootGenerator
+{
+    public List<string> GeneratePMCPocketLootPool()
+    {
+        throw new NotImplementedException();
+    }
+
+    public List<string> GeneratePMCBackpackLootPool()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/RagfairAssortGenerator.cs

@@ -0,0 +1,11 @@
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Generators;
+
+public class RagfairAssortGenerator
+{
+    public List<Item> GetAssortItems()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/RagfairOfferGenerator.cs

@@ -0,0 +1,13 @@
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Ragfair;
+
+namespace Core.Models.Spt.Generators;
+
+public class RagfairOfferGenerator
+{
+    public RagfairOffer CreateOffer(string userID, float time, List<Item> items, List<BarterScheme> barterScheme, int loyalLevel, int price,
+        bool sellInOnePiece)
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Hideout/CircleCraftDetails.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+using Core.Models.Spt.Config;
+
+namespace Core.Models.Spt.Hideout;
+
+public class CircleCraftDetails
+{
+    [JsonPropertyName("time")]
+    public int Time { get; set; } // this might not be the right "number" type
+    
+    [JsonPropertyName("rewardType")]
+    public CircleRewardType RewardType { get; set; }
+    
+    [JsonPropertyName("rewardAmountRoubles")]
+    public int RewardAmountRoubles { get; set; }
+    
+    [JsonPropertyName("rewardDetails")]
+    public CraftTimeThreshhold? RewardDetails { get; set; }
+}

Core/Models/Spt/Hideout/Hideout.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+using Core.Models.Spt.Repeatable;
+
+namespace Core.Models.Spt.Hideout;
+
+public class Hideout
+{
+    [JsonPropertyName("areas")]
+    public List<HideoutArea> Areas { get; set; }
+    
+    [JsonPropertyName("customisation")]
+    public HideoutCustomisation Customisation { get; set; }
+    
+    [JsonPropertyName("production")]
+    public HideoutProductionData Production { get; set; }
+    
+    [JsonPropertyName("settings")]
+    public HideoutSettingsBase Settings { get; set; }
+    
+    [JsonPropertyName("qte")]
+    public List<qteData> Qte { get; set; }
+}

Core/Models/Spt/Hideout/ScavCaseRewardCountsAndPrice.cs

@@ -0,0 +1,30 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Hideout;
+
+public class ScavCaseRewardCountsAndPrice
+{
+    [JsonPropertyName("Common")]
+    public RewardCountAndPriceDetails Common { get; set; }
+    
+    [JsonPropertyName("Rare")]
+    public RewardCountAndPriceDetails Rare { get; set; }
+    
+    [JsonPropertyName("Superrare")]
+    public RewardCountAndPriceDetails Superrare { get; set; }
+}
+
+public class RewardCountAndPriceDetails
+{
+    [JsonPropertyName("minCount")]
+    public int MinCount { get; set; }
+    
+    [JsonPropertyName("maxCount")]
+    public int MaxCount { get; set; }
+    
+    [JsonPropertyName("minPriceRub")]
+    public int MinPriceRub { get; set; }
+    
+    [JsonPropertyName("maxPriceRub")]
+    public int MaxPriceRub { get; set; }
+}

Core/Models/Spt/Inventory/OwnerInventoryItems.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Spt.Inventory;
+
+public class OwnerInventoryItems
+{
+    [JsonPropertyName("from")]
+    public List<Item> From { get; set; }
+    
+    [JsonPropertyName("to")]
+    public List<Item> To { get; set; }
+    
+    [JsonPropertyName("sameInventory")]
+    public bool SameInventory { get; set; }
+    
+    [JsonPropertyName("isMail")]
+    public bool IsMail { get; set; }
+}

Core/Models/Spt/Location/RaidChanges.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Location;
+
+public class RaidChanges
+{
+    [JsonPropertyName("dynamicLootPercent")]
+    public float DynamicLootPercent { get; set; }
+    
+    [JsonPropertyName("staticLootPercent")]
+    public float StaticLootPercent { get; set; }
+    
+    [JsonPropertyName("simulatedRaidStartSeconds")]
+    public int SimulatedRaidStartSeconds { get; set; }
+}

Core/Models/Spt/Logging/ClientLogRequest.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Logging;
+
+public class ClientLogRequest
+{
+    [JsonPropertyName("Source")]
+    public string Source { get; set; }
+    
+    [JsonPropertyName("Level")]
+    public LogLevel Level { get; set; }
+    
+    [JsonPropertyName("Message")]
+    public string Message { get; set; }
+    
+    [JsonPropertyName("Color")]
+    public string? Color { get; set; }
+    
+    [JsonPropertyName("BackgroundColor")]
+    public string? BackgroundColor { get; set; }
+}

Core/Models/Spt/Logging/LogBackgroundColor.cs

@@ -0,0 +1,16 @@
+// namespace Core.Models.Spt.Logging;
+//
+// public struct LogBackgroundColor
+// {
+//     public const string DEFAULT = "";
+//     public const string BLACK = "blackBG";
+//     public const string RED = "redBG";
+//     public const string GREEN = "greenBG";
+//     public const string YELLOW = "yellowBG";
+//     public const string BLUE = "blueBG";
+//     public const string MAGENTA = "magentaBG";
+//     public const string CYAN = "cyanBG";
+//     public const string WHITE = "whiteBG";
+// }
+
+// TODO: this likely wont be used anymore, so commenting out insteaad of reimplementing

Core/Models/Spt/Logging/LogLevel.cs

@@ -0,0 +1,13 @@
+namespace Core.Models.Spt.Logging;
+
+public enum LogLevel
+{
+    ERROR = 0,
+    WARN = 1,
+    SUCCESS = 2,
+    INFO = 3,
+    CUSTOM = 4,
+    DEBUG = 5
+}
+
+// TODO: needs to be moved to enums namespace

Core/Models/Spt/Logging/LogTextColor.cs

@@ -0,0 +1,16 @@
+// namespace Core.Models.Spt.Logging;
+//
+// public struct LogTextColor
+// {
+//     public const string BLACK = "black";
+//     public const string RED = "red";
+//     public const string GREEN = "green";
+//     public const string YELLOW = "yellow";
+//     public const string BLUE = "blue";
+//     public const string MAGENTA = "Magenta";
+//     public const string CYAN = "cyan";
+//     public const string WHITE = "white";
+//     public const string GRAY = "gray";
+// }
+
+// TODO: this likely wont be used anymore, so commenting out insteaad of reimplementing

Core/Models/Spt/Logging/SptLogger.cs

@@ -0,0 +1,12 @@
+namespace Core.Models.Spt.Logging;
+
+public class SptLogger
+{
+    public object Error  { get; set; } // error: (msg: string | Record<string, unknown>) => void;
+    public object Warn  { get; set; } // warn: (msg: string | Record<string, unknown>) => void;
+    public object Succ  { get; set; } // succ?: (msg: string | Record<string, unknown>) => void;
+    public object Info  { get; set; } // info: (msg: string | Record<string, unknown>) => void;
+    public object Debug  { get; set; } // debug: (msg: string | Record<string, unknown>) => void;
+}
+
+// TODO: needs to be reimplemented however we want to do it in this project

Core/Models/Spt/Mod/ModLoader.cs

@@ -0,0 +1,16 @@
+namespace Core.Models.Spt.Mod;
+
+public class ModLoader
+{
+    public void Load(DependencyContainer container)
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetModPath(string mod)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+// TODO: This needs to be reworked with however we do it for this project

Core/Models/Spt/Mod/NewItemDetails.cs

@@ -0,0 +1,72 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common;
+
+namespace Core.Models.Spt.Mod;
+
+public class NewItemDetails : NewItemDetailsBase
+{
+    [JsonPropertyName("newItem")]
+    public TemplateItem NewItem { get; set; }
+}
+
+public class NewItemFromCloneDetails : NewItemDetailsBase
+{
+    [JsonPropertyName("itemTplToClone")]
+    public string ItemTplToClone { get; set; }
+    
+    [JsonPropertyName("overrideProperties")]
+    public Props OverrideProperties { get; set; }
+    
+    [JsonPropertyName("parentId")]
+    public string ParentId { get; set; }
+
+    [JsonPropertyName("newId")] 
+    public string NewId { get; set; } = "";
+}
+
+public class NewItemDetailsBase
+{
+    [JsonPropertyName("fleaPriceRoubles")]
+    public float FleaPriceRoubles { get; set; }
+    
+    [JsonPropertyName("handbookPriceRoubles")]
+    public float HandbookPriceRoubles { get; set; }
+    
+    [JsonPropertyName("handbookParentId")]
+    public string HandbookParentId { get; set; }
+    
+    [JsonPropertyName("locales")]
+    public Dictionary<string, LocaleDetails> Locales { get; set; }
+}
+
+public class LocaleDetails
+{
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+    
+    [JsonPropertyName("shortName")]
+    public string ShortName { get; set; }
+    
+    [JsonPropertyName("description")]
+    public string Description { get; set; }
+}
+
+public class CreateItemResult
+{
+    [JsonPropertyName("success")] 
+    public bool Success { get; set; }
+    
+    [JsonPropertyName("itemId")]
+    public string ItemId { get; set; }
+    
+    [JsonPropertyName("errors")]
+    public List<string> Errors { get; set; }
+
+    public CreateItemResult()
+    {
+        Success = false;
+        Errors = new List<string>();
+    }
+}
+
+// TODO: This needs to be reworked with however we do it for this project

Core/Models/Spt/Mod/PackageJsonData.cs

@@ -0,0 +1,57 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Spt.Mod;
+
+public class PackageJsonData
+{
+    [JsonPropertyName("incompatibilities")]
+    public List<string>? Incompatibilities { get; set; }
+    
+    [JsonPropertyName("loadBefore")]
+    public List<string>? LoadBefore { get; set; }
+    
+    [JsonPropertyName("loadAfter")]
+    public List<string>? LoadAfter { get; set; }
+    
+    [JsonPropertyName("dependencies")]
+    public Dictionary<string, string>? Dependencies { get; set; }
+    
+    [JsonPropertyName("modDependencies")]
+    public Dictionary<string, string>? ModDependencies { get; set; }
+    
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+    
+    [JsonPropertyName("url")]
+    public string Url { get; set; }
+    
+    [JsonPropertyName("author")]
+    public string Author { get; set; }
+    
+    [JsonPropertyName("version")]
+    public string Version { get; set; }
+    
+    [JsonPropertyName("sptVersion")]
+    public string SptVersion { get; set; }
+    
+    // We deliberately purge this data
+    [JsonPropertyName("scripts")]
+    public Dictionary<string, string> Scripts { get; set; }
+    
+    [JsonPropertyName("devDependencies")]
+    public Dictionary<string, string>? DevDependencies { get; set; }
+    
+    [JsonPropertyName("licence")]
+    public string Licence { get; set; }
+    
+    [JsonPropertyName("main")]
+    public string Main { get; set; }
+    
+    [JsonPropertyName("isBundleMod")]
+    public bool IsBundleMod { get; set; }
+    
+    [JsonPropertyName("contributors")]
+    public List<string> Contributors { get; set; }
+}
+
+// TODO: this will need changing to however we implement it in this project

Core/Models/Spt/Repeatable/QuestTypePool.cs

@@ -28,7 +28,7 @@ public class QuestPool
 public class ExplorationPool
 {
     [JsonPropertyName("locations")]
-    public Dictionary<ELocationName, List<string>> Locations { get; set; }
+    public Dictionary<ELocationName, List<string>> Locations { get; set; } // TODO: check the type, originally - Partial<Record<ELocationName, string[]>>
 }
 
 public class EliminationPool
@@ -40,37 +40,37 @@ public class EliminationPool
 public class EliminationTargetPool
 {
     [JsonPropertyName("Savage")]
-    public TargetLocation Savage { get; set; }
+    public TargetLocation? Savage { get; set; }
 
     [JsonPropertyName("AnyPmc")]
-    public TargetLocation AnyPmc { get; set; }
+    public TargetLocation? AnyPmc { get; set; }
 
     [JsonPropertyName("bossBully")]
-    public TargetLocation BossBully { get; set; }
+    public TargetLocation? BossBully { get; set; }
 
     [JsonPropertyName("bossGluhar")]
-    public TargetLocation BossGluhar { get; set; }
+    public TargetLocation? BossGluhar { get; set; }
 
     [JsonPropertyName("bossKilla")]
-    public TargetLocation BossKilla { get; set; }
+    public TargetLocation? BossKilla { get; set; }
 
     [JsonPropertyName("bossSanitar")]
-    public TargetLocation BossSanitar { get; set; }
+    public TargetLocation? BossSanitar { get; set; }
 
     [JsonPropertyName("bossTagilla")]
-    public TargetLocation BossTagilla { get; set; }
+    public TargetLocation? BossTagilla { get; set; }
 
     [JsonPropertyName("bossKnight")]
-    public TargetLocation BossKnight { get; set; }
+    public TargetLocation? BossKnight { get; set; }
 
     [JsonPropertyName("bossZryachiy")]
-    public TargetLocation BossZryachiy { get; set; }
+    public TargetLocation? BossZryachiy { get; set; }
 
     [JsonPropertyName("bossBoar")]
-    public TargetLocation BossBoar { get; set; }
+    public TargetLocation? BossBoar { get; set; }
 
     [JsonPropertyName("bossBoarSniper")]
-    public TargetLocation BossBoarSniper { get; set; }
+    public TargetLocation? BossBoarSniper { get; set; }
 }
 
 public class TargetLocation

Core/Models/Spt/Server/LocaleBase.cs

@@ -1,5 +1,4 @@
 using System.Text.Json.Serialization;
-using System.Collections.Generic;
 
 namespace Core.Models.Spt.Server;