finished off helpers, added few more types (might not be used)

Core/Helpers/AssortHelper.cs

@@ -1,6 +1,61 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Helpers;
 
 public class AssortHelper
 {
+    /**
+     * Remove assorts from a trader that have not been unlocked yet (via player completing corresponding quest)
+     * @param pmcProfile Player profile
+     * @param traderId Traders id the assort belongs to
+     * @param traderAssorts All assort items from same trader
+     * @param mergedQuestAssorts Dict of quest assort to quest id unlocks for all traders (key = started/failed/complete)
+     * @returns Assort items minus locked quest assorts
+     */
+    public TraderAssort StripLockedQuestAssort(
+        PmcData pmcProfile,
+        string traderId,
+        List<TraderAssort> traderAssorts,
+        Dictionary<string, Dictionary<string, string>> mergedQuestAssorts,
+        bool flea = false)
+    {
+        throw new NotImplementedException();
+    }
 
+    /**
+     * Get a quest id + the statuses quest can be in to unlock assort
+     * @param mergedQuestAssorts quest assorts to search for assort id
+     * @param assortId Assort to look for linked quest id
+     * @returns quest id + array of quest status the assort should show for
+     */
+    protected (string questId, QuestStatus[] status) GetQuestIdAndStatusThatShowAssort(
+        Dictionary<string, Dictionary<string, string>> mergedQuestAssorts,
+        string assortId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /**
+     * Remove assorts from a trader that have not been unlocked yet
+     * @param pmcProfile player profile
+     * @param traderId traders id
+     * @param assort traders assorts
+     * @returns traders assorts minus locked loyalty assorts
+     */
+    public TraderAssort StripLockedLoyaltyAssort(PmcData pmcProfile, string traderId, List<TraderAssort> assort)
+    {
+        throw new NotImplementedException();
+    }
+
+    /**
+     * Remove an item from an assort
+     * @param assort assort to modify
+     * @param itemID item id to remove from assort
+     * @returns Modified assort
+     */
+    public TraderAssort RemoveItemFromAssort(List<TraderAssort> assort, string itemID, bool flea = false)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/BotDifficultyHelper.cs

@@ -1,6 +1,49 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Spt.Bots;
+
+namespace Core.Helpers;
 
 public class BotDifficultyHelper
 {
+    /// <summary>
+    /// Get difficulty settings for desired bot type, if not found use assault bot types
+    /// </summary>
+    /// <param name="type">bot type to retrieve difficulty of</param>
+    /// <param name="difficulty">difficulty to get settings for (easy/normal etc)</param>
+    /// <param name="botDb">bots from database</param>
+    /// <returns>Difficulty object</returns>
+    public DifficultyCategories GetBotDifficultySettings(string botType, string difficultyLevel, Bots botDatabase)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Get difficulty settings for a PMC
+    /// </summary>
+    /// <param name="type">"usec" / "bear"</param>
+    /// <param name="difficulty">what difficulty to retrieve</param>
+    /// <returns>Difficulty object</returns>
+    protected DifficultyCategories GetDifficultySettings(string botType, string difficultyLevel)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Translate chosen value from pre-raid difficulty dropdown into bot difficulty value
+    /// </summary>
+    /// <param name="dropDownDifficulty">Dropdown difficulty value to convert</param>
+    /// <returns>bot difficulty</returns>
+    public string ConvertBotDifficultyDropdownToBotDifficulty(string dropDownDifficultyValue)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Choose a random difficulty from - easy/normal/hard/impossible
+    /// </summary>
+    /// <returns>random difficulty</returns>
+    public string ChooseRandomDifficulty()
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/BotGeneratorHelper.cs

@@ -1,6 +1,117 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Spt.Config;
+
+namespace Core.Helpers;
 
 public class BotGeneratorHelper
 {
+    /// <summary>
+    /// Adds properties to an item
+    /// e.g. Repairable / HasHinge / Foldable / MaxDurability
+    /// </summary>
+    /// <param name="itemTemplate">Item extra properties are being generated for</param>
+    /// <param name="botRole">Used by weapons to randomize the durability values. Null for non-equipped items</param>
+    /// <returns>Item Upd object with extra properties</returns>
+    public object GenerateExtraPropertiesForItem(TemplateItem itemTemplate, string botRole = null)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Randomize the HpResource for bots e.g (245/400 resources)
+    /// </summary>
+    /// <param name="maxResource">Max resource value of medical items</param>
+    /// <param name="randomizationValues">Value provided from config</param>
+    /// <returns>Randomized value from maxHpResource</returns>
+    protected double GetRandomizedResourceValue(double maxResource, RandomisedResourceValues randomizationValues)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the chance for the weapon attachment or helmet equipment to be set as activated
+    /// </summary>
+    /// <param name="botRole">role of bot with weapon/helmet</param>
+    /// <param name="setting">the setting of the weapon attachment/helmet equipment to be activated</param>
+    /// <param name="defaultValue">default value for the chance of activation if the botrole or bot equipment role is undefined</param>
+    /// <returns>Percent chance to be active</returns>
+    protected double GetBotEquipmentSettingFromConfig(string botRole, string setting, double defaultValue)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Create a repairable object for a weapon that containers durability + max durability properties
+    /// </summary>
+    /// <param name="itemTemplate">weapon object being generated for</param>
+    /// <param name="botRole">type of bot being generated for</param>
+    /// <returns>Repairable object</returns>
+    protected object GenerateWeaponRepairableProperties(TemplateItem itemTemplate, string botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Create a repairable object for an armor that containers durability + max durability properties
+    /// </summary>
+    /// <param name="itemTemplate">weapon object being generated for</param>
+    /// <param name="botRole">type of bot being generated for</param>
+    /// <returns>Repairable object</returns>
+    protected object GenerateArmorRepairableProperties(TemplateItem itemTemplate, string botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Can item be added to another item without conflict
+    /// </summary>
+    /// <param name="itemsEquipped">Items to check compatibilities with</param>
+    /// <param name="tplToCheck">Tpl of the item to check for incompatibilities</param>
+    /// <param name="equipmentSlot">Slot the item will be placed into</param>
+    /// <returns>false if no incompatibilities, also has incompatibility reason</returns>
+    public object IsItemIncompatibleWithCurrentItems(List<Item> itemsEquipped, string tplToCheck, string equipmentSlot)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Convert a bots role to the equipment role used in config/bot.json
+    /// </summary>
+    /// <param name="botRole">Role to convert</param>
+    /// <returns>Equipment role (e.g. pmc / assault / bossTagilla)</returns>
+    public string GetBotEquipmentRole(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Adds an item with all its children into specified equipmentSlots, wherever it fits.
+    /// </summary>
+    /// <param name="equipmentSlots">Slot to add item+children into</param>
+    /// <param name="rootItemId">Root item id to use as mod items parentid</param>
+    /// <param name="rootItemTplId">Root itms tpl id</param>
+    /// <param name="itemWithChildren">Item to add</param>
+    /// <param name="inventory">Inventory to add item+children into</param>
+    /// <returns>ItemAddedResult result object</returns>
+    public object AddItemWithChildrenToEquipmentSlot(
+        List<string> equipmentSlots,
+        string rootItemId,
+        string rootItemTplId,
+        List<Item> itemWithChildren,
+        BotBaseInventory inventory,
+        HashSet<string> containersIdFull = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Is the provided item allowed inside a container
+    /// </summary>
+    /// <param name="slotGrid">Items sub-grid we want to place item inside</param>
+    /// <param name="itemTpl">Item tpl being placed</param>
+    /// <returns>True if allowed</returns>
+    protected bool ItemAllowedInContainer(Grid slotGrid, string itemTpl)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/BotHelper.cs

@@ -1,6 +1,128 @@
-namespace Core.Helpers;
+using Core.Models.Common;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Spt.Config;
+
+namespace Core.Helpers;
 
 public class BotHelper
 {
+    /// <summary>
+    /// Get a template object for the specified botRole from bots.types db
+    /// </summary>
+    /// <param name="role">botRole to get template for</param>
+    /// <returns>BotType object</returns>
+    public BotType GetBotTemplate(string role)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Is the passed in bot role a PMC (usec/bear/pmc)
+    /// </summary>
+    /// <param name="botRole">bot role to check</param>
+    /// <returns>true if is pmc</returns>
+    public bool IsBotPmc(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsBotBoss(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsBotFollower(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add a bot to the FRIENDLY_BOT_TYPES list
+    /// </summary>
+    /// <param name="difficultySettings">bot settings to alter</param>
+    /// <param name="typeToAdd">bot type to add to friendly list</param>
+    public void AddBotToFriendlyList(DifficultyCategories difficultySettings, string typeToAdd)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add a bot to the REVENGE_BOT_TYPES list
+    /// </summary>
+    /// <param name="difficultySettings">bot settings to alter</param>
+    /// <param name="typesToAdd">bot type to add to revenge list</param>
+    public void AddBotToRevengeList(DifficultyCategories difficultySettings, string[] typesToAdd)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool RollChanceToBePmc(MinMax botConvertMinMax)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void GetPmcConversionValuesForLocation(string location)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// is the provided role a PMC, case-agnostic
+    /// </summary>
+    /// <param name="botRole">Role to check</param>
+    /// <returns>True if role is PMC</returns>
+    public bool BotRoleIsPmc(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get randomization settings for bot from config/bot.json
+    /// </summary>
+    /// <param name="botLevel">level of bot</param>
+    /// <param name="botEquipConfig">bot equipment json</param>
+    /// <returns>RandomisationDetails</returns>
+    public RandomisationDetails GetBotRandomizationDetails(int botLevel, EquipmentFilters botEquipConfig)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Choose between pmcBEAR and pmcUSEC at random based on the % defined in pmcConfig.isUsec
+    /// </summary>
+    /// <returns>pmc role</returns>
+    public string GetRandomizedPmcRole()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the corresponding side when pmcBEAR or pmcUSEC is passed in
+    /// </summary>
+    /// <param name="botRole">role to get side for</param>
+    /// <returns>side (usec/bear)</returns>
+    public string GetPmcSideByRole(string botRole)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a randomized PMC side based on bot config value 'isUsec'
+    /// </summary>
+    /// <returns>pmc side as string</returns>
+    protected string GetRandomizedPmcSide()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a name from a PMC that fits the desired length
+    /// </summary>
+    /// <param name="maxLength">Max length of name, inclusive</param>
+    /// <param name="side">OPTIONAL - what side PMC to get name from (usec/bear)</param>
+    /// <returns>name of PMC</returns>
+    public string GetPmcNicknameOfMaxLength(int maxLength, string side = null)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/BotWeaponGeneratorHelper.cs

@@ -1,6 +1,77 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Enums;
+
+namespace Core.Helpers;
 
 public class BotWeaponGeneratorHelper
 {
+    /// <summary>
+    /// Get a randomized number of bullets for a specific magazine
+    /// </summary>
+    /// <param name="magCounts">Weights of magazines</param>
+    /// <param name="magTemplate">Magazine to generate bullet count for</param>
+    /// <returns>Bullet count number</returns>
+    public int GetRandomizedBulletCount(GenerationData magCounts, TemplateItem magTemplate)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Get a randomized count of magazines
+    /// </summary>
+    /// <param name="magCounts">Min and max value returned value can be between</param>
+    /// <returns>Numerical value of magazine count</returns>
+    public int GetRandomizedMagazineCount(GenerationData magCounts)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Is this magazine cylinder related (revolvers and grenade launchers)
+    /// </summary>
+    /// <param name="magazineParentName">The name of the magazines parent</param>
+    /// <returns>True if it is cylinder related</returns>
+    public bool MagazineIsCylinderRelated(string magazineParentName)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Create a magazine using the parameters given
+    /// </summary>
+    /// <param name="magazineTpl">Tpl of the magazine to create</param>
+    /// <param name="ammoTpl">Ammo to add to magazine</param>
+    /// <param name="magTemplate">Template object of magazine</param>
+    /// <returns>Item array</returns>
+    public List<Item> CreateMagazineWithAmmo(string magazineTpl, string ammoTpl, TemplateItem magTemplate)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add a specific number of cartridges to a bots inventory (defaults to vest and pockets)
+    /// </summary>
+    /// <param name="ammoTpl">Ammo tpl to add to vest/pockets</param>
+    /// <param name="cartridgeCount">Number of cartridges to add to vest/pockets</param>
+    /// <param name="inventory">Bot inventory to add cartridges to</param>
+    /// <param name="equipmentSlotsToAddTo">What equipment slots should bullets be added into</param>
+    public void AddAmmoIntoEquipmentSlots(
+        string ammoTpl,
+        int cartridgeCount,
+        BotBaseInventory inventory,
+        object equipmentSlotsToAddTo // TODO: EquipmentSlots[] equipmentSlotsToAddTo = new EquipmentSlots[] { EquipmentSlots.TACTICAL_VEST, EquipmentSlots.POCKETS }
+    )
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a weapons default magazine template id
+    /// </summary>
+    /// <param name="weaponTemplate">Weapon to get default magazine for</param>
+    /// <returns>Tpl of magazine</returns>
+    public string GetWeaponsDefaultMagazineTpl(TemplateItem weaponTemplate)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/ContainerHelper.cs

@@ -1,6 +1,76 @@
-namespace Core.Helpers;
+using System.Text.Json.Serialization;
+
+namespace Core.Helpers;
 
 public class ContainerHelper
 {
+    /// <summary>
+    /// Finds a slot for an item in a given 2D container map
+    /// </summary>
+    /// <param name="container2D">List of container with slots filled/free</param>
+    /// <param name="itemWidth">Width of item</param>
+    /// <param name="itemHeight">Height of item</param>
+    /// <returns>Location to place item in container</returns>
+    public FindSlotResult FindSlotForItem(List<List<int>> container2D, int itemWidth, int itemHeight)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Find a slot inside a container an item can be placed in
+    /// </summary>
+    /// <param name="container2D">Container to find space in</param>
+    /// <param name="containerX">Container x size</param>
+    /// <param name="containerY">Container y size</param>
+    /// <param name="x">???</param>
+    /// <param name="y">???</param>
+    /// <param name="itemW">Items width</param>
+    /// <param name="itemH">Items height</param>
+    /// <returns>True - slot found</returns>
+    protected bool LocateSlot(
+        List<List<int>> container2D,
+        int containerX,
+        int containerY,
+        int x,
+        int y,
+        int itemW,
+        int itemH)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Find a free slot for an item to be placed at
+    /// </summary>
+    /// <param name="container2D">Container to place item in</param>
+    /// <param name="x">Container x size</param>
+    /// <param name="y">Container y size</param>
+    /// <param name="itemW">Items width</param>
+    /// <param name="itemH">Items height</param>
+    /// <param name="rotate">is item rotated</param>
+    public void FillContainerMapWithItem(
+        List<List<int>> container2D,
+        int x,
+        int y,
+        int itemW,
+        int itemH,
+        bool rotate)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class FindSlotResult
+{
+    [JsonPropertyName("success")]
+    public bool? Success { get; set; }
+    
+    [JsonPropertyName("x")]
+    public double? X { get; set; }
+    
+    [JsonPropertyName("y")]
+    public double? Y { get; set; }
+    
+    [JsonPropertyName("rotation")]
+    public bool? Rotation { get; set; }
 }

Core/Helpers/Dialogue/AbstractDialogChatBot.cs

@@ -1,6 +1,28 @@
-namespace Core.Helpers.Dialogue;
+using Core.Helpers.Dialog.Commando;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
 
-public class AbstractDialogChatBot
+namespace Core.Helpers.Dialogue;
+
+public class AbstractDialogChatBot : IDialogueChatBot
 {
+    public UserDialogInfo GetChatBot()
+    {
+        throw new NotImplementedException();
+    }
 
+    public string HandleMessage(string sessionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
+
+    public void RegisterChatCommand(IChatCommand chatCommand)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected string GetUnrecognizedCommandMessage()
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/Commando/ChatCommand.cs

@@ -1,6 +0,0 @@
-namespace Core.Helpers.Dialog.Commando;
-
-public class ChatCommand
-{
-    
-}

Core/Helpers/Dialogue/Commando/IChatCommand.cs

@@ -0,0 +1,12 @@
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
+
+namespace Core.Helpers.Dialog.Commando;
+
+public interface IChatCommand
+{
+    public string GetCommandPrefix();
+    public string GetCommandHelp(string command);
+    public List<string> GetCommands();
+    public string Handle(string command, UserDialogInfo commandHandler, string sesssionId, SendMessageRequest request);
+}

Core/Helpers/Dialogue/Commando/SptCommandoCommands.cs

@@ -1,6 +1,33 @@
-namespace Core.Helpers.Dialog.Commando;
+using Core.Helpers.Dialog.Commando.SptCommands;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
 
-public class SptCommandoCommands
+namespace Core.Helpers.Dialog.Commando;
+
+public class SptCommandoCommands : IChatCommand
 {
+    public void RegisterSptCommandoCommand(ISptCommand command)
+    {
+        throw new NotImplementedException();
+    }
     
+    public string GetCommandPrefix()
+    {
+        throw new NotImplementedException();
+    }
+
+    public string GetCommandHelp(string command)
+    {
+        throw new NotImplementedException();
+    }
+
+    public List<string> GetCommands()
+    {
+        throw new NotImplementedException();
+    }
+
+    public string Handle(string command, UserDialogInfo commandHandler, string sesssionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/Commando/SptCommands/GiveCommand/GiveSptCommand.cs

@@ -1,6 +1,35 @@
-namespace Core.Helpers.Dialog.Commando.SptCommands.GiveCommand;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
+
+namespace Core.Helpers.Dialog.Commando.SptCommands.GiveCommand;
 
 public class GiveSptCommand
 {
+    public string GetCommand()
+    {
+        return "give";
+    }
 
+    public string GetCommandHelp()
+    {
+        return "spt give\n========\nSends items to the player through the message system.\n\n\tspt give [template ID] [quantity]\n\t\tEx: " +
+               "spt give 544fb25a4bdc2dfb738b4567 2\n\n\tspt give [\"item name\"] [quantity]\n\t\tEx: spt give \"pack of sugar\" 10\n\n\tspt " +
+               "give [locale] [\"item name\"] [quantity]\n\t\tEx: spt give fr \"figurine de chat\" 3";
+    }
+
+    public string PerformAction(UserDialogInfo commandHandler, string sessionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
+
+    /**
+     * A "simple" function that checks if an item is supposed to be given to a player or not
+     * @param templateItem the template item to check
+     * @returns true if its obtainable, false if its not
+     */
+    protected bool IsItemAllowed(TemplateItem templateItem)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/Commando/SptCommands/ISptCommand.cs

@@ -0,0 +1,11 @@
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
+
+namespace Core.Helpers.Dialog.Commando.SptCommands;
+
+public interface ISptCommand
+{
+    public string GetCommand();
+    public string GetCommandHelp();
+    public string PerformAction(UserDialogInfo commandHandler, string sessionId, SendMessageRequest request);
+}

Core/Helpers/Dialogue/Commando/SptCommands/ProfileCommand/ProfileSptCommand.cs

@@ -1,6 +1,35 @@
-namespace Core.Helpers.Dialog.Commando.SptCommands.ProfileCommand;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
+using Core.Models.Spt.Dialog;
 
-public class ProfileSptCommand
+namespace Core.Helpers.Dialog.Commando.SptCommands.ProfileCommand;
+
+public class ProfileSptCommand : ISptCommand
 {
+    public string GetCommand()
+    {
+        return "profile";
+    }
 
+    public string GetCommandHelp()
+    {
+        return "spt profile\n========\nSets the profile level or skill to the desired level through the message system.\n\n\tspt " +
+               "profile level [desired level]\n\t\tEx: spt profile level 20\n\n\tspt profile skill [skill name] [quantity]\n\t\tEx: " +
+               "spt profile skill metabolism 51";
+    }
+
+    public string PerformAction(UserDialogInfo commandHandler, string sessionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected ProfileChangeEvent HandleSkillCommand(string skill, int level)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected ProfileChangeEvent HandleLevelCommand(int level)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/Commando/SptCommands/SptCommand.cs

@@ -1,6 +0,0 @@
-namespace Core.Helpers.Dialog.Commando.SptCommands;
-
-public class SptCommand
-{
-    
-}

Core/Helpers/Dialogue/Commando/SptCommands/TraderCommand/TraderSptCommand.cs

@@ -1,6 +1,22 @@
-namespace Core.Helpers.Dialog.Commando.SptCommands.TraderCommand;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
 
-public class TraderSptCommand
+namespace Core.Helpers.Dialog.Commando.SptCommands.TraderCommand;
+
+public class TraderSptCommand : ISptCommand
 {
+    public string GetCommand()
+    {
+        return "trader";
+    }
 
+    public string GetCommandHelp()
+    {
+        return "spt trader\n========\nSets the reputation or money spent to the input quantity through the message system.\n\n\tspt trader [trader] rep [quantity]\n\t\tEx: spt trader prapor rep 2\n\n\tspt trader [trader] spend [quantity]\n\t\tEx: spt trader therapist spend 1000000";
+    }
+
+    public string PerformAction(UserDialogInfo commandHandler, string sessionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/CommandoDialogChatBot.cs

@@ -1,6 +1,16 @@
-namespace Core.Helpers.Dialogue;
+using Core.Models.Eft.Profile;
 
-public class CommandoDialogChatBot
+namespace Core.Helpers.Dialogue;
+
+public class CommandoDialogChatBot : AbstractDialogChatBot
 {
+    public UserDialogInfo GetChatBot()
+    {
+        throw new NotImplementedException();
+    }
 
+    protected string GetUnrecognizedCommandMessage()
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/Dialogue/DialogueChatBot.cs

@@ -1,6 +0,0 @@
-namespace Core.Helpers.Dialogue;
-
-public class DialogueChatBot
-{
-    
-}

Core/Helpers/Dialogue/IDialogueChatBot.cs

@@ -0,0 +1,10 @@
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
+
+namespace Core.Helpers.Dialogue;
+
+public interface IDialogueChatBot
+{
+    public UserDialogInfo GetChatBot();
+    public string HandleMessage(string sessionId, SendMessageRequest request);
+}

Core/Helpers/Dialogue/SptDialogueChatBot.cs

@@ -1,6 +1,17 @@
-namespace Core.Helpers.Dialogue;
+using Core.Models.Eft.Dialog;
+using Core.Models.Eft.Profile;
 
-public class SptDialogueChatBot
+namespace Core.Helpers.Dialogue;
+
+public class SptDialogueChatBot : IDialogueChatBot
 {
+    public UserDialogInfo GetChatBot()
+    {
+        throw new NotImplementedException();
+    }
 
+    public string HandleMessage(string sessionId, SendMessageRequest request)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/DialogueHelper.cs

@@ -1,6 +1,39 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Profile;
+
+namespace Core.Helpers;
 
 public class DialogueHelper
 {
+    /// <summary>
+    /// Get the preview contents of the last message in a dialogue.
+    /// </summary>
+    /// <param name="dialogue"></param>
+    /// <returns>MessagePreview</returns>
+    public MessagePreview GetMessagePreview(Models.Eft.Profile.Dialogue dialogue)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Get the item contents for a particular message.
+    /// </summary>
+    /// <param name="messageID"></param>
+    /// <param name="sessionID"></param>
+    /// <param name="itemId">Item being moved to inventory</param>
+    /// <returns></returns>
+    public List<Item> GetMessageItemContents(string messageID, string sessionID, string itemId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the dialogs dictionary for a profile, create if doesn't exist
+    /// </summary>
+    /// <param name="sessionId">Session/player id</param>
+    /// <returns>Dialog dictionary</returns>
+    public Dictionary<string, Models.Eft.Profile.Dialogue> GetDialogsForProfile(string sessionId)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/DurabilityLimitsHelper.cs

@@ -1,6 +1,112 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Helpers;
 
 public class DurabilityLimitsHelper
 {
+    /// <summary>
+    /// Get max durability for a weapon based on bot role
+    /// </summary>
+    /// <param name="itemTemplate">UNUSED - Item to get durability for</param>
+    /// <param name="botRole">Role of bot to get max durability for</param>
+    /// <returns>Max durability of weapon</returns>
+    public double GetRandomizedMaxWeaponDurability(TemplateItem itemTemplate, string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Get max durability value for armor based on bot role
+    /// </summary>
+    /// <param name="itemTemplate">Item to get max durability for</param>
+    /// <param name="botRole">Role of bot to get max durability for</param>
+    /// <returns>max durability</returns>
+    public double GetRandomizedMaxArmorDurability(TemplateItem itemTemplate, string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get randomised current weapon durability by bot role
+    /// </summary>
+    /// <param name="itemTemplate">Unused - Item to get current durability of</param>
+    /// <param name="botRole">Role of bot to get current durability for</param>
+    /// <param name="maxDurability">Max durability of weapon</param>
+    /// <returns>Current weapon durability</returns>
+    public double GetRandomizedWeaponDurability(TemplateItem itemTemplate, string? botRole, double maxDurability)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get randomised current armor durability by bot role
+    /// </summary>
+    /// <param name="itemTemplate">Unused - Item to get current durability of</param>
+    /// <param name="botRole">Role of bot to get current durability for</param>
+    /// <param name="maxDurability">Max durability of armor</param>
+    /// <returns>Current armor durability</returns>
+    public double GetRandomizedArmorDurability(TemplateItem itemTemplate, string? botRole, double maxDurability)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GenerateMaxWeaponDurability(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GenerateMaxPmcArmorDurability(double itemMaxDurability)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetLowestMaxWeaponFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetHighestMaxWeaponDurabilityFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GenerateWeaponDurability(string? botRole, double maxDurability)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GenerateArmorDurability(string? botRole, double maxDurability)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMinWeaponDeltaFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMaxWeaponDeltaFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMinArmorDeltaFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMaxArmorDeltaFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMinArmorLimitPercentFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected double GetMinWeaponLimitPercentFromConfig(string? botRole = null)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/HandbookHelper.cs

@@ -1,6 +1,87 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Helpers;
 
 public class HandbookHelper
 {
+    /// <summary>
+    /// Create an in-memory cache of all items with associated handbook price in handbookPriceCache class
+    /// </summary>
+    public void HydrateLookup()
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Get price from internal cache, if cache empty look up price directly in handbook (expensive)
+    /// If no values found, return 0
+    /// </summary>
+    /// <param name="tpl">Item tpl to look up price for</param>
+    /// <returns>price in roubles</returns>
+    public double GetTemplatePrice(string tpl)
+    {
+        throw new NotImplementedException();
+    }
+
+    public double GetTemplatePriceForItems(List<Item> items)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get all items in template with the given parent category
+    /// </summary>
+    /// <param name="parentId"></param>
+    /// <returns>string array</returns>
+    public List<string> TemplatesWithParent(string parentId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Does category exist in handbook cache
+    /// </summary>
+    /// <param name="category"></param>
+    /// <returns>true if exists in cache</returns>
+    public bool IsCategory(string category)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get all items associated with a categories parent
+    /// </summary>
+    /// <param name="categoryParent"></param>
+    /// <returns>string array</returns>
+    public List<string> ChildrenCategories(string categoryParent)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Convert non-roubles into roubles
+    /// </summary>
+    /// <param name="nonRoubleCurrencyCount">Currency count to convert</param>
+    /// <param name="currencyTypeFrom">What current currency is</param>
+    /// <returns>Count in roubles</returns>
+    public double InRUB(double nonRoubleCurrencyCount, string currencyTypeFrom)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Convert roubles into another currency
+    /// </summary>
+    /// <param name="roubleCurrencyCount">roubles to convert</param>
+    /// <param name="currencyTypeTo">Currency to convert roubles into</param>
+    /// <returns>currency count in desired type</returns>
+    public double FromRUB(double roubleCurrencyCount, string currencyTypeTo)
+    {
+        throw new NotImplementedException();
+    }
+
+    public HandbookCategory GetCategoryById(string handbookId)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/HealthHelper.cs

@@ -1,6 +1,116 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Health;
+using Core.Models.Eft.Profile;
+using Effects = Core.Models.Eft.Profile.Effects;
+using Health = Core.Models.Eft.Profile.Health;
+
+namespace Core.Helpers;
 
 public class HealthHelper
 {
+    /// <summary>
+    /// Resets the profiles vitality/health and vitality/effects properties to their defaults
+    /// </summary>
+    /// <param name="sessionID">Session Id</param>
+    /// <returns>Updated profile</returns>
+    public SptProfile ResetVitality(string sessionID)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Update player profile vitality values with changes from client request object
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="postRaidHealth">Post raid data</param>
+    /// <param name="sessionID">Session id</param>
+    /// <param name="isDead">Is player dead</param>
+    /// <param name="addEffects">Should effects be added to profile (default - true)</param>
+    /// <param name="deleteExistingEffects">Should all prior effects be removed before apply new ones  (default - true)</param>
+    public void UpdateProfileHealthPostRaid(
+        PmcData pmcData,
+        Health postRaidHealth,
+        string sessionID,
+        bool isDead)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void StoreHydrationEnergyTempInProfile(
+        SptProfile fullProfile,
+        double hydration,
+        double energy,
+        double temprature)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Take body part effects from client profile and apply to server profile
+    /// </summary>
+    /// <param name="postRaidBodyParts">Post-raid body part data</param>
+    /// <param name="profileData">Player profile on server</param>
+    protected void TransferPostRaidLimbEffectsToProfile(BodyPartsHealth postRaidBodyParts, PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Update player profile vitality values with changes from client request object
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="request">Heal request</param>
+    /// <param name="sessionID">Session id</param>
+    /// <param name="addEffects">Should effects be added to profile (default - true)</param>
+    /// <param name="deleteExistingEffects">Should all prior effects be removed before apply new ones  (default - true)</param>
+    public void SaveVitality(
+        PmcData pmcData,
+        SyncHealthRequestData request,
+        string sessionID,
+        bool addEffects = true,
+        bool deleteExistingEffects = true)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Adjust hydration/energy/temperate and body part hp values in player profile to values in profile.vitality
+    /// </summary>
+    /// <param name="pmcData">Profile to update</param>
+    /// <param name="sessionID">Session id</param>
+    protected void SaveHealth(PmcData pmcData, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Save effects to profile
+    /// Works by removing all effects and adding them back from profile
+    /// Removes empty 'Effects' objects if found
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="sessionID">Session id</param>
+    /// <param name="bodyPartsWithEffects">Dictionary of body parts with effects that should be added to profile</param>
+    /// <param name="deleteExistingEffects">Should effects be added back to profile</param>
+    protected void SaveEffects(
+        PmcData pmcData,
+        string sessionID,
+        Effects bodyPartsWithEffects,
+        bool deleteExistingEffects = true)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add effect to body part in profile
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="effectBodyPart">Body part to edit</param>
+    /// <param name="effectType">Effect to add to body part</param>
+    /// <param name="duration">How long the effect has left in seconds (-1 by default, no duration).</param>
+    protected void AddEffect(PmcData pmcData, string effectBodyPart, string effectType, int duration = -1)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/HideoutHelper.cs

@@ -1,6 +1,474 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Hideout;
+using Core.Models.Eft.ItemEvent;
+using Core.Models.Enums;
+
+namespace Core.Helpers;
 
 public class HideoutHelper
 {
+    /// <summary>
+    /// Add production to profiles' Hideout.Production array
+    /// </summary>
+    /// <param name="profileData">Profile to add production to</param>
+    /// <param name="productionRequest">Production request</param>
+    /// <param name="sessionId">Session id</param>
+    /// <returns>client response</returns>
+    public void RegisterProduction(
+        PmcData profileData,
+        HideoutSingleProductionStartRequestData productionRequest,
+        string sessionId)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// This convenience function initializes new Production Object
+    /// with all the constants.
+    /// </summary>
+    public void InitProduction(
+        string recipeId,
+        int productionTime,
+        bool needFuelForAllProductionTime)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Is the provided object a Production type
+    /// </summary>
+    /// <param name="productive"></param>
+    /// <returns></returns>
+    public bool IsProductionType(Productive productive)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Apply bonus to player profile given after completing hideout upgrades
+    /// </summary>
+    /// <param name="profileData">Profile to add bonus to</param>
+    /// <param name="bonus">Bonus to add to profile</param>
+    public void ApplyPlayerUpgradesBonuses(PmcData profileData, StageBonus bonus)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Process a players hideout, update areas that use resources + increment production timers
+    /// </summary>
+    /// <param name="sessionId">Session id</param>
+    public void UpdatePlayerHideout(string sessionId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get various properties that will be passed to hideout update-related functions
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    /// <returns>Properties</returns>
+    protected (int btcFarmCGs, bool isGeneratorOn, bool waterCollectorHasFilter) GetHideoutProperties(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected bool DoesWaterCollectorHaveFilter(BotHideoutArea waterCollector)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Iterate over productions and update their progress timers
+    /// </summary>
+    /// <param name="profileData">Profile to check for productions and update</param>
+    /// <param name="hideoutProperties">Hideout properties</param>
+    protected void UpdateProductionTimers(
+        PmcData profileData,
+        (int btcFarmCGs, bool isGeneratorOn, bool waterCollectorHasFilter) hideoutProperties)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Is a craft from a particular hideout area
+    /// </summary>
+    /// <param name="craft">Craft to check</param>
+    /// <param name="hideoutType">Type to check craft against</param>
+    /// <returns>True if it is from that area</returns>
+    protected bool IsCraftOfType(Production craft, HideoutAreas hideoutType)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Has the craft completed
+    /// Ignores bitcoin farm/cultist circle as they're continuous crafts
+    /// </summary>
+    /// <param name="craft">Craft to check</param>
+    /// <returns>True when craft is complete</returns>
+    protected bool IsCraftComplete(Production craft)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Update progress timer for water collector
+    /// </summary>
+    /// <param name="pmcData">profile to update</param>
+    /// <param name="productionId">id of water collection production to update</param>
+    /// <param name="hideoutProperties">Hideout properties</param>
+    protected void UpdateWaterCollectorProductionTimer(
+        PmcData pmcData,
+        string productionId,
+        Dictionary<string, object> hideoutProperties)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Update a productions progress value based on the amount of time that has passed
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="prodId">Production id being crafted</param>
+    /// <param name="recipe">Recipe data being crafted</param>
+    /// <param name="hideoutProperties"></param>
+    protected void UpdateProductionProgress(
+        PmcData pmcData,
+        string prodId,
+        HideoutProduction recipe,
+        Dictionary<string, object> hideoutProperties)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void UpdateCultistCircleCraftProgress(PmcData pmcData, string prodId)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void FlagCultistCircleCraftAsComplete(Productive production)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Check if a productions progress value matches its corresponding recipes production time value
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="prodId">Production id</param>
+    /// <param name="recipe">Recipe being crafted</param>
+    /// <returns>progress matches productionTime from recipe</returns>
+    protected bool DoesProgressMatchProductionTime(PmcData pmcData, string prodId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Update progress timer for scav case
+    /// </summary>
+    /// <param name="pmcData">Profile to update</param>
+    /// <param name="productionId">Id of scav case production to update</param>
+    protected void UpdateScavCaseProductionTimer(PmcData pmcData, string productionId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Iterate over hideout areas that use resources (fuel/filters etc) and update associated values
+    /// </summary>
+    /// <param name="sessionID">Session id</param>
+    /// <param name="pmcData">Profile to update areas of</param>
+    /// <param name="hideoutProperties">hideout properties</param>
+    protected void UpdateAreasWithResources(
+        string sessionID,
+        PmcData pmcData,
+        Dictionary<string, object> hideoutProperties)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Decrease fuel from generator slots based on amount of time since last time this occurred
+    /// </summary>
+    /// <param name="generatorArea">Hideout area</param>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="isGeneratorOn">Is the generator turned on since last update</param>
+    protected void UpdateFuel(BotHideoutArea generatorArea, PmcData pmcData, bool isGeneratorOn)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void UpdateWaterCollector(
+        string sessionId,
+        PmcData pmcData,
+        BotHideoutArea area,
+        Dictionary<string, object> hideoutProperties)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get craft time and make adjustments to account for dev profile + crafting skill level
+    /// </summary>
+    /// <param name="playerProfile">Player profile making craft</param>
+    /// <param name="recipeId">Recipe being crafted</param>
+    /// <param name="applyHideoutManagementBonus">Should the hideout management bonus be applied to the calculation</param>
+    /// <returns>Items craft time with bonuses subtracted</returns>
+    public double GetAdjustedCraftTimeWithSkills(
+        PmcData playerProfile,
+        string recipeId,
+        bool applyHideoutManagementBonus = false)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Adjust water filter objects resourceValue or delete when they reach 0 resource
+    /// </summary>
+    /// <param name="waterFilterArea">Water filter area to update</param>
+    /// <param name="production">Production object</param>
+    /// <param name="isGeneratorOn">Is generator enabled</param>
+    /// <param name="playerProfile">Player profile</param>
+    protected void UpdateWaterFilters(
+        BotHideoutArea waterFilterArea,
+        Production production,
+        bool isGeneratorOn,
+        PmcData playerProfile)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get an adjusted water filter drain rate based on time elapsed since last run,
+    /// handle edge case when craft time has gone on longer than total production time
+    /// </summary>
+    /// <param name="secondsSinceServerTick">Time passed</param>
+    /// <param name="totalProductionTime">Total time collecting water</param>
+    /// <param name="productionProgress">How far water collector has progressed</param>
+    /// <param name="baseFilterDrainRate">Base drain rate</param>
+    /// <returns>Drain rate (adjusted)</returns>
+    protected double GetTimeAdjustedWaterFilterDrainRate(
+        double secondsSinceServerTick,
+        double totalProductionTime,
+        double productionProgress,
+        double baseFilterDrainRate)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the water filter drain rate based on hideout bonuses player has
+    /// </summary>
+    /// <param name="playerProfile">Player profile</param>
+    /// <returns>Drain rate</returns>
+    protected double GetWaterFilterDrainRate(PmcData playerProfile)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the production time in seconds for the desired production
+    /// </summary>
+    /// <param name="prodId">Id, e.g. Water collector id</param>
+    /// <returns>Seconds to produce item</returns>
+    protected double GetTotalProductionTimeSeconds(string prodId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Create a upd object using passed in parameters
+    /// </summary>
+    /// <param name="stackCount"></param>
+    /// <param name="resourceValue"></param>
+    /// <param name="resourceUnitsConsumed"></param>
+    /// <returns>Upd</returns>
+    protected Upd GetAreaUpdObject(
+        int stackCount,
+        double resourceValue,
+        int resourceUnitsConsumed,
+        bool isFoundInRaid)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void UpdateAirFilters(BotHideoutArea airFilterArea, PmcData playerProfile, bool isGeneratorOn)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected void UpdateBitcoinFarm(
+        PmcData playerProfile,
+        Productive btcProduction,
+        int btcFarmCGs,
+        bool isGeneratorOn)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add bitcoin object to btc production products array and set progress time
+    /// </summary>
+    /// <param name="btcProd">Bitcoin production object</param>
+    /// <param name="coinCraftTimeSeconds">Time to craft a bitcoin</param>
+    protected void AddBtcToProduction(Production btcProd, double coinCraftTimeSeconds)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get number of ticks that have passed since hideout areas were last processed, reduced when generator is off
+    /// </summary>
+    /// <param name="playerProfile">Player profile</param>
+    /// <param name="isGeneratorOn">Is the generator on for the duration of elapsed time</param>
+    /// <param name="recipe">Hideout production recipe being crafted we need the ticks for</param>
+    /// <returns>Amount of time elapsed in seconds</returns>
+    protected double GetTimeElapsedSinceLastServerTick(
+        PmcData playerProfile,
+        bool isGeneratorOn,
+        HideoutProduction recipe = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a count of how many possible BTC can be gathered by the profile
+    /// </summary>
+    /// <param name="profileData">Profile to look up</param>
+    /// <returns>Coin slot count</returns>
+    protected int GetBTCSlots(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a count of how many additional bitcoins player hideout can hold with elite skill
+    /// </summary>
+    protected int GetEliteSkillAdditionalBitcoinSlotCount()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// HideoutManagement skill gives a consumption bonus the higher the level
+    /// 0.5% per level per 1-51, (25.5% at max)
+    /// </summary>
+    /// <param name="profileData">Profile to get hideout consumption level from</param>
+    /// <returns>Consumption bonus</returns>
+    protected double GetHideoutManagementConsumptionBonus(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a multiplier based on player's skill level and value per level
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    /// <param name="skill">Player skill from profile</param>
+    /// <param name="valuePerLevel">Value from globals.config.SkillsSettings - `PerLevel`</param>
+    /// <returns>Multiplier from 0 to 1</returns>
+    protected double GetSkillBonusMultipliedBySkillLevel(PmcData profileData, SkillTypes skill, double valuePerLevel)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    /// <param name="productionTime">Time to complete hideout craft in seconds</param>
+    /// <param name="skill">Skill bonus to get reduction from</param>
+    /// <param name="amountPerLevel">Skill bonus amount to apply</param>
+    /// <returns>Seconds to reduce craft time by</returns>
+    public double GetSkillProductionTimeReduction(
+        PmcData profileData,
+        double productionTime,
+        SkillTypes skill,
+        double amountPerLevel)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool IsProduction(Productive productive)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Gather crafted BTC from hideout area and add to inventory
+    /// Reset production start timestamp if hideout area at full coin capacity
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    /// <param name="request">Take production request</param>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="output">Output object to update</param>
+    public void GetBTC(
+        PmcData profileData,
+        HideoutTakeProductionRequestData request,
+        string sessionId,
+        ItemEventRouterResponse output)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Upgrade hideout wall from starting level to interactable level if necessary stations have been upgraded
+    /// </summary>
+    /// <param name="profileData">Profile to upgrade wall in</param>
+    public void UnlockHideoutWallInProfile(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Hideout improvement is flagged as complete
+    /// </summary>
+    /// <param name="improvement">hideout improvement object</param>
+    /// <returns>true if complete</returns>
+    protected bool HideoutImprovementIsComplete(HideoutImprovement improvement)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Iterate over hideout improvements not completed and check if they need to be adjusted
+    /// </summary>
+    /// <param name="profileData">Profile to adjust</param>
+    public void SetHideoutImprovementsToCompleted(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add/remove bonus combat skill based on number of dogtags in place of fame hideout area
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    public void ApplyPlaceOfFameDogtagBonus(PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Calculate the raw dogtag combat skill bonus for place of fame based on number of dogtags
+    /// Reverse engineered from client code
+    /// </summary>
+    /// <param name="profileData">Player profile</param>
+    /// <param name="activeDogtags">Active dogtags in place of fame dogtag slots</param>
+    /// <returns>Combat bonus</returns>
+    protected double GetDogtagCombatSkillBonusPercent(PmcData profileData, List<Item> activeDogtags)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// The wall pollutes a profile with various temp buffs/debuffs,
+    /// Remove them all
+    /// </summary>
+    /// <param name="wallAreaData">Hideout area data</param>
+    /// <param name="profileData">Player profile</param>
+    public void RemoveHideoutWallBuffsAndDebuffs(HideoutArea wallAreaData, PmcData profileData)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/HttpServerHelper.cs

@@ -2,5 +2,39 @@
 
 public class HttpServerHelper
 {
+    public string GetMimeText(string key)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Combine ip and port into address
+    /// </summary>
+    /// <returns>url</returns>
+    public string BuildUrl()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Prepend http to the url:port
+    /// </summary>
+    /// <returns>URI</returns>
+    public string GetBackendUrl()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get websocket url + port
+    /// </summary>
+    public string GetWebsocketUrl()
+    {
+        throw new NotImplementedException();
+    }
+
+    public void SendTextJson(object resp, object output)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/InRaidHelper.cs

@@ -1,6 +1,102 @@
-namespace Core.Helpers;
+using Core.Models.Eft.Common;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Helpers;
 
 public class InRaidHelper
 {
+    /// <summary>
+    /// Deprecated. Reset the skill points earned in a raid to 0, ready for next raid.
+    /// </summary>
+    /// <param name="profile">Profile to update</param>
+    protected void ResetSkillPointsEarnedDuringRaid(PmcData profile)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Update a player's inventory post-raid.
+    /// Remove equipped items from pre-raid.
+    /// Add new items found in raid to profile.
+    /// Store insurance items in profile.
+    /// </summary>
+    /// <param name="sessionID">Session id</param>
+    /// <param name="serverProfile">Profile to update</param>
+    /// <param name="postRaidProfile">Profile returned by client after a raid</param>
+    /// <param name="isSurvived">Indicates if the player survived the raid</param>
+    /// <param name="isTransfer">Indicates if it is a transfer operation</param>
+    public void SetInventory(
+        string sessionID,
+        PmcData serverProfile,
+        PmcData postRaidProfile,
+        bool isSurvived,
+        bool isTransfer)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Remove FiR status from items.
+    /// </summary>
+    /// <param name="items">Items to process</param>
+    protected void RemoveFiRStatusFromCertainItems(List<Item> items)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Add items from one parameter into another.
+    /// </summary>
+    /// <param name="itemsToAdd">Items we want to add</param>
+    /// <param name="serverInventoryItems">Location to add items to</param>
+    protected void AddItemsToInventory(List<Item> itemsToAdd, List<Item> serverInventoryItems)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Clear PMC inventory of all items except those that are exempt.
+    /// Used post-raid to remove items after death.
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="sessionId">Session id</param>
+    public void DeleteInventory(PmcData pmcData, string sessionId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Remove FiR status from designated container.
+    /// </summary>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="secureContainerSlotId">Container slot id to find items for and remove FiR from</param>
+    public void RemoveFiRStatusFromItemsInContainer(
+        string sessionId,
+        PmcData pmcData,
+        string secureContainerSlotId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a list of items from a profile that will be lost on death.
+    /// </summary>
+    /// <param name="pmcProfile">Profile to get items from</param>
+    /// <returns>List of items lost on death</returns>
+    protected List<Item> GetInventoryItemsLostOnDeath(PmcData pmcProfile)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Does the provided item's slotId mean it's kept on the player after death?
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="itemToCheck">Item to check should be kept</param>
+    /// <returns>true if item is kept after death</returns>
+    protected bool IsItemKeptAfterDeath(PmcData pmcData, Item itemToCheck)
+    {
+        throw new NotImplementedException();
+    }
 }

Core/Helpers/InventoryHelper.cs

@@ -1,6 +1,399 @@
-namespace Core.Helpers;
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common;
+using Core.Models.Eft.Common.Tables;
+using Core.Models.Eft.Inventory;
+using Core.Models.Eft.ItemEvent;
+using Core.Models.Spt.Config;
+using Core.Models.Spt.Inventory;
+
+namespace Core.Helpers;
 
 public class InventoryHelper
 {
+    /// <summary>
+    /// Add multiple items to player stash (assuming they all fit)
+    /// </summary>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="request">AddItemsDirectRequest request</param>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="output">Client response object</param>
+    public void AddItemsToStash(
+        string sessionId,
+        AddItemsDirectRequest request,
+        PmcData pmcData,
+        ItemEventRouterResponse output)
+    {
+        throw new NotImplementedException();
+    }
 
+    /// <summary>
+    /// Add whatever is passed in request.itemWithModsToAdd into player inventory (if it fits)
+    /// </summary>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="request">AddItemDirect request</param>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="output">Client response object</param>
+    public void AddItemToStash(
+        string sessionId,
+        AddItemDirectRequest request,
+        PmcData pmcData,
+        ItemEventRouterResponse output)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Set FiR status for an item + its children
+    /// </summary>
+    /// <param name="itemWithChildren">An item</param>
+    /// <param name="foundInRaid">Item was found in raid</param>
+    protected void SetFindInRaidStatusForItem(Item[] itemWithChildren, bool foundInRaid)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Remove properties from a Upd object used by a trader/ragfair that are unnecessary to a player
+    /// </summary>
+    /// <param name="upd">Object to update</param>
+    protected void RemoveTraderRagfairRelatedUpdProperties(Upd upd)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Can all provided items be added into player inventory
+    /// </summary>
+    /// <param name="sessionId">Player id</param>
+    /// <param name="itemsWithChildren">Array of items with children to try and fit</param>
+    /// <returns>True all items fit</returns>
+    public bool CanPlaceItemsInInventory(string sessionId, Item[][] itemsWithChildren)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Do the provided items all fit into the grid
+    /// </summary>
+    /// <param name="containerFS2D">Container grid to fit items into</param>
+    /// <param name="itemsWithChildren">Items to try and fit into grid</param>
+    /// <returns>True all fit</returns>
+    public bool CanPlaceItemsInContainer(int[][] containerFS2D, Item[][] itemsWithChildren)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Does an item fit into a container grid
+    /// </summary>
+    /// <param name="containerFS2D">Container grid</param>
+    /// <param name="itemWithChildren">Item to check fits</param>
+    /// <returns>True it fits</returns>
+    public bool CanPlaceItemInContainer(int[][] containerFS2D, Item[] itemWithChildren)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Find a free location inside a container to fit the item
+    /// </summary>
+    /// <param name="containerFS2D">Container grid to add item to</param>
+    /// <param name="itemWithChildren">Item to add to grid</param>
+    /// <param name="containerId">Id of the container we're fitting item into</param>
+    /// <param name="desiredSlotId">Slot id value to use, default is "hideout"</param>
+    public void PlaceItemInContainer(
+        int[][] containerFS2D,
+        Item[] itemWithChildren,
+        string containerId,
+        string desiredSlotId = "hideout")
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Find a location to place an item into inventory and place it
+    /// </summary>
+    /// <param name="stashFS2D">2-dimensional representation of the container slots</param>
+    /// <param name="sortingTableFS2D">2-dimensional representation of the sorting table slots</param>
+    /// <param name="itemWithChildren">Item to place with children</param>
+    /// <param name="playerInventory">Players inventory</param>
+    /// <param name="useSortingTable">Should sorting table to be used if main stash has no space</param>
+    /// <param name="output">Output to send back to client</param>
+    protected void PlaceItemInInventory(
+        int[][] stashFS2D,
+        int[][] sortingTableFS2D,
+        Item[] itemWithChildren,
+        BotBaseInventory playerInventory,
+        bool useSortingTable,
+        ItemEventRouterResponse output)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Handle Remove event
+    /// Remove item from player inventory + insured items array
+    /// Also deletes child items
+    /// </summary>
+    /// <param name="profile">Profile to remove item from (pmc or scav)</param>
+    /// <param name="itemId">Items id to remove</param>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="output">OPTIONAL - ItemEventRouterResponse</param>
+    public void RemoveItem(PmcData profile, string itemId, string sessionId, ItemEventRouterResponse output = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Delete desired item from a player profiles mail
+    /// </summary>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="removeRequest">Remove request</param>
+    /// <param name="output">OPTIONAL - ItemEventRouterResponse</param>
+    public void RemoveItemAndChildrenFromMailRewards(string sessionId, InventoryRemoveRequestData removeRequest, ItemEventRouterResponse output = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Find item by id in player inventory and remove x of its count
+    /// </summary>
+    /// <param name="pmcData">player profile</param>
+    /// <param name="itemId">Item id to decrement StackObjectsCount of</param>
+    /// <param name="countToRemove">Number of item to remove</param>
+    /// <param name="sessionId">Session id</param>
+    /// <param name="output">ItemEventRouterResponse</param>
+    /// <returns>ItemEventRouterResponse</returns>
+    public ItemEventRouterResponse RemoveItemByCount(PmcData pmcData, string itemId, int countToRemove, string sessionId, ItemEventRouterResponse output = null)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the height and width of an item - can have children that alter size
+    /// </summary>
+    /// <param name="itemTpl">Item to get size of</param>
+    /// <param name="itemId">Items id to get size of</param>
+    /// <param name="inventoryItems"></param>
+    /// <returns>[width, height]</returns>
+    public List<int> GetItemSize(string itemTpl, string itemId, List<Item> inventoryItems)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Calculates the size of an item including attachments
+    /// takes into account if item is folded
+    /// </summary>
+    /// <param name="itemTpl">Items template id</param>
+    /// <param name="itemId">Items id</param>
+    /// <param name="inventoryItemHash">Hashmap of inventory items</param>
+    /// <returns>An array representing the [width, height] of the item</returns>
+    protected List<int> GetSizeByInventoryItemHash(string itemTpl, string itemId, InventoryItemHash inventoryItemHash)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a blank two-dimensional representation of a container
+    /// </summary>
+    /// <param name="containerH">Horizontal size of container</param>
+    /// <param name="containerY">Vertical size of container</param>
+    /// <returns>Two-dimensional representation of container</returns>
+    protected List<List<int>> GetBlankContainerMap(int containerH, int containerY)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a 2d mapping of a container with what grid slots are filled
+    /// </summary>
+    /// <param name="containerH">Horizontal size of container</param>
+    /// <param name="containerV">Vertical size of container</param>
+    /// <param name="itemList">Players inventory items</param>
+    /// <param name="containerId">Id of the container</param>
+    /// <returns>Two-dimensional representation of container</returns>
+    public List<List<int>> GetContainerMap(int containerH, int containerV, List<Item> itemList, string containerId)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected bool IsVertical(ItemLocation itemLocation)
+    {
+        throw new NotImplementedException();
+    }
+
+    protected InventoryItemHash GetInventoryItemHash(List<Item> inventoryItems)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Return the inventory that needs to be modified (scav/pmc etc)
+    /// Changes made to result apply to character inventory
+    /// Based on the item action, determine whose inventories we should be looking at for from and to.
+    /// </summary>
+    /// <param name="request">Item interaction request</param>
+    /// <param name="sessionId">Session id / playerid</param>
+    /// <returns>OwnerInventoryItems with inventory of player/scav to adjust</returns>
+    public OwnerInventoryItems GetOwnerInventoryItems(
+        InventoryMoveRequestData request,
+        string sessionId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a two dimensional array to represent stash slots
+    /// 0 value = free, 1 = taken
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="sessionID">session id</param>
+    /// <returns>2-dimensional array</returns>
+    protected int[,] GetStashSlotMap(PmcData pmcData, string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a blank two-dimensional array representation of a container
+    /// </summary>
+    /// <param name="containerTpl">Container to get data for</param>
+    /// <returns>blank two-dimensional array</returns>
+    public int[,] GetContainerSlotMap(string containerTpl)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get a two-dimensional array representation of the players sorting table
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <returns>two-dimensional array</returns>
+    protected int[,] GetSortingTableSlotMap(PmcData pmcData)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get Players Stash Size
+    /// </summary>
+    /// <param name="sessionID">Players id</param>
+    /// <returns>Dictionary of 2 values, horizontal and vertical stash size</returns>
+    protected Dictionary<int, int> GetPlayerStashSize(string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get the players stash items tpl
+    /// </summary>
+    /// <param name="sessionID">Player id</param>
+    /// <returns>Stash tpl</returns>
+    protected string GetStashType(string sessionID)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Internal helper function to transfer an item + children from one profile to another.
+    /// </summary>
+    /// <param name="sourceItems">Inventory of the source (can be non-player)</param>
+    /// <param name="toItems">Inventory of the destination</param>
+    /// <param name="request">Move request</param>
+    public void MoveItemToProfile(Item[] sourceItems, Item[] toItems, InventoryMoveRequestData request)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Internal helper function to move item within the same profile.
+    /// </summary>
+    /// <param name="pmcData">profile to edit</param>
+    /// <param name="inventoryItems"></param>
+    /// <param name="moveRequest">client move request</param>
+    /// <returns>True if move was successful</returns>
+    public (bool success, string errorMessage) MoveItemInternal(
+        PmcData pmcData,
+        Item[] inventoryItems,
+        InventoryMoveRequestData moveRequest)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Update fast panel bindings when an item is moved into a container that doesn't allow quick slot access
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="itemBeingMoved">item being moved</param>
+    protected void UpdateFastPanelBinding(PmcData pmcData, Item itemBeingMoved)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Internal helper function to handle cartridges in inventory if any of them exist.
+    /// </summary>
+    protected void HandleCartridges(Item[] items, InventoryMoveRequestData request)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get details for how a random loot container should be handled, max rewards, possible reward tpls
+    /// </summary>
+    /// <param name="itemTpl">Container being opened</param>
+    /// <returns>Reward details</returns>
+    public RewardDetails GetRandomLootContainerRewardDetails(string itemTpl)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Get inventory configuration
+    /// </summary>
+    /// <returns>Inventory configuration</returns>
+    public InventoryConfig GetInventoryConfig()
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Recursively checks if the given item is
+    /// inside the stash, that is it has the stash as
+    /// ancestor with slotId=hideout
+    /// </summary>
+    /// <param name="pmcData">Player profile</param>
+    /// <param name="itemToCheck">Item to look for</param>
+    /// <returns>True if item exists inside stash</returns>
+    public bool IsItemInStash(PmcData pmcData, Item itemToCheck)
+    {
+        throw new NotImplementedException();
+    }
+
+    public void ValidateInventoryUsesMongoIds(List<Item> itemsToValidate)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// Does the provided item have a root item with the provided id
+    /// </summary>
+    /// <param name="pmcData">Profile with items</param>
+    /// <param name="item">Item to check</param>
+    /// <param name="rootId">Root item id to check for</param>
+    /// <returns>True when item has rootId, false when not</returns>
+    public bool DoesItemHaveRootId(PmcData pmcData, Item item, string rootId)
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class InventoryItemHash
+{
+    [JsonPropertyName("byItemId")]
+    public Dictionary<string, Item> ByItemId { get; set; }
+
+    [JsonPropertyName("byParentId")]
+    public Dictionary<string, List<Item>> ByParentId { get; set; }
 }

Core/Models/Eft/Common/MetricsTableData.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Common;
+
+public class MetricsTableData
+{
+    [JsonPropertyName("Keys")]
+    public List<int>? Keys { get; set; }
+
+    [JsonPropertyName("NetProcessingBins")]
+    public List<int>? NetProcessingBins { get; set; }
+
+    [JsonPropertyName("RenderBins")]
+    public List<int>? RenderBins { get; set; }
+
+    [JsonPropertyName("GameUpdateBins")]
+    public List<int>? GameUpdateBins { get; set; }
+
+    [JsonPropertyName("MemoryMeasureInterval")]
+    public int? MemoryMeasureInterval { get; set; }
+}

Core/Models/Eft/Health/SyncHealthRequestData.cs

@@ -0,0 +1,57 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Health;
+
+public class SyncHealthRequestData
+{
+    [JsonPropertyName("Health")]
+    public List<BodyPartHealth>? Health { get; set; }
+
+    [JsonPropertyName("IsAlive")]
+    public bool? IsAlive { get; set; }
+
+    [JsonPropertyName("Hydration")]
+    public double? Hydration { get; set; }
+
+    [JsonPropertyName("Energy")]
+    public double? Energy { get; set; }
+
+    [JsonPropertyName("Temperature")]
+    public double? Temperature { get; set; }
+}
+
+public class BodyPartCollection
+{
+    [JsonPropertyName("Head")]
+    public BodyPartHealth? Head { get; set; }
+
+    [JsonPropertyName("Chest")]
+    public BodyPartHealth? Chest { get; set; }
+
+    [JsonPropertyName("Stomach")]
+    public BodyPartHealth? Stomach { get; set; }
+
+    [JsonPropertyName("LeftArm")]
+    public BodyPartHealth? LeftArm { get; set; }
+
+    [JsonPropertyName("RightArm")]
+    public BodyPartHealth? RightArm { get; set; }
+
+    [JsonPropertyName("LeftLeg")]
+    public BodyPartHealth? LeftLeg { get; set; }
+
+    [JsonPropertyName("RightLeg")]
+    public BodyPartHealth? RightLeg { get; set; }
+}
+
+public class BodyPartHealth
+{
+    [JsonPropertyName("Maximum")]
+    public int? Maximum { get; set; }
+
+    [JsonPropertyName("Current")]
+    public int? Current { get; set; }
+
+    [JsonPropertyName("Effects")]
+    public Dictionary<string, int>? Effects { get; set; }
+}

Core/Models/Eft/InRaid/InsuredItemsData.cs

@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.InRaid;
+
+public class InsuredItemsData
+{
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    [JsonPropertyName("durability")]
+    public int? Durability { get; set; }
+
+    [JsonPropertyName("maxDurability")]
+    public int? MaxDurability { get; set; }
+
+    [JsonPropertyName("hits")]
+    public int? Hits { get; set; }
+
+    [JsonPropertyName("usedInQuest")]
+    public bool? UsedInQuest { get; set; }
+}

Core/Models/Eft/InRaid/ItemDeliveryRequestData.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Eft.InRaid;
+
+public class ItemDeliveryRequestData
+{
+    [JsonPropertyName("items")]
+    public List<Item>? Items { get; set; }
+
+    [JsonPropertyName("traderId")]
+    public string? TraderId { get; set; }
+}

Core/Models/Eft/Inventory/AddItemDirectRequest.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Eft.Inventory;
+
+public class AddItemDirectRequest
+{
+    /// <summary>
+    /// Item and child mods to add to player inventory
+    /// </summary>
+    [JsonPropertyName("itemWithModsToAdd")]
+    public List<Item>? ItemWithModsToAdd { get; set; }
+
+    [JsonPropertyName("foundInRaid")]
+    public bool? FoundInRaid { get; set; }
+
+    [JsonPropertyName("callback")]
+    public Action<int>? Callback { get; set; }
+
+    [JsonPropertyName("useSortingTable")]
+    public bool? UseSortingTable { get; set; }
+}

Core/Models/Eft/Inventory/AddItemRequestData.cs

@@ -0,0 +1,25 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Inventory;
+
+public class AddItemRequestData
+{
+    // Trader id
+    [JsonPropertyName("tid")]
+    public string? TraderId { get; set; }
+
+    [JsonPropertyName("items")]
+    public List<ItemToAdd>? Items { get; set; }
+}
+
+public class ItemToAdd
+{
+    [JsonPropertyName("count")]
+    public int? Count { get; set; }
+
+    [JsonPropertyName("sptIsPreset")]
+    public bool? IsPreset { get; set; }
+
+    [JsonPropertyName("item_id")]
+    public string? ItemId { get; set; }
+}

Core/Models/Eft/Inventory/AddItemTempObject.cs

@@ -0,0 +1,23 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Eft.Inventory;
+
+public class AddItemTempObject
+{
+    [JsonPropertyName("itemRef")]
+    public Item? ItemReference { get; set; }
+
+    [JsonPropertyName("count")]
+    public int? ItemCount { get; set; }
+
+    [JsonPropertyName("isPreset")]
+    public bool? IsPresetItem { get; set; }
+
+    [JsonPropertyName("location")]
+    public ItemLocation? ItemLocation { get; set; }
+
+    // Container item will be placed in - stash or sorting table
+    [JsonPropertyName("containerId")]
+    public string? ContainerIdentifier { get; set; }
+}

Core/Models/Eft/Inventory/AddItemsDirectRequest.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+using Core.Models.Eft.Common.Tables;
+
+namespace Core.Models.Eft.Inventory;
+
+public class AddItemsDirectRequest
+{
+    /// Item and child mods to add to player inventory
+    [JsonPropertyName("itemsWithModsToAdd")]
+    public List<List<Item>>? ItemsWithModsToAdd { get; set; }
+
+    [JsonPropertyName("foundInRaid")]
+    public bool? FoundInRaid { get; set; }
+
+    /// Runs after EACH item with children is added
+    [JsonPropertyName("callback")]
+    public Action<int>? Callback { get; set; }
+
+    /// Should sorting table be used when no space found in stash
+    [JsonPropertyName("useSortingTable")]
+    public bool? UseSortingTable { get; set; }
+}

Core/Models/Eft/Inventory/InventoryAddRequestData.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Inventory;
+
+public class InventoryAddRequestData : InventoryBaseActionRequestData
+{
+    [JsonPropertyName("Action")]
+    public string? Action { get; set; } = "Add";
+
+    [JsonPropertyName("item")]
+    public string? Item { get; set; }
+
+    [JsonPropertyName("container")]
+    public Container? Container { get; set; }
+}

Core/Models/Eft/Inventory/InventoryUnbindRequestData.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Inventory;
+
+public class InventoryUnbindRequestData : InventoryBaseActionRequestData
+{
+    [JsonPropertyName("Action")]
+    public string? Action { get; set; } = "Unbind";
+
+    [JsonPropertyName("item")]
+    public string? Item { get; set; }
+
+    [JsonPropertyName("index")]
+    public int? Index { get; set; }
+}

Core/Models/Eft/Launcher/MiniProfile.cs

@@ -0,0 +1,39 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Launcher;
+
+public class MiniProfile
+{
+    [JsonPropertyName("username")]
+    public string? Username { get; set; }
+
+    [JsonPropertyName("nickname")]
+    public string? Nickname { get; set; }
+
+    [JsonPropertyName("side")]
+    public string? Side { get; set; }
+
+    [JsonPropertyName("currlvl")]
+    public int? CurrentLevel { get; set; }
+
+    [JsonPropertyName("currexp")]
+    public int? CurrentExperience { get; set; }
+
+    [JsonPropertyName("prevexp")]
+    public int? PreviousExperience { get; set; }
+
+    [JsonPropertyName("nextlvl")]
+    public int? NextLevel { get; set; }
+
+    [JsonPropertyName("maxlvl")]
+    public int? MaxLevel { get; set; }
+
+    [JsonPropertyName("edition")]
+    public string? Edition { get; set; }
+
+    [JsonPropertyName("profileId")]
+    public string? ProfileId { get; set; }
+
+    [JsonPropertyName("sptData")]
+    public Profile.Spt? SptData { get; set; }
+}

Core/Models/Eft/Location/AirdropLootResult.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+using Core.Models.Spt.Services;
+
+namespace Core.Models.Eft.Location;
+
+public class AirdropLootResult
+{
+    [JsonPropertyName("dropType")]
+    public string? DropType { get; set; }
+
+    [JsonPropertyName("loot")]
+    public List<LootItem>? Loot { get; set; }
+}

Core/Models/Eft/Location/GetLocationRequestData.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Location;
+
+public class GetLocationRequestData
+{
+    [JsonPropertyName("crc")]
+    public int? Crc { get; set; }
+
+    [JsonPropertyName("locationId")]
+    public string? LocationId { get; set; }
+
+    [JsonPropertyName("variantId")]
+    public int? VariantId { get; set; }
+}

Core/Models/Eft/Match/EndOfflineRaidRequestData.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Match;
+
+public class EndOfflineRaidRequestData
+{
+    [JsonPropertyName("crc")]
+    public int? Crc { get; set; }
+
+    [JsonPropertyName("exitStatus")]
+    public string? ExitStatus { get; set; }
+
+    [JsonPropertyName("exitName")]
+    public string? ExitName { get; set; }
+
+    [JsonPropertyName("raidSeconds")]
+    public int? RaidSeconds { get; set; }
+}

Core/Models/Eft/Match/ProfileStatusRequest.cs

@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Match;
+
+public class ProfileStatusRequest
+{
+    [JsonPropertyName("groupId")]
+    public int? GroupId { get; set; }
+}

Core/Models/Eft/Match/UpdatePingRequestData.cs

@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Match;
+
+public class UpdatePingRequestData
+{
+    [JsonPropertyName("servers")]
+    public List<object>? servers { get; set; }
+}

Core/Models/Eft/Profile/MessageContentRagfair.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace Core.Models.Eft.Profile;
+
+public class MessageContentRagfair
+{
+    [JsonPropertyName("offerId")]
+    public string? OfferId { get; set; }
+
+    [JsonPropertyName("count")]
+    public int? Count { get; set; }
+
+    [JsonPropertyName("handbookId")]
+    public string? HandbookId { get; set; }
+}

Core/Models/Eft/Profile/SptProfile.cs

@@ -548,15 +548,3 @@ public class Insurance
     [JsonPropertyName("items")]
     public List<Item>? Items { get; set; }
 }
-
-public class MessageContentRagfair
-{
-    [JsonPropertyName("offerId")]
-    public string? OfferId { get; set; }
-
-    [JsonPropertyName("count")]
-    public int? Count { get; set; }
-
-    [JsonPropertyName("handbookId")]
-    public string? HandbookId { get; set; }
-}