Fix Namespaces along with CJs PR, Added more types

Core/Core.csproj

@@ -5,7 +5,6 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <OutputType>Library</OutputType>
-        <RootNamespace>Types</RootNamespace>
     </PropertyGroup>
 
     <ItemGroup>

Core/Models/Config/HttpConfig.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Config;
+namespace Core.Models.Config;
 
 public class HttpConfig
 {

Core/Models/Eft/Common/Tables/BotBase.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Eft.Common.Tables;
+namespace Core.Models.Eft.Common.Tables;
 
 public class BotBase
 {

Core/Models/Eft/Common/Tables/BotCore.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Eft.Common.Tables;
+namespace Core.Models.Eft.Common.Tables;
 
 public class BotCore
 {

Core/Models/Eft/Common/Tables/BotType.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Eft.Common.Tables;
+namespace Core.Models.Eft.Common.Tables;
 
 public class BotType
 {

Core/Models/Enums/ConfigTypes.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Enums;
+namespace Core.Models.Enums;
 
 public enum ConfigTypes
 {

Core/Models/Logging/LogBackgroundColor.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Logging;
+namespace Core.Models.Logging;
 
 public enum LogBackgroundColor
 {

Core/Models/Logging/LogTextColor.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Logging;
+namespace Core.Models.Logging;
 
 public enum LogTextColor
 {

Core/Models/Spt/Bots/Bots.cs

@@ -1,6 +1,7 @@
 using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
 
-namespace Types.Models.Spt.Bots;
+namespace Core.Models.Spt.Bots;
 
 public class Bots
 {

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,6 @@
+namespace Core.Models.Spt.Callbacks;
+
+public class HideoutCallbacks
+{
+    
+}

Core/Models/Spt/Callbacks/HttpCallbacks.cs

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

Core/Models/Spt/Callbacks/InsuranceCallbacks.cs

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

Core/Models/Spt/Callbacks/InventoryCallbacks.cs

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

Core/Models/Spt/Callbacks/ItemEventCallbacks.cs

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

Core/Models/Spt/Callbacks/LauncherCallbacks.cs

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

Core/Models/Spt/Callbacks/LocationCallbacks.cs

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

Core/Models/Spt/Callbacks/ModCallbacks.cs

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

Core/Models/Spt/Callbacks/NoteCallbacks.cs

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

Core/Models/Spt/Callbacks/NotifierCallbacks.cs

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

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

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class AirdropConfig : BaseConfig
 {

Core/Models/Spt/Config/BackupConfig.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 using System.Text.Json.Serialization;
 

Core/Models/Spt/Config/BaseConfig.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class BaseConfig
 {

Core/Models/Spt/Config/BotConfig.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class BotConfig : BaseConfig
 {

Core/Models/Spt/Config/BotDurability.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class BotDurability 
 {

Core/Models/Spt/Config/CoreConfig.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class CoreConfig : BaseConfig
 {

Core/Models/Spt/Config/GiftsConfig.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class Gift
 {

Core/Models/Spt/Config/HealthConfig.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class HealthConfig : BaseConfig
 {
@@ -11,7 +11,7 @@ public class HealthConfig : BaseConfig
     public HealthMultipliers HealthMultipliers { get; set; }
 
     [JsonPropertyName("save")]
-    public Save Save { get; set; }
+    public HealthSave Save { get; set; }
 }
 
 public class HealthMultipliers
@@ -23,7 +23,7 @@ public class HealthMultipliers
     public double Blacked { get; set; }
 }
 
-public class Save
+public class HealthSave
 {
     [JsonPropertyName("health")]
     public bool Health { get; set; }

Core/Models/Spt/Config/HideoutConfig.cs

@@ -1,7 +1,6 @@
-using System.Collections.Generic;
+using System.Text.Json.Serialization;
-using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class HideoutConfig : BaseConfig
 {

Core/Models/Spt/Config/HttpConfig.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
 public class HttpConfig : BaseConfig
 {

Core/Models/Spt/Config/InRaidConfig.cs

@@ -1,6 +1,87 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class InRaidConfig
+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

@@ -1,6 +1,56 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class InsuranceConfig
+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

@@ -1,6 +1,71 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class InventoryConfig
+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

@@ -1,6 +1,47 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class ItemConfig
+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

@@ -1,6 +1,24 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class LocaleConfig
+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

@@ -1,6 +1,317 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class LocationConfig
+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

@@ -1,6 +1,17 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class LootConfig
+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

@@ -1,6 +1,63 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class LostOnDeathConfig
+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

@@ -1,6 +1,12 @@
-namespace Types.Models.Spt.Config;
+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

@@ -1,6 +1,60 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class PlayerScavConfig
+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

@@ -1,6 +1,33 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class PmcChatResponse
+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

@@ -1,6 +1,159 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class PmcConfig
+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

@@ -1,6 +1,366 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class QuestConfig
+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

@@ -1,6 +1,364 @@
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
-public class RagfairConfig
+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
+{
+    // Should a purchased dynamic offers items be flagged as found in raid
+    public bool PurchasesAreFoundInRaid { get; set; }
+
+    /** Use the highest trader price for an offer if its greater than the price in templates/prices.json */
+    public bool UseTraderPriceForOffersIfHigher { get; set; }
+
+    /** Barter offer specific settings */
+    public BarterDetails Barter { get; set; }
+
+    public PackDetails Pack { get; set; }
+
+    /** Dynamic offer price below handbook adjustment values */
+    public OfferAdjustment OfferAdjustment { get; set; }
+
+    /** How many offers should expire before an offer regeneration occurs */
+    public int ExpiredOfferThreshold { get; set; }
+
+    /** How many offers should be listed */
+    public MinMax OfferItemCount { get; set; }
+
+    /** How much should the price of an offer vary by (percent 0.8 = 80%, 1.2 = 120%) */
+    public PriceRanges PriceRanges { get; set; }
+
+    /** Should default presets to listed only or should non-standard presets found in globals.json be listed too */
+    public bool ShowDefaultPresetsOnly { get; set; }
+
+    /** 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; }
+
+    public MinMax EndTimeSeconds { get; set; }
+
+    /** Settings to control the durability range of item items listed on flea */
+    public Condition Condition { get; set; }
+
+    /** Size stackable items should be listed for in percent of max stack size */
+    public MinMax StackablePercent { get; set; }
+
+    /** Items that cannot be stacked can have multiples sold in one offer, what range of values can be listed */
+    public MinMax NonStackableCount { get; set; }
+
+    /** Range of rating offers for items being listed */
+    public MinMax Rating { get; set; }
+
+    /** Armor specific flea settings */
+    public ArmorSettings Armor { get; set; }
+
+    /** A multipler to apply to individual tpls price just prior to item quality adjustment */
+    public Dictionary<string, double> ItemPriceMultiplier { get; set; }
+
+    /** Percentages to sell offers in each currency */
+    public Dictionary<string, double> Currencies { get; set; }
+
+    /** Item tpls that should be forced to sell as a single item */
+    public List<string> ShowAsSingleStack { get; set; }
+
+    /** Should christmas/halloween items be removed from flea when not within the seasonal bounds */
+    public bool RemoveSeasonalItemsWhenNotInEvent { get; set; }
+
+    /** Flea blacklist settings */
+    public RagfairBlacklist Blacklist { get; set; }
+
+    /** Dict of price limits keyed by item type */
+    public Dictionary<string, UnreasonableModPrices> UnreasonableModPrices { get; set; }
+
+    /** 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

@@ -1,6 +1,108 @@
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
-public class RepairConfig
+using System.Text.Json.Serialization;
+
+public class RepairConfig : IBaseConfig
 {
-    
+    [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

@@ -1,6 +1,78 @@
-namespace Types.Models.Spt.Config;
+namespace Core.Models.Spt.Config;
 
-public class ScavCaseConfig
+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

@@ -1,6 +1,103 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class SeasonalEventConfig
+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, SeasonalEventSettings> Settings { get; set; }
+}
+
+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

@@ -1,6 +1,172 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class TraderConfig
+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

@@ -1,6 +1,104 @@
-namespace Types.Models.Spt.Config;
+using System.Text.Json.Serialization;
 
-public class WeatherConfig
+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

@@ -1,16 +1,41 @@
-// namespace Types.Models.Spt.Controllers;
+using Core.Models.Eft.Common.Tables;
-//
-// public class BotController
-// {
-//     export interface IBotController {
-//         getBotLimit(type: string): number;
-//         getBotDifficulty(type: string, difficulty: string): IBotCore | IDifficultyCategories;
-//         isBotPmc(botRole: string): boolean;
-//         isBotBoss(botRole: string): boolean;
-//         isBotFollower(botRole: string): boolean;
-//         generate(info: IGenerateBotsRequestData, playerScav: boolean): IBotBase[];
-//         getBotCap(): number;
-//     }
-// }
 
-// TODO: implement in C#
+namespace Core.Models.Spt.Controllers;
+
+public class BotController
+{
+    public int GetBotLimit(string type)
+    {
+        throw new NotImplementedException();
+    }
+
+    public object GetBotDifficulty(string type, string difficulty) // 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

@@ -1,7 +1,6 @@
-using System.Collections.Generic;
+using System.Text.Json.Serialization;
-using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Dialog;
+namespace Core.Models.Spt.Dialog;
 
 public class SendMessageDetails
 {

Core/Models/Spt/Fence/CreateFenceAssortsResult.cs

@@ -1,7 +1,6 @@
-using System.Collections.Generic;
+using System.Text.Json.Serialization;
-using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Fence;
+namespace Core.Models.Spt.Fence;
 
 public class CreateFenceAssortsResult
 {

Core/Models/Spt/Fence/FenceAssortGenerationValues.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Fence;
+namespace Core.Models.Spt.Fence;
 
 public class FenceAssortGenerationValues
 {

Core/Models/Spt/Generators/BotGenerator.cs

@@ -1,16 +1,11 @@
-// namespace Types.Models.Spt.Generators;
+using Core.Models.Eft.Common.Tables;
-//
-// public class BotGenerator
-// {
-//     export interface IBotGenerator {
-//         generateInventory(
-//             templateInventory: IInventory,
-//         equipmentChances: IChances,
-//         generation: IGeneration,
-//         botRole: string,
-//         isPmc: boolean,
-//         ): PmcInventory;
-//     }
-// }
 
-// TODO: implement in C#
+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

@@ -1,21 +1,16 @@
-// namespace Types.Models.Spt.Generators;
+namespace Core.Models.Spt.Generators;
-//
-// public class LocationGenerator
-// {
-//     export interface ILocationGenerator {
-//         generateContainerLoot(
-//             containerIn: IStaticContainerProps,
-//         staticForced: IStaticForcedProps[],
-//         staticLootDist: Record<string, IStaticLootDetails>,
-//         staticAmmoDist: Record<string, IStaticAmmoDetails[]>,
-//         locationName: string,
-//         ): IStaticContainerProps;
-//         generateDynamicLoot(
-//             dynamicLootDist: ILooseLoot,
-//         staticAmmoDist: Record<string, IStaticAmmoDetails[]>,
-//         locationName: string,
-//         ): ISpawnpointTemplate[];
-//     }
-// }
 
-// TODO: Implement in C#
+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

@@ -1,12 +1,14 @@
-// namespace Types.Models.Spt.Generators;
+namespace Core.Models.Spt.Generators;
-//
-// public class PMCLootGenerator
-// {
-//     export interface IPMCLootGenerator {
-//         generatePMCPocketLootPool(): string[];
-//         generatePMCBackpackLootPool(): string[];
-//     }
-//
-// }
 
-// TODO: Implement in C#
+public class PMCLootGenerator
+{
+    public List<string> GeneratePMCPocketLootPool()
+    {
+        throw new NotImplementedException();
+    }
+
+    public List<string> GeneratePMCBackpackLootPool()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/RagfairAssortGenerator.cs

@@ -1,11 +1,9 @@
-// namespace Types.Models.Spt.Generators;
+namespace Core.Models.Spt.Generators;
-//
-// public class RagfairAssortGenerator
-// {
-//     export interface IRagfairAssortGenerator {
-//         getAssortItems(): IItem[];
-//     }
-//
-// }
 
-// TODO: implement in C#
+public class RagfairAssortGenerator
+{
+    public List<Item> GetAssortItems()
+    {
+        throw new NotImplementedException();
+    }
+}

Core/Models/Spt/Generators/RagfairOfferGenerator.cs

@@ -1,18 +1,10 @@
-// namespace Types.Models.Spt.Generators;
+namespace Core.Models.Spt.Generators;
-//
-// public class RagfairOfferGenerator
-// {
-//     export interface IRagfairOfferGenerator {
-//         createOffer(
-//             userID: string,
-//         time: number,
-//         items: IItem[],
-//         barterScheme: IBarterScheme[],
-//         loyalLevel: number,
-//         price: number,
-//         sellInOnePiece: boolean,
-//         ): IRagfairOffer;
-//     }
-// }
 
-// TODO: implement in C#
+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

@@ -1,7 +1,7 @@
 using System.Text.Json.Serialization;
-using Types.Models.Spt.Config;
+using Core.Models.Spt.Config;
 
-namespace Types.Models.Spt.Hideout;
+namespace Core.Models.Spt.Hideout;
 
 public class CircleCraftDetails
 {

Core/Models/Spt/Hideout/Hideout.cs

@@ -1,7 +1,7 @@
 using System.Text.Json.Serialization;
-using Types.Models.Spt.Repeatable;
+using Core.Models.Spt.Repeatable;
 
-namespace Types.Models.Spt.Hideout;
+namespace Core.Models.Spt.Hideout;
 
 public class Hideout
 {

Core/Models/Spt/Hideout/ScavCaseRewardCountsAndPrice.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Hideout;
+namespace Core.Models.Spt.Hideout;
 
 public class ScavCaseRewardCountsAndPrice
 {

Core/Models/Spt/Inventory/OwnerInventoryItems.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Inventory;
+namespace Core.Models.Spt.Inventory;
 
 public class OwnerInventoryItems
 {

Core/Models/Spt/Location/RaidChanges.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Location;
+namespace Core.Models.Spt.Location;
 
 public class RaidChanges
 {

Core/Models/Spt/Logging/ClientLogRequest.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Logging;
+namespace Core.Models.Spt.Logging;
 
 public class ClientLogRequest
 {

Core/Models/Spt/Logging/LogBackgroundColor.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Spt.Logging;
+namespace Core.Models.Spt.Logging;
 
 public struct LogBackgroundColor
 {

Core/Models/Spt/Logging/LogLevel.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Spt.Logging;
+namespace Core.Models.Spt.Logging;
 
 public enum LogLevel
 {

Core/Models/Spt/Logging/LogTextColor.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Spt.Logging;
+namespace Core.Models.Spt.Logging;
 
 public struct LogTextColor
 {

Core/Models/Spt/Logging/SptLogger.cs

@@ -1,15 +1,12 @@
-// namespace Types.Models.Spt.Logging;
+namespace Core.Models.Spt.Logging;
-//
+
-// public class SptLogger
+public class SptLogger
-// {
+{
-//     export interface SptLogger {
+    public object Error  { get; set; } // error: (msg: string | Record<string, unknown>) => void;
-//         error: (msg: string | Record<string, unknown>) => void;
+    public object Warn  { get; set; } // warn: (msg: string | Record<string, unknown>) => void;
-//         warn: (msg: string | Record<string, unknown>) => void;
+    public object Succ  { get; set; } // succ?: (msg: string | Record<string, unknown>) => void;
-//         succ?: (msg: string | Record<string, unknown>) => void;
+    public object Info  { get; set; } // info: (msg: string | Record<string, unknown>) => void;
-//         info: (msg: string | Record<string, unknown>) => void;
+    public object Debug  { get; set; } // debug: (msg: string | Record<string, unknown>) => void;
-//         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

@@ -1,13 +1,16 @@
-// namespace Types.Models.Spt.Mod;
+namespace Core.Models.Spt.Mod;
-//
+
-// public class ModLoader
+public class ModLoader
-// {
+{
-//     export interface IModLoader {
+    public void Load(DependencyContainer container)
-//         load(container: DependencyContainer): void;
+    {
-//
+        throw new NotImplementedException();
-//         getModPath(mod: string): string;
+    }
-//     }
+
-//
+    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

@@ -1,61 +1,71 @@
-// namespace Types.Models.Spt.Mod;
+using System.Text.Json.Serialization;
-//
+
-// public class NewItemDetails
+namespace Core.Models.Spt.Mod;
-// {
+
-//     export abstract class NewItemDetailsBase {
+public class NewItemDetails : NewItemDetailsBase
-//         /** Price of the item on flea market */
+{
-//         fleaPriceRoubles: number;
+    [JsonPropertyName("newItem")]
-//
+    public TemplateItem NewItem { get; set; }
-//         /** Price of the item in the handbook */
+}
-//         handbookPriceRoubles: number;
+
-//
+public class NewItemFromCloneDetails : NewItemDetailsBase
-//         /** Handbook ParentId for the new item */
+{
-//         handbookParentId: string;
+    [JsonPropertyName("itemTplToClone")]
-//
+    public string ItemTplToClone { get; set; }
-//         /**
+    
-//          * A dictionary for locale settings, key = langauge (e.g. en,cn,es-mx,jp,fr)
+    [JsonPropertyName("overrideProperties")]
-//          * If a language is not included, the first item in the array will be used in its place
+    public Props OverrideProperties { get; set; }
-//          */
+    
-//         locales: Record<string, LocaleDetails>;
+    [JsonPropertyName("parentId")]
-//     }
+    public string ParentId { get; set; }
-//
+
-//     export class NewItemFromCloneDetails extends NewItemDetailsBase {
+    [JsonPropertyName("newId")] 
-//         /** Id of the item to copy and use as a base */
+    public string NewId { get; set; } = "";
-//         itemTplToClone: string;
+}
-//
+
-//     /** Item properties that should be applied over the top of the cloned base */
+public class NewItemDetailsBase
-//     overrideProperties: IProps;
+{
-//
+    [JsonPropertyName("fleaPriceRoubles")]
-//     /** ParentId for the new item (item type) */
+    public float FleaPriceRoubles { get; set; }
-//     parentId: string;
+    
-//
+    [JsonPropertyName("handbookPriceRoubles")]
-//     /**
+    public float HandbookPriceRoubles { get; set; }
-//      * the id the new item should have, leave blank to have one generated for you
+    
-//      * This is often known as the TplId, or TemplateId
+    [JsonPropertyName("handbookParentId")]
-//      */
+    public string HandbookParentId { get; set; }
-//     newId = "";
+    
-// }
+    [JsonPropertyName("locales")]
-//
+    public Dictionary<string, LocaleDetails> Locales { get; set; }
-// export class NewItemDetails extends NewItemDetailsBase {
+}
-// newItem: ITemplateItem;
+
-// }
+public class LocaleDetails
-//
+{
-// export class LocaleDetails {
+    [JsonPropertyName("name")]
-//     name: string;
+    public string Name { get; set; }
-//     shortName: string;
+    
-//     description: string;
+    [JsonPropertyName("shortName")]
-// }
+    public string ShortName { get; set; }
-//
+    
-// export class CreateItemResult {
+    [JsonPropertyName("description")]
-//     constructor() {
+    public string Description { get; set; }
-//         this.success = false;
+}
-//         this.errors = [];
+
-//     }
+public class CreateItemResult
-//
+{
-//     success: boolean;
+    [JsonPropertyName("success")] 
-//     itemId: string;
+    public bool Success { get; set; }
-//     errors: string[];
+    
-// }
+    [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

@@ -1,27 +1,57 @@
-// namespace Types.Models.Spt.Mod;
+using System.Text.Json.Serialization;
-//
+
-// public class PackageJsonData
+namespace Core.Models.Spt.Mod;
-// {
+
-//     export interface IPackageJsonData {
+public class PackageJsonData
-//         incompatibilities?: string[];
+{
-//         loadBefore?: string[];
+    [JsonPropertyName("incompatibilities")]
-//         loadAfter?: string[];
+    public List<string>? Incompatibilities { get; set; }
-//         dependencies?: Record<string, string>;
+    
-//         modDependencies?: Record<string, string>;
+    [JsonPropertyName("loadBefore")]
-//         name: string;
+    public List<string>? LoadBefore { get; set; }
-//         url: string;
+    
-//         author: string;
+    [JsonPropertyName("loadAfter")]
-//         version: string;
+    public List<string>? LoadAfter { get; set; }
-//         sptVersion: string;
+    
-//         /** We deliberately purge this data */
+    [JsonPropertyName("dependencies")]
-//         scripts: Record<string, string>;
+    public Dictionary<string, string>? Dependencies { get; set; }
-//         devDependencies: Record<string, string>;
+    
-//         licence: string;
+    [JsonPropertyName("modDependencies")]
-//         main: string;
+    public Dictionary<string, string>? ModDependencies { get; set; }
-//         isBundleMod: boolean;
+    
-//         contributors: string[];
+    [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/Quests/GetRepeatableByIdResult.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Quests;
+namespace Core.Models.Spt.Quests;
 
 public class GetRepeatableByIdResult
 {

Core/Models/Spt/Ragfair/RagfairServerPrices.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Ragfair;
+namespace Core.Models.Spt.Ragfair;
 
 public class RagfairServerPrices
 {

Core/Models/Spt/Ragfair/TplWithFleaPrice.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Ragfair;
+namespace Core.Models.Spt.Ragfair;
 
 public class TplWithFleaPrice
 {

Core/Models/Spt/Repeatable/QuestRewardValues.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Repeatable;
+namespace Core.Models.Spt.Repeatable;
 
 public class QuestRewardValues
 {

Core/Models/Spt/Repeatable/QuestTypePool.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Repeatable;
+namespace Core.Models.Spt.Repeatable;
 
 public class QuestTypePool
 {

Core/Models/Spt/Server/DatabaseTables.cs

@@ -1,4 +1,4 @@
-namespace Types.Models.Spt.Server;
+namespace Core.Models.Spt.Server;
 
 public class DatabaseTables
 {

Core/Models/Spt/Server/LocaleBase.cs

@@ -1,7 +1,6 @@
 using System.Text.Json.Serialization;
-using System.Collections.Generic;
 
-namespace Types.Models.Spt.Server;
+namespace Core.Models.Spt.Server;
 
 public class LocaleBase
 {

Core/Models/Spt/Server/Locations.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Server;
+namespace Core.Models.Spt.Server;
 
 public class Locations
 {

Core/Models/Spt/Server/ServerBase.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Server;
+namespace Core.Models.Spt.Server;
 
 public class ServerBase
 {

Core/Models/Spt/Server/SettingsBase.cs

@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace Types.Models.Spt.Server;
+namespace Core.Models.Spt.Server;
 
 public class SettingsBase
 {