Update types

TypeScript/10ScopesAndTypes/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/10ScopesAndTypes/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/10ScopesAndTypes/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/10ScopesAndTypes/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/10ScopesAndTypes/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/10ScopesAndTypes/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/11BundleLoadingSample/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/11BundleLoadingSample/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/11BundleLoadingSample/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/11BundleLoadingSample/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/11BundleLoadingSample/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/11BundleLoadingSample/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/12ClassExtensionOverride/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/12ClassExtensionOverride/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/12ClassExtensionOverride/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/12ClassExtensionOverride/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/12ClassExtensionOverride/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/12ClassExtensionOverride/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/13AddTrader/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/13AddTrader/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/13AddTrader/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/13AddTrader/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/13AddTrader/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/13AddTrader/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/14AfterDBLoadHook/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/14AfterDBLoadHook/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/14AfterDBLoadHook/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/14AfterDBLoadHook/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/14AfterDBLoadHook/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/14AfterDBLoadHook/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/15HttpListenerExample/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/15HttpListenerExample/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/15HttpListenerExample/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/15HttpListenerExample/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/15HttpListenerExample/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/15HttpListenerExample/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/16ImporterUtil/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/16ImporterUtil/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/16ImporterUtil/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/16ImporterUtil/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/16ImporterUtil/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/16ImporterUtil/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/17AsyncImporterWithDependency1/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/17AsyncImporterWithDependency1/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/17AsyncImporterWithDependency1/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/17AsyncImporterWithDependency1/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/17AsyncImporterWithDependency1/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/17AsyncImporterWithDependency1/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/17AsyncImporterWithDependency2/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/17AsyncImporterWithDependency2/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/17AsyncImporterWithDependency2/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/17AsyncImporterWithDependency2/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/17AsyncImporterWithDependency2/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/17AsyncImporterWithDependency2/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/18CustomItemService/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/18CustomItemService/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/18CustomItemService/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/18CustomItemService/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/18CustomItemService/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/18CustomItemService/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/1LogToConsole/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/1LogToConsole/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/1LogToConsole/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/1LogToConsole/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/1LogToConsole/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/1LogToConsole/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/2EditDatabase/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/2EditDatabase/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/2EditDatabase/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/2EditDatabase/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/2EditDatabase/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/2EditDatabase/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/3GetSptConfigFile/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/3GetSptConfigFile/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/3GetSptConfigFile/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/3GetSptConfigFile/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/3GetSptConfigFile/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/3GetSptConfigFile/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/4UseACustomConfigFile/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/4UseACustomConfigFile/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/4UseACustomConfigFile/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/4UseACustomConfigFile/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/4UseACustomConfigFile/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/4UseACustomConfigFile/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/5ReplaceMethod/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/5ReplaceMethod/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/5ReplaceMethod/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/5ReplaceMethod/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/5ReplaceMethod/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/5ReplaceMethod/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/6ReferenceAnotherClass/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/6ReferenceAnotherClass/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/6ReferenceAnotherClass/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/6ReferenceAnotherClass/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }

TypeScript/6ReferenceAnotherClass/types/models/spt/config/IRagfairConfig.d.ts

@@ -71,13 +71,8 @@ export interface Dynamic {
     removeSeasonalItemsWhenNotInEvent: boolean;
     /** Flea blacklist settings */
     blacklist: Blacklist;
-    /** Should prices over the multiplier be adjusted */
+    /** Dict of price limits keyed by item type */
-    unreasonableModPrices: IUnreasonableModPrices;
+    unreasonableModPrices: Record<string, IUnreasonableModPrices>;
-}
-export interface IUnreasonableModPrices {
-    enabled: boolean;
-    handbookPriceOverMultiplier: number;
-    newPriceHandbookMultiplier: number;
 }
 export interface Barter {
     /** Should barter offers be generated */
@@ -121,3 +116,8 @@ export interface Blacklist {
     /** Should trader items that are blacklisted by bsg */
     traderItems: boolean;
 }
+export interface IUnreasonableModPrices {
+    enabled: boolean;
+    handbookPriceOverMultiplier: number;
+    newPriceHandbookMultiplier: number;
+}

TypeScript/6ReferenceAnotherClass/types/services/InsuranceService.d.ts

@@ -6,14 +6,15 @@ import { NotificationSendHelper } from "../helpers/NotificationSendHelper";
 import { SecureContainerHelper } from "../helpers/SecureContainerHelper";
 import { TraderHelper } from "../helpers/TraderHelper";
 import { IPmcData } from "../models/eft/common/IPmcData";
-import { InsuredItem } from "../models/eft/common/tables/IBotBase";
 import { Item } from "../models/eft/common/tables/IItem";
+import { IInsuredItemsData } from "../models/eft/inRaid/IInsuredItemsData";
 import { ISaveProgressRequestData } from "../models/eft/inRaid/ISaveProgressRequestData";
 import { IInsuranceConfig } from "../models/spt/config/IInsuranceConfig";
 import { ILogger } from "../models/spt/utils/ILogger";
 import { ConfigServer } from "../servers/ConfigServer";
 import { DatabaseServer } from "../servers/DatabaseServer";
 import { SaveServer } from "../servers/SaveServer";
+import { JsonUtil } from "../utils/JsonUtil";
 import { RandomUtil } from "../utils/RandomUtil";
 import { TimeUtil } from "../utils/TimeUtil";
 import { LocaleService } from "./LocaleService";
@@ -24,6 +25,7 @@ export declare class InsuranceService {
     protected secureContainerHelper: SecureContainerHelper;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
     protected traderHelper: TraderHelper;
@@ -35,7 +37,12 @@ export declare class InsuranceService {
     protected configServer: ConfigServer;
     protected insured: Record<string, Record<string, Item[]>>;
     protected insuranceConfig: IInsuranceConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, secureContainerHelper: SecureContainerHelper, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, timeUtil: TimeUtil, saveServer: SaveServer, traderHelper: TraderHelper, dialogueHelper: DialogueHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, localeService: LocaleService, notificationSendHelper: NotificationSendHelper, configServer: ConfigServer);
+    /**
+     * Does player have insurance array
+     * @param sessionId Player id
+     * @returns True if exists
+     */
     insuranceExists(sessionId: string): boolean;
     /**
      * Get all insured items by all traders for a profile
@@ -78,7 +85,7 @@ export declare class InsuranceService {
      */
     protected getInsuranceReturnTimestamp(pmcData: IPmcData, trader: ITraderBase): number;
     /**
-     * Store lost gear post-raid inside profile
+     * Store lost gear post-raid inside profile, ready for later code to pick it up and mail it
      * @param pmcData player profile to store gear in
      * @param offraidData post-raid request object
      * @param preRaidGear gear player wore prior to raid
@@ -86,6 +93,21 @@ export declare class InsuranceService {
      * @param playerDied did the player die in raid
      */
     storeLostGear(pmcData: IPmcData, offraidData: ISaveProgressRequestData, preRaidGear: Item[], sessionID: string, playerDied: boolean): void;
+    /**
+     * Take preraid item and update properties to ensure its ready to be given to player in insurance return mail
+     * @param pmcData Player profile
+     * @param insuredItem Insured items properties
+     * @param preRaidItem Insured item as it was pre-raid
+     * @param insuredItemFromClient Item data when player left raid (durability values)
+     * @returns Item object
+     */
+    protected getInsuredItemDetails(pmcData: IPmcData, preRaidItem: Item, insuredItemFromClient: IInsuredItemsData): Item;
+    /**
+     * Reset slotId property to "hideout" when necessary (used to be in )
+     * @param pmcData Players pmcData.Inventory.equipment value
+     * @param itemToReturn item we will send to player as insurance return
+     */
+    protected updateSlotIdValue(playerBaseInventoryEquipmentId: string, itemToReturn: Item): void;
     /**
      * Create a hash table for an array of items, keyed by items _id
      * @param items Items to hash
@@ -94,12 +116,17 @@ export declare class InsuranceService {
     protected createItemHashTable(items: Item[]): Record<string, Item>;
     /**
      * Add gear item to InsuredItems array in player profile
-     * @param pmcData profile to store item in
-     * @param insuredItem Item to store in profile
-     * @param actualItem item to store
      * @param sessionID Session id
+     * @param pmcData Player profile
+     * @param itemToReturnToPlayer item to store
+     * @param traderId Id of trader item was insured with
      */
-    protected addGearToSend(pmcData: IPmcData, insuredItem: InsuredItem, actualItem: Item, sessionID: string): void;
+    protected addGearToSend(gear: {
+        sessionID: string;
+        pmcData: IPmcData;
+        itemToReturnToPlayer: Item;
+        traderId: string;
+    }): void;
     /**
      * Does insurance exist for a player and by trader
      * @param sessionId Player id (session id)

TypeScript/7OnLoadHook/types/models/eft/common/tables/IBotBase.d.ts

@@ -267,6 +267,7 @@ export interface BackendCounter {
     value: number;
 }
 export interface InsuredItem {
+    /** Trader Id item was insured by */
     tid: string;
     itemId: string;
 }

TypeScript/7OnLoadHook/types/models/eft/common/tables/IItem.d.ts

@@ -12,6 +12,7 @@ export interface Upd {
     Togglable?: Togglable;
     Map?: Map;
     Tag?: Tag;
+    /** SPT specific property, not made by BSG */
     sptPresetId?: string;
     FaceShield?: FaceShield;
     StackObjectsCount?: number;

TypeScript/7OnLoadHook/types/models/eft/inRaid/IInsuredItemsData.d.ts

@@ -0,0 +1,6 @@
+export interface IInsuredItemsData {
+    id: string;
+    durability?: number;
+    maxDurability?: number;
+    hits?: number;
+}

TypeScript/7OnLoadHook/types/models/eft/inRaid/ISaveProgressRequestData.d.ts

@@ -1,9 +1,11 @@
 import { PlayerRaidEndState } from "../../../models/enums/PlayerRaidEndState";
 import { IPmcData } from "../common/IPmcData";
 import { ISyncHealthRequestData } from "../health/ISyncHealthRequestData";
+import { IInsuredItemsData } from "./IInsuredItemsData";
 export interface ISaveProgressRequestData {
     exit: PlayerRaidEndState;
     profile: IPmcData;
     isPlayerScav: boolean;
     health: ISyncHealthRequestData;
+    insurance: IInsuredItemsData[];
 }