Update types

types/callbacks/BundleCallbacks.d.ts

@@ -1,18 +1,13 @@
 import { BundleLoader } from "@spt-aki/loaders/BundleLoader";
 import { IHttpConfig } from "@spt-aki/models/spt/config/IHttpConfig";
-import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
-import { HttpFileUtil } from "@spt-aki/utils/HttpFileUtil";
 import { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil";
 export declare class BundleCallbacks {
-    protected logger: ILogger;
     protected httpResponse: HttpResponseUtil;
-    protected httpFileUtil: HttpFileUtil;
     protected bundleLoader: BundleLoader;
     protected configServer: ConfigServer;
     protected httpConfig: IHttpConfig;
-    constructor(logger: ILogger, httpResponse: HttpResponseUtil, httpFileUtil: HttpFileUtil, bundleLoader: BundleLoader, configServer: ConfigServer);
+    constructor(httpResponse: HttpResponseUtil, bundleLoader: BundleLoader, configServer: ConfigServer);
-    sendBundle(sessionID: string, req: any, resp: any, body: any): void;
     /**
      * Handle singleplayer/bundles
      */

types/callbacks/ClientLogCallbacks.d.ts

@@ -1,14 +1,28 @@
 import { ClientLogController } from "@spt-aki/controllers/ClientLogController";
+import { ModLoadOrder } from "@spt-aki/loaders/ModLoadOrder";
 import { INullResponseData } from "@spt-aki/models/eft/httpResponse/INullResponseData";
 import { IClientLogRequest } from "@spt-aki/models/spt/logging/IClientLogRequest";
+import { ConfigServer } from "@spt-aki/servers/ConfigServer";
+import { LocalisationService } from "@spt-aki/services/LocalisationService";
 import { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil";
 /** Handle client logging related events */
 export declare class ClientLogCallbacks {
     protected httpResponse: HttpResponseUtil;
     protected clientLogController: ClientLogController;
-    constructor(httpResponse: HttpResponseUtil, clientLogController: ClientLogController);
+    protected configServer: ConfigServer;
+    protected localisationService: LocalisationService;
+    protected modLoadOrder: ModLoadOrder;
+    constructor(httpResponse: HttpResponseUtil, clientLogController: ClientLogController, configServer: ConfigServer, localisationService: LocalisationService, modLoadOrder: ModLoadOrder);
     /**
      * Handle /singleplayer/log
      */
     clientLog(url: string, info: IClientLogRequest, sessionID: string): INullResponseData;
+    /**
+     * Handle /singleplayer/release
+     */
+    releaseNotes(): string;
+    /**
+     * Handle /singleplayer/enableBSGlogging
+     */
+    bsgLogging(): string;
 }

types/callbacks/HideoutCallbacks.d.ts

@@ -26,11 +26,11 @@ export declare class HideoutCallbacks implements OnUpdate {
     /**
      * Handle HideoutUpgrade event
      */
-    upgrade(pmcData: IPmcData, body: IHideoutUpgradeRequestData, sessionID: string): IItemEventRouterResponse;
+    upgrade(pmcData: IPmcData, body: IHideoutUpgradeRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Handle HideoutUpgradeComplete event
      */
-    upgradeComplete(pmcData: IPmcData, body: IHideoutUpgradeCompleteRequestData, sessionID: string): IItemEventRouterResponse;
+    upgradeComplete(pmcData: IPmcData, body: IHideoutUpgradeCompleteRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Handle HideoutPutItemsInAreaSlots
      */
@@ -62,11 +62,11 @@ export declare class HideoutCallbacks implements OnUpdate {
     /**
      * Handle HideoutQuickTimeEvent
      */
-    handleQTEEvent(pmcData: IPmcData, request: IHandleQTEEventRequestData, sessionId: string): IItemEventRouterResponse;
+    handleQTEEvent(pmcData: IPmcData, request: IHandleQTEEventRequestData, sessionId: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Handle client/game/profile/items/moving - RecordShootingRangePoints
      */
-    recordShootingRangePoints(pmcData: IPmcData, request: IRecordShootingRangePoints, sessionId: string): IItemEventRouterResponse;
+    recordShootingRangePoints(pmcData: IPmcData, request: IRecordShootingRangePoints, sessionId: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Handle client/game/profile/items/moving - RecordShootingRangePoints
      */

types/callbacks/InraidCallbacks.d.ts

@@ -62,4 +62,6 @@ export declare class InraidCallbacks {
      * Handle singleplayer/traderServices/itemDelivery
      */
     itemDelivery(url: string, request: IItemDeliveryRequestData, sessionId: string): INullResponseData;
+    getTraitorScavHostileChance(url: string, info: IEmptyRequestData, sessionId: string): string;
+    getSandboxMaxPatrolValue(url: string, info: IEmptyRequestData, sessionId: string): string;
 }

types/callbacks/InventoryCallbacks.d.ts

@@ -27,35 +27,35 @@ export declare class InventoryCallbacks {
     protected questController: QuestController;
     constructor(inventoryController: InventoryController, questController: QuestController);
     /** Handle client/game/profile/items/moving Move event */
-    moveItem(pmcData: IPmcData, body: IInventoryMoveRequestData, sessionID: string): IItemEventRouterResponse;
+    moveItem(pmcData: IPmcData, body: IInventoryMoveRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /** Handle Remove event */
-    removeItem(pmcData: IPmcData, body: IInventoryRemoveRequestData, sessionID: string): IItemEventRouterResponse;
+    removeItem(pmcData: IPmcData, body: IInventoryRemoveRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /** Handle Split event */
-    splitItem(pmcData: IPmcData, body: IInventorySplitRequestData, sessionID: string): IItemEventRouterResponse;
+    splitItem(pmcData: IPmcData, body: IInventorySplitRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    mergeItem(pmcData: IPmcData, body: IInventoryMergeRequestData, sessionID: string): IItemEventRouterResponse;
+    mergeItem(pmcData: IPmcData, body: IInventoryMergeRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    transferItem(pmcData: IPmcData, body: IInventoryTransferRequestData, sessionID: string): IItemEventRouterResponse;
+    transferItem(pmcData: IPmcData, request: IInventoryTransferRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /** Handle Swap */
     swapItem(pmcData: IPmcData, body: IInventorySwapRequestData, sessionID: string): IItemEventRouterResponse;
     foldItem(pmcData: IPmcData, body: IInventoryFoldRequestData, sessionID: string): IItemEventRouterResponse;
     toggleItem(pmcData: IPmcData, body: IInventoryToggleRequestData, sessionID: string): IItemEventRouterResponse;
     tagItem(pmcData: IPmcData, body: IInventoryTagRequestData, sessionID: string): IItemEventRouterResponse;
-    bindItem(pmcData: IPmcData, body: IInventoryBindRequestData, sessionID: string): IItemEventRouterResponse;
+    bindItem(pmcData: IPmcData, body: IInventoryBindRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    unbindItem(pmcData: IPmcData, body: IInventoryBindRequestData, sessionID: string): IItemEventRouterResponse;
+    unbindItem(pmcData: IPmcData, body: IInventoryBindRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    examineItem(pmcData: IPmcData, body: IInventoryExamineRequestData, sessionID: string): IItemEventRouterResponse;
+    examineItem(pmcData: IPmcData, body: IInventoryExamineRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /** Handle ReadEncyclopedia */
     readEncyclopedia(pmcData: IPmcData, body: IInventoryReadEncyclopediaRequestData, sessionID: string): IItemEventRouterResponse;
     /** Handle ApplyInventoryChanges */
-    sortInventory(pmcData: IPmcData, body: IInventorySortRequestData, sessionID: string): IItemEventRouterResponse;
+    sortInventory(pmcData: IPmcData, body: IInventorySortRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    createMapMarker(pmcData: IPmcData, body: IInventoryCreateMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    createMapMarker(pmcData: IPmcData, body: IInventoryCreateMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    deleteMapMarker(pmcData: IPmcData, body: IInventoryDeleteMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    deleteMapMarker(pmcData: IPmcData, body: IInventoryDeleteMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    editMapMarker(pmcData: IPmcData, body: IInventoryEditMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    editMapMarker(pmcData: IPmcData, body: IInventoryEditMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /** Handle OpenRandomLootContainer */
-    openRandomLootContainer(pmcData: IPmcData, body: IOpenRandomLootContainerRequestData, sessionID: string): IItemEventRouterResponse;
+    openRandomLootContainer(pmcData: IPmcData, body: IOpenRandomLootContainerRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    redeemProfileReward(pmcData: IPmcData, body: IRedeemProfileRequestData, sessionId: string): IItemEventRouterResponse;
+    redeemProfileReward(pmcData: IPmcData, body: IRedeemProfileRequestData, sessionId: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    setFavoriteItem(pmcData: IPmcData, body: ISetFavoriteItems, sessionId: string): IItemEventRouterResponse;
+    setFavoriteItem(pmcData: IPmcData, body: ISetFavoriteItems, sessionId: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * TODO - MOVE INTO QUEST CODE
      * Handle game/profile/items/moving - QuestFail
      */
-    failQuest(pmcData: IPmcData, request: IFailQuestRequestData, sessionID: string): IItemEventRouterResponse;
+    failQuest(pmcData: IPmcData, request: IFailQuestRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
 }

types/callbacks/ItemEventCallbacks.d.ts

@@ -9,5 +9,11 @@ export declare class ItemEventCallbacks {
     protected itemEventRouter: ItemEventRouter;
     constructor(httpResponse: HttpResponseUtil, itemEventRouter: ItemEventRouter);
     handleEvents(url: string, info: IItemEventRouterRequest, sessionID: string): IGetBodyResponseData<IItemEventRouterResponse>;
+    /**
+     * Return true if the passed in list of warnings contains critical issues
+     * @param warnings The list of warnings to check for critical errors
+     * @returns
+     */
+    private isCriticalError;
     protected getErrorCode(warnings: Warning[]): number;
 }

types/callbacks/MatchCallbacks.d.ts

@@ -1,16 +1,14 @@
 import { MatchController } from "@spt-aki/controllers/MatchController";
 import { IEmptyRequestData } from "@spt-aki/models/eft/common/IEmptyRequestData";
-import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
 import { IGetBodyResponseData } from "@spt-aki/models/eft/httpResponse/IGetBodyResponseData";
 import { INullResponseData } from "@spt-aki/models/eft/httpResponse/INullResponseData";
 import { IAcceptGroupInviteRequest } from "@spt-aki/models/eft/match/IAcceptGroupInviteRequest";
 import { IAcceptGroupInviteResponse } from "@spt-aki/models/eft/match/IAcceptGroupInviteResponse";
 import { ICancelGroupInviteRequest } from "@spt-aki/models/eft/match/ICancelGroupInviteRequest";
-import { ICreateGroupRequestData } from "@spt-aki/models/eft/match/ICreateGroupRequestData";
+import { IDeclineGroupInviteRequest } from "@spt-aki/models/eft/match/IDeclineGroupInviteRequest";
 import { IEndOfflineRaidRequestData } from "@spt-aki/models/eft/match/IEndOfflineRaidRequestData";
 import { IGetGroupStatusRequestData } from "@spt-aki/models/eft/match/IGetGroupStatusRequestData";
 import { IGetGroupStatusResponse } from "@spt-aki/models/eft/match/IGetGroupStatusResponse";
-import { IGetProfileRequestData } from "@spt-aki/models/eft/match/IGetProfileRequestData";
 import { IGetRaidConfigurationRequestData } from "@spt-aki/models/eft/match/IGetRaidConfigurationRequestData";
 import { IJoinMatchRequestData } from "@spt-aki/models/eft/match/IJoinMatchRequestData";
 import { IJoinMatchResult } from "@spt-aki/models/eft/match/IJoinMatchResult";
@@ -39,29 +37,27 @@ export declare class MatchCallbacks {
     sendGroupInvite(url: string, info: ISendGroupInviteRequest, sessionID: string): IGetBodyResponseData<string>;
     /** Handle client/match/group/invite/accept */
     acceptGroupInvite(url: string, info: IAcceptGroupInviteRequest, sessionID: string): IGetBodyResponseData<IAcceptGroupInviteResponse[]>;
+    /** Handle client/match/group/invite/decline */
+    declineGroupInvite(url: string, info: IDeclineGroupInviteRequest, sessionID: string): IGetBodyResponseData<any>;
     /** Handle client/match/group/invite/cancel */
     cancelGroupInvite(url: string, info: ICancelGroupInviteRequest, sessionID: string): IGetBodyResponseData<boolean>;
     /** Handle client/match/group/transfer */
     transferGroup(url: string, info: ITransferGroupRequest, sessionID: string): IGetBodyResponseData<boolean>;
     /** Handle client/match/group/invite/cancel-all */
-    cancelAllGroupInvite(url: string, info: any, sessionID: string): INullResponseData;
+    cancelAllGroupInvite(url: string, info: IEmptyRequestData, sessionID: string): INullResponseData;
     /** @deprecated - not called on raid start/end or game start/exit */
     putMetrics(url: string, info: IPutMetricsRequestData, sessionID: string): INullResponseData;
-    /** Handle raid/profile/list */
-    getProfile(url: string, info: IGetProfileRequestData, sessionID: string): IGetBodyResponseData<IPmcData[]>;
     serverAvailable(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<boolean>;
     /** Handle match/group/start_game */
     joinMatch(url: string, info: IJoinMatchRequestData, sessionID: string): IGetBodyResponseData<IJoinMatchResult>;
     /** Handle client/getMetricsConfig */
     getMetrics(url: string, info: any, sessionID: string): IGetBodyResponseData<string>;
     /**
-     * @deprecated - not called on raid start/end or game start/exit
+     * Called periodically while in a group
      * Handle client/match/group/status
      * @returns
      */
     getGroupStatus(url: string, info: IGetGroupStatusRequestData, sessionID: string): IGetBodyResponseData<IGetGroupStatusResponse>;
-    /** Handle client/match/group/create */
-    createGroup(url: string, info: ICreateGroupRequestData, sessionID: string): IGetBodyResponseData<any>;
     /** Handle client/match/group/delete */
     deleteGroup(url: string, info: any, sessionID: string): INullResponseData;
     leaveGroup(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<boolean>;

types/controllers/GameController.d.ts

@@ -15,6 +15,7 @@ import { IServerDetails } from "@spt-aki/models/eft/game/IServerDetails";
 import { IAkiProfile } from "@spt-aki/models/eft/profile/IAkiProfile";
 import { IBotConfig } from "@spt-aki/models/spt/config/IBotConfig";
 import { ICoreConfig } from "@spt-aki/models/spt/config/ICoreConfig";
+import { IHideoutConfig } from "@spt-aki/models/spt/config/IHideoutConfig";
 import { IHttpConfig } from "@spt-aki/models/spt/config/IHttpConfig";
 import { ILocationConfig } from "@spt-aki/models/spt/config/ILocationConfig";
 import { ILootConfig } from "@spt-aki/models/spt/config/ILootConfig";
@@ -60,6 +61,7 @@ export declare class GameController {
     protected coreConfig: ICoreConfig;
     protected locationConfig: ILocationConfig;
     protected ragfairConfig: IRagfairConfig;
+    protected hideoutConfig: IHideoutConfig;
     protected pmcConfig: IPmcConfig;
     protected lootConfig: ILootConfig;
     protected botConfig: IBotConfig;

types/controllers/HideoutController.d.ts

@@ -70,18 +70,18 @@ export declare class HideoutController {
      * @param pmcData Player profile
      * @param request upgrade start request
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    startUpgrade(pmcData: IPmcData, request: IHideoutUpgradeRequestData, sessionID: string): IItemEventRouterResponse;
+    startUpgrade(pmcData: IPmcData, request: IHideoutUpgradeRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Handle HideoutUpgradeComplete event
      * Complete a hideout area upgrade
      * @param pmcData Player profile
      * @param request Completed upgrade request
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    upgradeComplete(pmcData: IPmcData, request: HideoutUpgradeCompleteRequestData, sessionID: string): IItemEventRouterResponse;
+    upgradeComplete(pmcData: IPmcData, request: HideoutUpgradeCompleteRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Upgrade wall status to visible in profile if medstation/water collector are both level 1
      * @param pmcData Player profile
@@ -222,14 +222,6 @@ export declare class HideoutController {
      * @param output Output object to update
      */
     protected handleScavCase(sessionID: string, pmcData: IPmcData, request: IHideoutTakeProductionRequestData, output: IItemEventRouterResponse): void;
-    /**
-     * Start area production for item by adding production to profiles' Hideout.Production array
-     * @param pmcData Player profile
-     * @param request Start production request
-     * @param sessionID Session id
-     * @returns IItemEventRouterResponse
-     */
-    registerProduction(pmcData: IPmcData, request: IHideoutSingleProductionStartRequestData | IHideoutContinuousProductionStartRequestData, sessionID: string): IItemEventRouterResponse;
     /**
      * Get quick time event list for hideout
      * // TODO - implement this
@@ -244,7 +236,7 @@ export declare class HideoutController {
      * @param pmcData Profile to adjust
      * @param request QTE result object
      */
-    handleQTEEventOutcome(sessionId: string, pmcData: IPmcData, request: IHandleQTEEventRequestData): IItemEventRouterResponse;
+    handleQTEEventOutcome(sessionId: string, pmcData: IPmcData, request: IHandleQTEEventRequestData, output: IItemEventRouterResponse): void;
     /**
      * Record a high score from the shooting range into a player profiles overallcounters
      * @param sessionId Session id
@@ -252,7 +244,7 @@ export declare class HideoutController {
      * @param request shooting range score request
      * @returns IItemEventRouterResponse
      */
-    recordShootingRangePoints(sessionId: string, pmcData: IPmcData, request: IRecordShootingRangePoints): IItemEventRouterResponse;
+    recordShootingRangePoints(sessionId: string, pmcData: IPmcData, request: IRecordShootingRangePoints): void;
     /**
      * Handle client/game/profile/items/moving - HideoutImproveArea
      * @param sessionId Session id

types/controllers/InraidController.d.ts

@@ -13,7 +13,10 @@ import { ISaveProgressRequestData } from "@spt-aki/models/eft/inRaid/ISaveProgre
 import { PlayerRaidEndState } from "@spt-aki/models/enums/PlayerRaidEndState";
 import { IAirdropConfig } from "@spt-aki/models/spt/config/IAirdropConfig";
 import { IBTRConfig } from "@spt-aki/models/spt/config/IBTRConfig";
+import { IHideoutConfig } from "@spt-aki/models/spt/config/IHideoutConfig";
 import { IInRaidConfig } from "@spt-aki/models/spt/config/IInRaidConfig";
+import { ILocationConfig } from "@spt-aki/models/spt/config/ILocationConfig";
+import { IRagfairConfig } from "@spt-aki/models/spt/config/IRagfairConfig";
 import { ITraderConfig } from "@spt-aki/models/spt/config/ITraderConfig";
 import { ITraderServiceModel } from "@spt-aki/models/spt/services/ITraderServiceModel";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
@@ -56,6 +59,9 @@ export declare class InraidController {
     protected btrConfig: IBTRConfig;
     protected inRaidConfig: IInRaidConfig;
     protected traderConfig: ITraderConfig;
+    protected locationConfig: ILocationConfig;
+    protected ragfairConfig: IRagfairConfig;
+    protected hideoutConfig: IHideoutConfig;
     constructor(logger: ILogger, saveServer: SaveServer, jsonUtil: JsonUtil, timeUtil: TimeUtil, databaseServer: DatabaseServer, pmcChatResponseService: PmcChatResponseService, matchBotDetailsCacheService: MatchBotDetailsCacheService, questHelper: QuestHelper, itemHelper: ItemHelper, profileHelper: ProfileHelper, playerScavGenerator: PlayerScavGenerator, healthHelper: HealthHelper, traderHelper: TraderHelper, traderServicesService: TraderServicesService, insuranceService: InsuranceService, inRaidHelper: InRaidHelper, applicationContext: ApplicationContext, configServer: ConfigServer, mailSendService: MailSendService, randomUtil: RandomUtil);
     /**
      * Save locationId to active profiles inraid object AND app context
@@ -104,6 +110,20 @@ export declare class InraidController {
      * @param postRaidRequest Post-raid data of raid
      */
     protected savePlayerScavProgress(sessionID: string, postRaidRequest: ISaveProgressRequestData): void;
+    /**
+     * merge two dictionaries together
+     * Prioritise pair that has true as a value
+     * @param primary main dictionary
+     * @param secondary Secondary dictionary
+     */
+    protected mergePmcAndScavEncyclopedias(primary: IPmcData, secondary: IPmcData): void;
+    /**
+     * Post-scav-raid any charisma increase must be propigated into PMC profile
+     * @param postRaidServerScavProfile Scav profile after adjustments made from raid
+     * @param postRaidServerPmcProfile Pmc profile after raid
+     * @param preRaidScavCharismaProgress charisma progress value pre-raid
+     */
+    protected updatePmcCharismaSkillPostScavRaid(postRaidServerScavProfile: IPmcData, postRaidServerPmcProfile: IPmcData, preRaidScavCharismaProgress: number): void;
     /**
      * Does provided profile contain any condition counters
      * @param profile Profile to check for condition counters
@@ -140,8 +160,9 @@ export declare class InraidController {
      * Update profile with scav karma values based on in-raid actions
      * @param pmcData Pmc profile
      * @param offraidData Post-raid save request
+     * @param scavData Scav profile
      */
-    protected handlePostRaidPlayerScavKarmaChanges(pmcData: IPmcData, offraidData: ISaveProgressRequestData): void;
+    protected handlePostRaidPlayerScavKarmaChanges(pmcData: IPmcData, offraidData: ISaveProgressRequestData, scavData: IPmcData): void;
     /**
      * Get the inraid config from configs/inraid.json
      * @returns InRaid Config
@@ -166,4 +187,6 @@ export declare class InraidController {
      * Handle singleplayer/traderServices/itemDelivery
      */
     itemDelivery(sessionId: string, traderId: string, items: Item[]): void;
+    getTraitorScavHostileChance(url: string, sessionID: string): number;
+    getSandboxMaxPatrolValue(url: string, sessionID: string): number;
 }

types/controllers/InventoryController.d.ts

@@ -27,6 +27,7 @@ import { IOpenRandomLootContainerRequestData } from "@spt-aki/models/eft/invento
 import { IRedeemProfileRequestData } from "@spt-aki/models/eft/inventory/IRedeemProfileRequestData";
 import { ISetFavoriteItems } from "@spt-aki/models/eft/inventory/ISetFavoriteItems";
 import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse";
+import { IAkiProfile } from "@spt-aki/models/eft/profile/IAkiProfile";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
@@ -67,55 +68,52 @@ export declare class InventoryController {
      * @param pmcData Profile
      * @param moveRequest Move request data
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    moveItem(pmcData: IPmcData, moveRequest: IInventoryMoveRequestData, sessionID: string): IItemEventRouterResponse;
+    moveItem(pmcData: IPmcData, moveRequest: IInventoryMoveRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Get a event router response with inventory trader message
      * @param output Item event router response
      * @returns Item event router response
      */
-    protected getTraderExploitErrorResponse(output: IItemEventRouterResponse): IItemEventRouterResponse;
+    protected appendTraderExploitErrorResponse(output: IItemEventRouterResponse): void;
-    /**
-     * Remove Item from Profile
-     * Deep tree item deletion, also removes items from insurance list
-     */
-    removeItem(pmcData: IPmcData, itemId: string, sessionID: string, output?: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Handle Remove event
      * Implements functionality "Discard" from Main menu (Stash etc.)
      * Removes item from PMC Profile
      */
-    discardItem(pmcData: IPmcData, body: IInventoryRemoveRequestData, sessionID: string): IItemEventRouterResponse;
+    discardItem(pmcData: IPmcData, request: IInventoryRemoveRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Split Item
      * spliting 1 stack into 2
      * @param pmcData Player profile (unused, getOwnerInventoryItems() gets profile)
      * @param request Split request
      * @param sessionID Session/player id
+     * @param output Client response
      * @returns IItemEventRouterResponse
      */
-    splitItem(pmcData: IPmcData, request: IInventorySplitRequestData, sessionID: string): IItemEventRouterResponse;
+    splitItem(pmcData: IPmcData, request: IInventorySplitRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Fully merge 2 inventory stacks together into one stack (merging where both stacks remain is called 'transfer')
      * Deletes item from `body.item` and adding number of stacks into `body.with`
      * @param pmcData Player profile (unused, getOwnerInventoryItems() gets profile)
      * @param body Merge request
      * @param sessionID Player id
+     * @param output Client response
      * @returns IItemEventRouterResponse
      */
-    mergeItem(pmcData: IPmcData, body: IInventoryMergeRequestData, sessionID: string): IItemEventRouterResponse;
+    mergeItem(pmcData: IPmcData, body: IInventoryMergeRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * TODO: Adds no data to output to send to client, is this by design?
-     * TODO: should make use of getOwnerInventoryItems(), stack being transferred may not always be on pmc
      * Transfer items from one stack into another while keeping original stack
      * Used to take items from scav inventory into stash or to insert ammo into mags (shotgun ones) and reloading weapon by clicking "Reload"
      * @param pmcData Player profile
      * @param body Transfer request
      * @param sessionID Session id
+     * @param output Client response
      * @returns IItemEventRouterResponse
      */
-    transferItem(pmcData: IPmcData, body: IInventoryTransferRequestData, sessionID: string): IItemEventRouterResponse;
+    transferItem(pmcData: IPmcData, body: IInventoryTransferRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
     /**
      * Swap Item
      * its used for "reload" if you have weapon in hands and magazine is somewhere else in rig or backpack in equipment
@@ -125,7 +123,7 @@ export declare class InventoryController {
     /**
      * Handles folding of Weapons
      */
-    foldItem(pmcData: IPmcData, body: IInventoryFoldRequestData, sessionID: string): IItemEventRouterResponse;
+    foldItem(pmcData: IPmcData, request: IInventoryFoldRequestData, sessionID: string): IItemEventRouterResponse;
     /**
      * Toggles "Toggleable" items like night vision goggles and face shields.
      * @param pmcData player profile
@@ -150,25 +148,26 @@ export declare class InventoryController {
      * @param sessionID Session id
      * @returns IItemEventRouterResponse
      */
-    bindItem(pmcData: IPmcData, bindRequest: IInventoryBindRequestData, sessionID: string): IItemEventRouterResponse;
+    bindItem(pmcData: IPmcData, bindRequest: IInventoryBindRequestData, sessionID: string): void;
     /**
      * Unbind an inventory item from quick access menu at bottom of player screen
      * Handle unbind event
      * @param pmcData Player profile
      * @param bindRequest Request object
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    unbindItem(pmcData: IPmcData, request: IInventoryBindRequestData, sessionID: string): IItemEventRouterResponse;
+    unbindItem(pmcData: IPmcData, request: IInventoryBindRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Handles examining an item
      * @param pmcData player profile
      * @param body request object
      * @param sessionID session id
+     * @param output Client response
      * @returns response
      */
-    examineItem(pmcData: IPmcData, body: IInventoryExamineRequestData, sessionID: string): IItemEventRouterResponse;
+    examineItem(pmcData: IPmcData, body: IInventoryExamineRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
-    protected flagItemsAsInspectedAndRewardXp(itemTpls: string[], pmcProfile: IPmcData): void;
+    protected flagItemsAsInspectedAndRewardXp(itemTpls: string[], fullProfile: IAkiProfile): void;
     /**
      * Get the tplid of an item from the examine request object
      * @param request Response request
@@ -182,33 +181,33 @@ export declare class InventoryController {
      * @param pmcData Player profile
      * @param request sort request
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
      */
-    sortInventory(pmcData: IPmcData, request: IInventorySortRequestData, sessionID: string): IItemEventRouterResponse;
+    sortInventory(pmcData: IPmcData, request: IInventorySortRequestData, sessionID: string): void;
     /**
      * Add note to a map
      * @param pmcData Player profile
      * @param request Add marker request
      * @param sessionID Session id
+     * @param output Client response
      * @returns IItemEventRouterResponse
      */
-    createMapMarker(pmcData: IPmcData, request: IInventoryCreateMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    createMapMarker(pmcData: IPmcData, request: IInventoryCreateMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Delete a map marker
      * @param pmcData Player profile
      * @param request Delete marker request
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    deleteMapMarker(pmcData: IPmcData, request: IInventoryDeleteMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    deleteMapMarker(pmcData: IPmcData, request: IInventoryDeleteMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Edit an existing map marker
      * @param pmcData Player profile
      * @param request Edit marker request
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    editMapMarker(pmcData: IPmcData, request: IInventoryEditMarkerRequestData, sessionID: string): IItemEventRouterResponse;
+    editMapMarker(pmcData: IPmcData, request: IInventoryEditMarkerRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Strip out characters from note string that are not: letter/numbers/unicode/spaces
      * @param mapNoteText Marker text to sanitise
@@ -219,11 +218,11 @@ export declare class InventoryController {
      * Handle OpenRandomLootContainer event
      * Handle event fired when a container is unpacked (currently only the halloween pumpkin)
      * @param pmcData Profile data
-     * @param body open loot container request data
+     * @param body Open loot container request data
      * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    openRandomLootContainer(pmcData: IPmcData, body: IOpenRandomLootContainerRequestData, sessionID: string): IItemEventRouterResponse;
+    openRandomLootContainer(pmcData: IPmcData, body: IOpenRandomLootContainerRequestData, sessionID: string, output: IItemEventRouterResponse): void;
-    redeemProfileReward(pmcData: IPmcData, request: IRedeemProfileRequestData, sessionId: string): IItemEventRouterResponse;
+    redeemProfileReward(pmcData: IPmcData, request: IRedeemProfileRequestData, sessionId: string): void;
-    setFavoriteItem(pmcData: IPmcData, request: ISetFavoriteItems, sessionId: string): IItemEventRouterResponse;
+    setFavoriteItem(pmcData: IPmcData, request: ISetFavoriteItems, sessionId: string): void;
 }

types/controllers/LocationController.d.ts

@@ -13,6 +13,7 @@ import { LootRequest } from "@spt-aki/models/spt/services/LootRequest";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
+import { ItemFilterService } from "@spt-aki/services/ItemFilterService";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
 import { RaidTimeAdjustmentService } from "@spt-aki/services/RaidTimeAdjustmentService";
 import { HashUtil } from "@spt-aki/utils/HashUtil";
@@ -28,6 +29,7 @@ export declare class LocationController {
     protected locationGenerator: LocationGenerator;
     protected localisationService: LocalisationService;
     protected raidTimeAdjustmentService: RaidTimeAdjustmentService;
+    protected itemFilterService: ItemFilterService;
     protected lootGenerator: LootGenerator;
     protected databaseServer: DatabaseServer;
     protected timeUtil: TimeUtil;
@@ -35,7 +37,7 @@ export declare class LocationController {
     protected applicationContext: ApplicationContext;
     protected airdropConfig: IAirdropConfig;
     protected locationConfig: ILocationConfig;
-    constructor(jsonUtil: JsonUtil, hashUtil: HashUtil, randomUtil: RandomUtil, weightedRandomHelper: WeightedRandomHelper, logger: ILogger, locationGenerator: LocationGenerator, localisationService: LocalisationService, raidTimeAdjustmentService: RaidTimeAdjustmentService, lootGenerator: LootGenerator, databaseServer: DatabaseServer, timeUtil: TimeUtil, configServer: ConfigServer, applicationContext: ApplicationContext);
+    constructor(jsonUtil: JsonUtil, hashUtil: HashUtil, randomUtil: RandomUtil, weightedRandomHelper: WeightedRandomHelper, logger: ILogger, locationGenerator: LocationGenerator, localisationService: LocalisationService, raidTimeAdjustmentService: RaidTimeAdjustmentService, itemFilterService: ItemFilterService, lootGenerator: LootGenerator, databaseServer: DatabaseServer, timeUtil: TimeUtil, configServer: ConfigServer, applicationContext: ApplicationContext);
     /**
      * Handle client/location/getLocalloot
      * Get a location (map) with generated loot data

types/controllers/MatchController.d.ts

@@ -3,11 +3,9 @@ import { LootGenerator } from "@spt-aki/generators/LootGenerator";
 import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { TraderHelper } from "@spt-aki/helpers/TraderHelper";
 import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
-import { ICreateGroupRequestData } from "@spt-aki/models/eft/match/ICreateGroupRequestData";
 import { IEndOfflineRaidRequestData } from "@spt-aki/models/eft/match/IEndOfflineRaidRequestData";
 import { IGetGroupStatusRequestData } from "@spt-aki/models/eft/match/IGetGroupStatusRequestData";
 import { IGetGroupStatusResponse } from "@spt-aki/models/eft/match/IGetGroupStatusResponse";
-import { IGetProfileRequestData } from "@spt-aki/models/eft/match/IGetProfileRequestData";
 import { IGetRaidConfigurationRequestData } from "@spt-aki/models/eft/match/IGetRaidConfigurationRequestData";
 import { IJoinMatchRequestData } from "@spt-aki/models/eft/match/IJoinMatchRequestData";
 import { IJoinMatchResult } from "@spt-aki/models/eft/match/IJoinMatchResult";
@@ -48,10 +46,6 @@ export declare class MatchController {
     protected pmcConfig: IPmcConfig;
     constructor(logger: ILogger, saveServer: SaveServer, timeUtil: TimeUtil, randomUtil: RandomUtil, hashUtil: HashUtil, profileHelper: ProfileHelper, matchLocationService: MatchLocationService, traderHelper: TraderHelper, botLootCacheService: BotLootCacheService, configServer: ConfigServer, profileSnapshotService: ProfileSnapshotService, botGenerationCacheService: BotGenerationCacheService, mailSendService: MailSendService, lootGenerator: LootGenerator, applicationContext: ApplicationContext);
     getEnabled(): boolean;
-    /** Handle raid/profile/list */
-    getProfile(info: IGetProfileRequestData): IPmcData[];
-    /** Handle client/match/group/create */
-    createGroup(sessionID: string, info: ICreateGroupRequestData): any;
     /** Handle client/match/group/delete */
     deleteGroup(info: any): void;
     /** Handle match/group/start_game */

types/controllers/PresetController.d.ts

@@ -1,8 +1,10 @@
 import { PresetHelper } from "@spt-aki/helpers/PresetHelper";
+import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 export declare class PresetController {
+    protected logger: ILogger;
     protected presetHelper: PresetHelper;
     protected databaseServer: DatabaseServer;
-    constructor(presetHelper: PresetHelper, databaseServer: DatabaseServer);
+    constructor(logger: ILogger, presetHelper: PresetHelper, databaseServer: DatabaseServer);
     initialize(): void;
 }

types/controllers/QuestController.d.ts

@@ -69,12 +69,6 @@ export declare class QuestController {
      * @returns true = show to player
      */
     protected showEventQuestToPlayer(questId: string): boolean;
-    /**
-     * Is the quest for the opposite side the player is on
-     * @param playerSide Player side (usec/bear)
-     * @param questId QuestId to check
-     */
-    protected questIsForOtherSide(playerSide: string, questId: string): boolean;
     /**
      * Handle QuestAccept event
      * Handle the client accepting a quest and starting it
@@ -114,6 +108,12 @@ export declare class QuestController {
      * @returns ItemEvent client response
      */
     completeQuest(pmcData: IPmcData, body: ICompleteQuestRequestData, sessionID: string): IItemEventRouterResponse;
+    /**
+     * Return a list of quests that would fail when supplied quest is completed
+     * @param completedQuestId quest completed id
+     * @returns array of IQuest objects
+     */
+    protected getQuestsFailedByCompletingQuest(completedQuestId: string, pmcProfile: IPmcData): IQuest[];
     /**
      * Remove a quest entirely from a profile
      * @param sessionId Player id
@@ -191,5 +191,5 @@ export declare class QuestController {
      * @param sessionID Session id
      * @returns IItemEventRouterResponse
      */
-    failQuest(pmcData: IPmcData, request: IFailQuestRequestData, sessionID: string): IItemEventRouterResponse;
+    failQuest(pmcData: IPmcData, request: IFailQuestRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
 }

types/controllers/RagfairController.d.ts

@@ -70,9 +70,17 @@ export declare class RagfairController {
     protected configServer: ConfigServer;
     protected ragfairConfig: IRagfairConfig;
     constructor(logger: ILogger, timeUtil: TimeUtil, httpResponse: HttpResponseUtil, eventOutputHolder: EventOutputHolder, ragfairServer: RagfairServer, ragfairPriceService: RagfairPriceService, databaseServer: DatabaseServer, itemHelper: ItemHelper, saveServer: SaveServer, ragfairSellHelper: RagfairSellHelper, ragfairTaxService: RagfairTaxService, ragfairSortHelper: RagfairSortHelper, ragfairOfferHelper: RagfairOfferHelper, profileHelper: ProfileHelper, paymentService: PaymentService, handbookHelper: HandbookHelper, paymentHelper: PaymentHelper, inventoryHelper: InventoryHelper, traderHelper: TraderHelper, ragfairHelper: RagfairHelper, ragfairOfferService: RagfairOfferService, ragfairRequiredItemsService: RagfairRequiredItemsService, ragfairOfferGenerator: RagfairOfferGenerator, localisationService: LocalisationService, configServer: ConfigServer);
+    /**
+     * Handles client/ragfair/find
+     * Returns flea offers that match required search parameters
+     * @param sessionID Player id
+     * @param searchRequest Search request data
+     * @returns IGetOffersResult
+     */
     getOffers(sessionID: string, searchRequest: ISearchRequestData): IGetOffersResult;
     /**
      * Handle client/ragfair/offer/findbyid
+     * Occurs when searching for `#x` on flea
      * @param sessionId Player id
      * @param request Request data
      * @returns IRagfairOffer
@@ -81,7 +89,7 @@ export declare class RagfairController {
     /**
      * Get offers for the client based on type of search being performed
      * @param searchRequest Client search request data
-     * @param itemsToAdd comes from ragfairHelper.filterCategories()
+     * @param itemsToAdd Comes from ragfairHelper.filterCategories()
      * @param traderAssorts Trader assorts
      * @param pmcProfile Player profile
      * @returns array of offers
@@ -90,7 +98,7 @@ export declare class RagfairController {
     /**
      * Get categories for the type of search being performed, linked/required/all
      * @param searchRequest Client search request data
-     * @param offers ragfair offers to get categories for
+     * @param offers Ragfair offers to get categories for
      * @returns record with templates + counts
      */
     protected getSpecificCategories(pmcProfile: IPmcData, searchRequest: ISearchRequestData, offers: IRagfairOffer[]): Record<string, number>;
@@ -101,16 +109,26 @@ export declare class RagfairController {
     protected addIndexValueToOffers(offers: IRagfairOffer[]): void;
     /**
      * Update a trader flea offer with buy restrictions stored in the traders assort
-     * @param offer flea offer to update
+     * @param offer Flea offer to update
-     * @param profile full profile of player
+     * @param fullProfile Players full profile
      */
-    protected setTraderOfferPurchaseLimits(offer: IRagfairOffer, profile: IAkiProfile): void;
+    protected setTraderOfferPurchaseLimits(offer: IRagfairOffer, fullProfile: IAkiProfile): void;
     /**
      * Adjust ragfair offer stack count to match same value as traders assort stack count
-     * @param offer Flea offer to adjust
+     * @param offer Flea offer to adjust stack size of
      */
     protected setTraderOfferStackSize(offer: IRagfairOffer): void;
+    /**
+     * Is the flea search being performed a 'linked' search type
+     * @param info Search request
+     * @returns True if it is a 'linked' search type
+     */
     protected isLinkedSearch(info: ISearchRequestData): boolean;
+    /**
+     * Is the flea search being performed a 'required' search type
+     * @param info Search request
+     * @returns True if it is a 'required' search type
+     */
     protected isRequiredSearch(info: ISearchRequestData): boolean;
     /**
      * Check all profiles and sell player offers / send player money for listing if it sold
@@ -165,7 +183,7 @@ export declare class RagfairController {
         items: Item[] | null;
         errorMessage: string | null;
     };
-    createPlayerOffer(profile: IAkiProfile, requirements: Requirement[], items: Item[], sellInOnePiece: boolean, amountToSend: number): IRagfairOffer;
+    createPlayerOffer(sessionId: string, requirements: Requirement[], items: Item[], sellInOnePiece: boolean): IRagfairOffer;
     getAllFleaPrices(): Record<string, number>;
     getStaticPrices(): Record<string, number>;
     /**

types/controllers/RepairController.d.ts

@@ -1,3 +1,4 @@
+import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { QuestHelper } from "@spt-aki/helpers/QuestHelper";
 import { RepairHelper } from "@spt-aki/helpers/RepairHelper";
 import { TraderHelper } from "@spt-aki/helpers/TraderHelper";
@@ -20,8 +21,9 @@ export declare class RepairController {
     protected paymentService: PaymentService;
     protected repairHelper: RepairHelper;
     protected repairService: RepairService;
+    protected profileHelper: ProfileHelper;
     protected repairConfig: IRepairConfig;
-    constructor(logger: ILogger, eventOutputHolder: EventOutputHolder, databaseServer: DatabaseServer, questHelper: QuestHelper, traderHelper: TraderHelper, paymentService: PaymentService, repairHelper: RepairHelper, repairService: RepairService);
+    constructor(logger: ILogger, eventOutputHolder: EventOutputHolder, databaseServer: DatabaseServer, questHelper: QuestHelper, traderHelper: TraderHelper, paymentService: PaymentService, repairHelper: RepairHelper, repairService: RepairService, profileHelper: ProfileHelper);
     /**
      * Handle TraderRepair event
      * Repair with trader

types/controllers/RepeatableQuestController.d.ts

@@ -1,13 +1,13 @@
 import { RepeatableQuestGenerator } from "@spt-aki/generators/RepeatableQuestGenerator";
 import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { QuestHelper } from "@spt-aki/helpers/QuestHelper";
-import { RagfairServerHelper } from "@spt-aki/helpers/RagfairServerHelper";
 import { RepeatableQuestHelper } from "@spt-aki/helpers/RepeatableQuestHelper";
 import { IEmptyRequestData } from "@spt-aki/models/eft/common/IEmptyRequestData";
 import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
 import { IPmcDataRepeatableQuest, IRepeatableQuest } from "@spt-aki/models/eft/common/tables/IRepeatableQuests";
 import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse";
 import { IRepeatableQuestChangeRequest } from "@spt-aki/models/eft/quests/IRepeatableQuestChangeRequest";
+import { ELocationName } from "@spt-aki/models/enums/ELocationName";
 import { IQuestConfig, IRepeatableQuestConfig } from "@spt-aki/models/spt/config/IQuestConfig";
 import { IQuestTypePool } from "@spt-aki/models/spt/repeatable/IQuestTypePool";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
@@ -30,7 +30,6 @@ export declare class RepeatableQuestController {
     protected jsonUtil: JsonUtil;
     protected profileHelper: ProfileHelper;
     protected profileFixerService: ProfileFixerService;
-    protected ragfairServerHelper: RagfairServerHelper;
     protected eventOutputHolder: EventOutputHolder;
     protected paymentService: PaymentService;
     protected objectId: ObjectId;
@@ -39,7 +38,7 @@ export declare class RepeatableQuestController {
     protected questHelper: QuestHelper;
     protected configServer: ConfigServer;
     protected questConfig: IQuestConfig;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, timeUtil: TimeUtil, randomUtil: RandomUtil, httpResponse: HttpResponseUtil, jsonUtil: JsonUtil, profileHelper: ProfileHelper, profileFixerService: ProfileFixerService, ragfairServerHelper: RagfairServerHelper, eventOutputHolder: EventOutputHolder, paymentService: PaymentService, objectId: ObjectId, repeatableQuestGenerator: RepeatableQuestGenerator, repeatableQuestHelper: RepeatableQuestHelper, questHelper: QuestHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, databaseServer: DatabaseServer, timeUtil: TimeUtil, randomUtil: RandomUtil, httpResponse: HttpResponseUtil, jsonUtil: JsonUtil, profileHelper: ProfileHelper, profileFixerService: ProfileFixerService, eventOutputHolder: EventOutputHolder, paymentService: PaymentService, objectId: ObjectId, repeatableQuestGenerator: RepeatableQuestGenerator, repeatableQuestHelper: RepeatableQuestHelper, questHelper: QuestHelper, configServer: ConfigServer);
     /**
      * Handle client/repeatalbeQuests/activityPeriods
      * Returns an array of objects in the format of repeatable quests to the client.
@@ -95,6 +94,20 @@ export declare class RepeatableQuestController {
      */
     protected generateQuestPool(repeatableConfig: IRepeatableQuestConfig, pmcLevel: number): IQuestTypePool;
     protected createBaseQuestPool(repeatableConfig: IRepeatableQuestConfig): IQuestTypePool;
+    /**
+     * Return the locations this PMC is allowed to get daily quests for based on their level
+     * @param locations The original list of locations
+     * @param pmcLevel The level of the player PMC
+     * @returns A filtered list of locations that allow the player PMC level to access it
+     */
+    protected getAllowedLocations(locations: Record<ELocationName, string[]>, pmcLevel: number): Partial<Record<ELocationName, string[]>>;
+    /**
+     * Return true if the given pmcLevel is allowed on the given location
+     * @param location The location name to check
+     * @param pmcLevel The level of the pmc
+     * @returns True if the given pmc level is allowed to access the given location
+     */
+    protected isPmcLevelAllowedOnLocation(location: string, pmcLevel: number): boolean;
     debugLogRepeatableQuestIds(pmcData: IPmcData): void;
     /**
      * Handle RepeatableQuestChange event

types/controllers/TraderController.d.ts

@@ -3,14 +3,18 @@ import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { TraderAssortHelper } from "@spt-aki/helpers/TraderAssortHelper";
 import { TraderHelper } from "@spt-aki/helpers/TraderHelper";
 import { ITraderAssort, ITraderBase } from "@spt-aki/models/eft/common/tables/ITrader";
+import { ITraderConfig } from "@spt-aki/models/spt/config/ITraderConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
+import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { FenceService } from "@spt-aki/services/FenceService";
 import { TraderAssortService } from "@spt-aki/services/TraderAssortService";
 import { TraderPurchasePersisterService } from "@spt-aki/services/TraderPurchasePersisterService";
 import { JsonUtil } from "@spt-aki/utils/JsonUtil";
+import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 export declare class TraderController {
     protected logger: ILogger;
+    protected timeUtil: TimeUtil;
     protected databaseServer: DatabaseServer;
     protected traderAssortHelper: TraderAssortHelper;
     protected profileHelper: ProfileHelper;
@@ -20,10 +24,12 @@ export declare class TraderController {
     protected fenceService: FenceService;
     protected fenceBaseAssortGenerator: FenceBaseAssortGenerator;
     protected jsonUtil: JsonUtil;
-    constructor(logger: ILogger, databaseServer: DatabaseServer, traderAssortHelper: TraderAssortHelper, profileHelper: ProfileHelper, traderHelper: TraderHelper, traderAssortService: TraderAssortService, traderPurchasePersisterService: TraderPurchasePersisterService, fenceService: FenceService, fenceBaseAssortGenerator: FenceBaseAssortGenerator, jsonUtil: JsonUtil);
+    protected configServer: ConfigServer;
+    protected traderConfig: ITraderConfig;
+    constructor(logger: ILogger, timeUtil: TimeUtil, databaseServer: DatabaseServer, traderAssortHelper: TraderAssortHelper, profileHelper: ProfileHelper, traderHelper: TraderHelper, traderAssortService: TraderAssortService, traderPurchasePersisterService: TraderPurchasePersisterService, fenceService: FenceService, fenceBaseAssortGenerator: FenceBaseAssortGenerator, jsonUtil: JsonUtil, configServer: ConfigServer);
     /**
      * Runs when onLoad event is fired
-     * Iterate over traders, ensure an unmolested copy of their assorts is stored in traderAssortService
+     * Iterate over traders, ensure a pristine copy of their assorts is stored in traderAssortService
      * Store timestamp of next assort refresh in nextResupply property of traders .base object
      */
     load(): void;

types/di/Router.d.ts

@@ -21,7 +21,7 @@ export declare class DynamicRouter extends Router {
     getHandledRoutes(): HandledRoute[];
 }
 export declare class ItemEventRouterDefinition extends Router {
-    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string): IItemEventRouterResponse;
+    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string, output: IItemEventRouterResponse): void;
 }
 export declare class SaveLoadRouter extends Router {
     handleLoad(profile: IAkiProfile): IAkiProfile;

types/generators/BotGenerator.d.ts

@@ -4,7 +4,7 @@ import { BotDifficultyHelper } from "@spt-aki/helpers/BotDifficultyHelper";
 import { BotHelper } from "@spt-aki/helpers/BotHelper";
 import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { WeightedRandomHelper } from "@spt-aki/helpers/WeightedRandomHelper";
-import { Health as PmcHealth, IBaseJsonSkills, IBaseSkill, IBotBase, Info, Skills as botSkills } from "@spt-aki/models/eft/common/tables/IBotBase";
+import { IBaseJsonSkills, IBaseSkill, IBotBase, Info, Health as PmcHealth, Skills as botSkills } from "@spt-aki/models/eft/common/tables/IBotBase";
 import { Appearance, Health, IBotType } from "@spt-aki/models/eft/common/tables/IBotType";
 import { BotGenerationDetails } from "@spt-aki/models/spt/bots/BotGenerationDetails";
 import { IBotConfig } from "@spt-aki/models/spt/config/IBotConfig";

types/generators/BotLootGenerator.d.ts

@@ -1,7 +1,8 @@
 import { BotWeaponGenerator } from "@spt-aki/generators/BotWeaponGenerator";
 import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper";
-import { BotWeaponGeneratorHelper } from "@spt-aki/helpers/BotWeaponGeneratorHelper";
+import { BotHelper } from "@spt-aki/helpers/BotHelper";
 import { HandbookHelper } from "@spt-aki/helpers/HandbookHelper";
+import { InventoryHelper } from "@spt-aki/helpers/InventoryHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { WeightedRandomHelper } from "@spt-aki/helpers/WeightedRandomHelper";
 import { Inventory as PmcInventory } from "@spt-aki/models/eft/common/tables/IBotBase";
@@ -9,6 +10,7 @@ import { IBotType, Inventory, ModsChances } from "@spt-aki/models/eft/common/tab
 import { Item } from "@spt-aki/models/eft/common/tables/IItem";
 import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
 import { EquipmentSlots } from "@spt-aki/models/enums/EquipmentSlots";
+import { IItemSpawnLimitSettings } from "@spt-aki/models/spt/bots/IItemSpawnLimitSettings";
 import { IBotConfig } from "@spt-aki/models/spt/config/IBotConfig";
 import { IPmcConfig } from "@spt-aki/models/spt/config/IPmcConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
@@ -17,24 +19,28 @@ import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { BotLootCacheService } from "@spt-aki/services/BotLootCacheService";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
 import { HashUtil } from "@spt-aki/utils/HashUtil";
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { RandomUtil } from "@spt-aki/utils/RandomUtil";
 export declare class BotLootGenerator {
     protected logger: ILogger;
     protected hashUtil: HashUtil;
     protected randomUtil: RandomUtil;
     protected itemHelper: ItemHelper;
+    protected jsonUtil: JsonUtil;
+    protected inventoryHelper: InventoryHelper;
     protected databaseServer: DatabaseServer;
     protected handbookHelper: HandbookHelper;
     protected botGeneratorHelper: BotGeneratorHelper;
     protected botWeaponGenerator: BotWeaponGenerator;
-    protected botWeaponGeneratorHelper: BotWeaponGeneratorHelper;
     protected weightedRandomHelper: WeightedRandomHelper;
+    protected botHelper: BotHelper;
     protected botLootCacheService: BotLootCacheService;
     protected localisationService: LocalisationService;
     protected configServer: ConfigServer;
     protected botConfig: IBotConfig;
     protected pmcConfig: IPmcConfig;
-    constructor(logger: ILogger, hashUtil: HashUtil, randomUtil: RandomUtil, itemHelper: ItemHelper, databaseServer: DatabaseServer, handbookHelper: HandbookHelper, botGeneratorHelper: BotGeneratorHelper, botWeaponGenerator: BotWeaponGenerator, botWeaponGeneratorHelper: BotWeaponGeneratorHelper, weightedRandomHelper: WeightedRandomHelper, botLootCacheService: BotLootCacheService, localisationService: LocalisationService, configServer: ConfigServer);
+    constructor(logger: ILogger, hashUtil: HashUtil, randomUtil: RandomUtil, itemHelper: ItemHelper, jsonUtil: JsonUtil, inventoryHelper: InventoryHelper, databaseServer: DatabaseServer, handbookHelper: HandbookHelper, botGeneratorHelper: BotGeneratorHelper, botWeaponGenerator: BotWeaponGenerator, weightedRandomHelper: WeightedRandomHelper, botHelper: BotHelper, botLootCacheService: BotLootCacheService, localisationService: LocalisationService, configServer: ConfigServer);
+    protected getItemSpawnLimitsForBot(botRole: string): IItemSpawnLimitSettings;
     /**
      * Add loot to bots containers
      * @param sessionId Session id
@@ -67,23 +73,25 @@ export declare class BotLootGenerator {
     protected getRandomisedCount(min: number, max: number, nValue: number): number;
     /**
      * Take random items from a pool and add to an inventory until totalItemCount or totalValueLimit or space limit is reached
-     * @param pool Pool of items to pick from
+     * @param pool Pool of items to pick from with weight
      * @param equipmentSlots What equipment slot will the loot items be added to
      * @param totalItemCount Max count of items to add
      * @param inventoryToAddItemsTo Bot inventory loot will be added to
      * @param botRole Role of the bot loot is being generated for (assault/pmcbot)
-     * @param useLimits Should item limit counts be used as defined in config/bot.json
+     * @param itemSpawnLimits Item spawn limits the bot must adhere to
      * @param totalValueLimitRub Total value of loot allowed in roubles
      * @param isPmc Is bot being generated for a pmc
      */
-    protected addLootFromPool(pool: ITemplateItem[], equipmentSlots: string[], totalItemCount: number, inventoryToAddItemsTo: PmcInventory, botRole: string, useLimits?: boolean, totalValueLimitRub?: number, isPmc?: boolean): void;
+    protected addLootFromPool(pool: Record<string, number>, equipmentSlots: string[], totalItemCount: number, inventoryToAddItemsTo: PmcInventory, botRole: string, itemSpawnLimits?: IItemSpawnLimitSettings, totalValueLimitRub?: number, isPmc?: boolean): void;
+    protected createWalletLoot(walletId: string): Item[][];
     /**
      * Some items need child items to function, add them to the itemToAddChildrenTo array
      * @param itemToAddTemplate Db template of item to check
      * @param itemToAddChildrenTo Item to add children to
      * @param isPmc Is the item being generated for a pmc (affects money/ammo stack sizes)
+     * @param botRole role bot has that owns item
      */
-    protected addRequiredChildItemsToParent(itemToAddTemplate: ITemplateItem, itemToAddChildrenTo: Item[], isPmc: boolean): void;
+    protected addRequiredChildItemsToParent(itemToAddTemplate: ITemplateItem, itemToAddChildrenTo: Item[], isPmc: boolean, botRole: string): void;
     /**
      * Add generated weapons to inventory as loot
      * @param botInventory inventory to add preset to
@@ -94,44 +102,28 @@ export declare class BotLootGenerator {
      * @param isPmc are we generating for a pmc
      */
     protected addLooseWeaponsToInventorySlot(sessionId: string, botInventory: PmcInventory, equipmentSlot: string, templateInventory: Inventory, modChances: ModsChances, botRole: string, isPmc: boolean, botLevel: number): void;
-    /**
-     * Get a random item from the pool parameter using the biasedRandomNumber system
-     * @param pool Pool of items to pick an item from
-     * @param isPmc Is the bot being created a pmc
-     * @returns ITemplateItem object
-     */
-    protected getRandomItemFromPoolByBotRole(pool: ITemplateItem[], botRole: string): ITemplateItem;
-    /**
-     * Get the loot nvalue from botconfig
-     * @param botRole Role of bot e.g. assault/bosstagilla/sptBear
-     * @returns nvalue as number
-     */
-    protected getBotLootNValueByRole(botRole: string): number;
     /**
      * Hydrate item limit array to contain items that have a limit for a specific bot type
      * All values are set to 0
-     * @param isPmc Is the bot a pmc
      * @param botRole Role the bot has
      * @param limitCount
      */
-    protected initItemLimitArray(isPmc: boolean, botRole: string, limitCount: Record<string, number>): void;
+    protected initItemLimitArray(botRole: string, limitCount: Record<string, number>): void;
     /**
      * Check if an item has reached its bot-specific spawn limit
      * @param itemTemplate Item we check to see if its reached spawn limit
      * @param botRole Bot type
-     * @param isPmc Is bot we're working with a pmc
+     * @param itemSpawnLimits
-     * @param limitCount Spawn limits for items on bot
-     * @param itemSpawnLimits The limits this bot is allowed to have
      * @returns true if item has reached spawn limit
      */
-    protected itemHasReachedSpawnLimit(itemTemplate: ITemplateItem, botRole: string, isPmc: boolean, limitCount: Record<string, number>, itemSpawnLimits: Record<string, number>): boolean;
+    protected itemHasReachedSpawnLimit(itemTemplate: ITemplateItem, botRole: string, itemSpawnLimits: IItemSpawnLimitSettings): boolean;
     /**
      * Randomise the stack size of a money object, uses different values for pmc or scavs
-     * @param isPmc Is money on a PMC bot
+     * @param botRole Role bot has that has money stack
      * @param itemTemplate item details from db
      * @param moneyItem Money item to randomise
      */
-    protected randomiseMoneyStackSize(isPmc: boolean, itemTemplate: ITemplateItem, moneyItem: Item): void;
+    protected randomiseMoneyStackSize(botRole: string, itemTemplate: ITemplateItem, moneyItem: Item): void;
     /**
      * Randomise the size of an ammo stack
      * @param isPmc Is ammo on a PMC bot
@@ -142,11 +134,10 @@ export declare class BotLootGenerator {
     /**
      * Get spawn limits for a specific bot type from bot.json config
      * If no limit found for a non pmc bot, fall back to defaults
-     * @param isPmc is the bot we want limits for a pmc
      * @param botRole what role does the bot have
      * @returns Dictionary of tplIds and limit
      */
-    protected getItemSpawnLimitsForBotType(isPmc: boolean, botRole: string): Record<string, number>;
+    protected getItemSpawnLimitsForBotType(botRole: string): Record<string, number>;
     /**
      * Get the parentId or tplId of item inside spawnLimits object if it exists
      * @param itemTemplate item we want to look for in spawn limits

types/generators/FenceBaseAssortGenerator.d.ts

@@ -28,6 +28,8 @@ export declare class FenceBaseAssortGenerator {
      * Create base fence assorts dynamically and store in memory
      */
     generateFenceBaseAssorts(): void;
+    protected getItemPrice(itemTpl: string, items: Item[]): number;
+    protected getAmmoBoxPrice(items: Item[]): number;
     /**
      * Add soft inserts + armor plates to an armor
      * @param armor Armor item array to add mods into

types/generators/PMCLootGenerator.d.ts

@@ -4,6 +4,7 @@ import { IPmcConfig } from "@spt-aki/models/spt/config/IPmcConfig";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { ItemFilterService } from "@spt-aki/services/ItemFilterService";
+import { RagfairPriceService } from "@spt-aki/services/RagfairPriceService";
 import { SeasonalEventService } from "@spt-aki/services/SeasonalEventService";
 /**
  * Handle the generation of dynamic PMC loot in pockets and backpacks
@@ -14,22 +15,23 @@ export declare class PMCLootGenerator {
     protected databaseServer: DatabaseServer;
     protected configServer: ConfigServer;
     protected itemFilterService: ItemFilterService;
+    protected ragfairPriceService: RagfairPriceService;
     protected seasonalEventService: SeasonalEventService;
-    protected pocketLootPool: string[];
+    protected pocketLootPool: Record<string, number>;
-    protected vestLootPool: string[];
+    protected vestLootPool: Record<string, number>;
-    protected backpackLootPool: string[];
+    protected backpackLootPool: Record<string, number>;
     protected pmcConfig: IPmcConfig;
-    constructor(itemHelper: ItemHelper, databaseServer: DatabaseServer, configServer: ConfigServer, itemFilterService: ItemFilterService, seasonalEventService: SeasonalEventService);
+    constructor(itemHelper: ItemHelper, databaseServer: DatabaseServer, configServer: ConfigServer, itemFilterService: ItemFilterService, ragfairPriceService: RagfairPriceService, seasonalEventService: SeasonalEventService);
     /**
      * Create an array of loot items a PMC can have in their pockets
      * @returns string array of tpls
      */
-    generatePMCPocketLootPool(): string[];
+    generatePMCPocketLootPool(botRole: string): Record<string, number>;
     /**
      * Create an array of loot items a PMC can have in their vests
      * @returns string array of tpls
      */
-    generatePMCVestLootPool(): string[];
+    generatePMCVestLootPool(botRole: string): Record<string, number>;
     /**
      * Check if item has a width/height that lets it fit into a 2x2 slot
      * 1x1 / 1x2 / 2x1 / 2x2
@@ -41,5 +43,12 @@ export declare class PMCLootGenerator {
      * Create an array of loot items a PMC can have in their backpack
      * @returns string array of tpls
      */
-    generatePMCBackpackLootPool(): string[];
+    generatePMCBackpackLootPool(botRole: string): Record<string, number>;
+    /**
+     * Find the greated common divisor of all weights and use it on the passed in dictionary
+     * @param weightedDict
+     */
+    protected reduceWeightValues(weightedDict: Record<string, number>): void;
+    protected commonDivisor(numbers: number[]): number;
+    protected gcd(a: number, b: number): number;
 }

types/generators/PlayerScavGenerator.d.ts

@@ -1,11 +1,10 @@
 import { BotGenerator } from "@spt-aki/generators/BotGenerator";
 import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper";
 import { BotHelper } from "@spt-aki/helpers/BotHelper";
-import { BotWeaponGeneratorHelper } from "@spt-aki/helpers/BotWeaponGeneratorHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
-import { Skills, Stats } from "@spt-aki/models/eft/common/tables/IBotBase";
+import { IBotBase, Skills, Stats } from "@spt-aki/models/eft/common/tables/IBotBase";
 import { IBotType } from "@spt-aki/models/eft/common/tables/IBotType";
 import { IPlayerScavConfig, KarmaLevel } from "@spt-aki/models/spt/config/IPlayerScavConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
@@ -24,7 +23,6 @@ export declare class PlayerScavGenerator {
     protected databaseServer: DatabaseServer;
     protected hashUtil: HashUtil;
     protected itemHelper: ItemHelper;
-    protected botWeaponGeneratorHelper: BotWeaponGeneratorHelper;
     protected botGeneratorHelper: BotGeneratorHelper;
     protected saveServer: SaveServer;
     protected profileHelper: ProfileHelper;
@@ -36,13 +34,20 @@ export declare class PlayerScavGenerator {
     protected botGenerator: BotGenerator;
     protected configServer: ConfigServer;
     protected playerScavConfig: IPlayerScavConfig;
-    constructor(logger: ILogger, randomUtil: RandomUtil, databaseServer: DatabaseServer, hashUtil: HashUtil, itemHelper: ItemHelper, botWeaponGeneratorHelper: BotWeaponGeneratorHelper, botGeneratorHelper: BotGeneratorHelper, saveServer: SaveServer, profileHelper: ProfileHelper, botHelper: BotHelper, jsonUtil: JsonUtil, fenceService: FenceService, botLootCacheService: BotLootCacheService, localisationService: LocalisationService, botGenerator: BotGenerator, configServer: ConfigServer);
+    constructor(logger: ILogger, randomUtil: RandomUtil, databaseServer: DatabaseServer, hashUtil: HashUtil, itemHelper: ItemHelper, botGeneratorHelper: BotGeneratorHelper, saveServer: SaveServer, profileHelper: ProfileHelper, botHelper: BotHelper, jsonUtil: JsonUtil, fenceService: FenceService, botLootCacheService: BotLootCacheService, localisationService: LocalisationService, botGenerator: BotGenerator, configServer: ConfigServer);
     /**
      * Update a player profile to include a new player scav profile
      * @param sessionID session id to specify what profile is updated
      * @returns profile object
      */
     generate(sessionID: string): IPmcData;
+    /**
+     * Add items picked from `playerscav.lootItemsToAddChancePercent`
+     * @param possibleItemsToAdd dict of tpl + % chance to be added
+     * @param scavData
+     * @param containersToAddTo Possible slotIds to add loot to
+     */
+    protected addAdditionalLootToPlayerScavContainers(possibleItemsToAdd: Record<string, number>, scavData: IBotBase, containersToAddTo: string[]): void;
     /**
      * Get the scav karama level for a profile
      * Is also the fence trader rep level

types/generators/RepeatableQuestGenerator.d.ts

@@ -1,54 +1,34 @@
-import { HandbookHelper } from "@spt-aki/helpers/HandbookHelper";
+import { RepeatableQuestRewardGenerator } from "@spt-aki/generators/RepeatableQuestRewardGenerator";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
-import { PresetHelper } from "@spt-aki/helpers/PresetHelper";
-import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
-import { RagfairServerHelper } from "@spt-aki/helpers/RagfairServerHelper";
 import { RepeatableQuestHelper } from "@spt-aki/helpers/RepeatableQuestHelper";
 import { Exit } from "@spt-aki/models/eft/common/ILocationBase";
 import { TraderInfo } from "@spt-aki/models/eft/common/tables/IBotBase";
-import { Item } from "@spt-aki/models/eft/common/tables/IItem";
+import { IQuestCondition, IQuestConditionCounterCondition } from "@spt-aki/models/eft/common/tables/IQuest";
-import { IQuestCondition, IQuestConditionCounterCondition, IQuestReward, IQuestRewards } from "@spt-aki/models/eft/common/tables/IQuest";
 import { IRepeatableQuest } from "@spt-aki/models/eft/common/tables/IRepeatableQuests";
-import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
+import { IBossInfo, IEliminationConfig, IQuestConfig, IRepeatableQuestConfig } from "@spt-aki/models/spt/config/IQuestConfig";
-import { IBaseQuestConfig, IBossInfo, IEliminationConfig, IQuestConfig, IRepeatableQuestConfig } from "@spt-aki/models/spt/config/IQuestConfig";
 import { IQuestTypePool } from "@spt-aki/models/spt/repeatable/IQuestTypePool";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
-import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
-import { ItemFilterService } from "@spt-aki/services/ItemFilterService";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
-import { PaymentService } from "@spt-aki/services/PaymentService";
-import { ProfileFixerService } from "@spt-aki/services/ProfileFixerService";
-import { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil";
 import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { MathUtil } from "@spt-aki/utils/MathUtil";
 import { ObjectId } from "@spt-aki/utils/ObjectId";
 import { ProbabilityObjectArray, RandomUtil } from "@spt-aki/utils/RandomUtil";
-import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 export declare class RepeatableQuestGenerator {
-    protected timeUtil: TimeUtil;
     protected logger: ILogger;
     protected randomUtil: RandomUtil;
-    protected httpResponse: HttpResponseUtil;
     protected mathUtil: MathUtil;
     protected jsonUtil: JsonUtil;
     protected databaseServer: DatabaseServer;
     protected itemHelper: ItemHelper;
-    protected presetHelper: PresetHelper;
-    protected profileHelper: ProfileHelper;
-    protected profileFixerService: ProfileFixerService;
-    protected handbookHelper: HandbookHelper;
-    protected ragfairServerHelper: RagfairServerHelper;
-    protected eventOutputHolder: EventOutputHolder;
     protected localisationService: LocalisationService;
-    protected paymentService: PaymentService;
     protected objectId: ObjectId;
-    protected itemFilterService: ItemFilterService;
     protected repeatableQuestHelper: RepeatableQuestHelper;
+    protected repeatableQuestRewardGenerator: RepeatableQuestRewardGenerator;
     protected configServer: ConfigServer;
     protected questConfig: IQuestConfig;
-    constructor(timeUtil: TimeUtil, logger: ILogger, randomUtil: RandomUtil, httpResponse: HttpResponseUtil, mathUtil: MathUtil, jsonUtil: JsonUtil, databaseServer: DatabaseServer, itemHelper: ItemHelper, presetHelper: PresetHelper, profileHelper: ProfileHelper, profileFixerService: ProfileFixerService, handbookHelper: HandbookHelper, ragfairServerHelper: RagfairServerHelper, eventOutputHolder: EventOutputHolder, localisationService: LocalisationService, paymentService: PaymentService, objectId: ObjectId, itemFilterService: ItemFilterService, repeatableQuestHelper: RepeatableQuestHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, randomUtil: RandomUtil, mathUtil: MathUtil, jsonUtil: JsonUtil, databaseServer: DatabaseServer, itemHelper: ItemHelper, localisationService: LocalisationService, objectId: ObjectId, repeatableQuestHelper: RepeatableQuestHelper, repeatableQuestRewardGenerator: RepeatableQuestRewardGenerator, configServer: ConfigServer);
     /**
      * This method is called by /GetClientRepeatableQuests/ and creates one element of quest type format (see assets/database/templates/repeatableQuests.json).
      * It randomly draws a quest type (currently Elimination, Completion or Exploration) as well as a trader who is providing the quest
@@ -125,7 +105,7 @@ export declare class RepeatableQuestGenerator {
     /**
      * Filter a maps exits to just those for the desired side
      * @param locationKey Map id (e.g. factory4_day)
-     * @param playerSide Scav/Bear
+     * @param playerSide Scav/Pmc
      * @returns Array of Exit objects
      */
     protected getLocationExitsForSide(locationKey: string, playerSide: string): Exit[];
@@ -144,71 +124,6 @@ export declare class RepeatableQuestGenerator {
      * @returns {object}                            Exit condition
      */
     protected generateExplorationExitCondition(exit: Exit): IQuestConditionCounterCondition;
-    /**
-     * Generate the reward for a mission. A reward can consist of
-     * - Experience
-     * - Money
-     * - Items
-     * - Trader Reputation
-     *
-     * The reward is dependent on the player level as given by the wiki. The exact mapping of pmcLevel to
-     * experience / money / items / trader reputation can be defined in QuestConfig.js
-     *
-     * There's also a random variation of the reward the spread of which can be also defined in the config.
-     *
-     * Additionally, a scaling factor w.r.t. quest difficulty going from 0.2...1 can be used
-     *
-     * @param   {integer}   pmcLevel            player's level
-     * @param   {number}    difficulty          a reward scaling factor from 0.2 to 1
-     * @param   {string}    traderId            the trader for reputation gain (and possible in the future filtering of reward item type based on trader)
-     * @param   {object}    repeatableConfig    The configuration for the repeatable kind (daily, weekly) as configured in QuestConfig for the requested quest
-     * @returns {object}                        object of "Reward"-type that can be given for a repeatable mission
-     */
-    protected generateReward(pmcLevel: number, difficulty: number, traderId: string, repeatableConfig: IRepeatableQuestConfig, questConfig: IBaseQuestConfig): IQuestRewards;
-    protected addMoneyReward(traderId: string, rewards: IQuestRewards, rewardRoubles: number, rewardIndex: number): void;
-    protected calculateAmmoStackSizeThatFitsBudget(itemSelected: ITemplateItem, roublesBudget: number, rewardNumItems: number): number;
-    /**
-     * Should reward item have stack size increased (25% chance)
-     * @param item Item to possibly increase stack size of
-     * @param maxRoublePriceToStack Maximum rouble price an item can be to still be chosen for stacking
-     * @returns True if it should
-     */
-    protected canIncreaseRewardItemStackSize(item: ITemplateItem, maxRoublePriceToStack: number): boolean;
-    /**
-     * Get a randomised number a reward items stack size should be based on its handbook price
-     * @param item Reward item to get stack size for
-     * @returns Stack size value
-     */
-    protected getRandomisedRewardItemStackSizeByPrice(item: ITemplateItem): number;
-    /**
-     * Select a number of items that have a colelctive value of the passed in parameter
-     * @param repeatableConfig Config
-     * @param roublesBudget Total value of items to return
-     * @returns Array of reward items that fit budget
-     */
-    protected chooseRewardItemsWithinBudget(repeatableConfig: IRepeatableQuestConfig, roublesBudget: number, traderId: string): ITemplateItem[];
-    /**
-     * Helper to create a reward item structured as required by the client
-     *
-     * @param   {string}    tpl             ItemId of the rewarded item
-     * @param   {integer}   value           Amount of items to give
-     * @param   {integer}   index           All rewards will be appended to a list, for unknown reasons the client wants the index
-     * @returns {object}                    Object of "Reward"-item-type
-     */
-    protected generateRewardItem(tpl: string, value: number, index: number, preset?: Item[]): IQuestReward;
-    /**
-     * Picks rewardable items from items.json. This means they need to fit into the inventory and they shouldn't be keys (debatable)
-     * @param repeatableQuestConfig Config file
-     * @returns List of rewardable items [[_tpl, itemTemplate],...]
-     */
-    protected getRewardableItems(repeatableQuestConfig: IRepeatableQuestConfig, traderId: string): [string, ITemplateItem][];
-    /**
-     * Checks if an id is a valid item. Valid meaning that it's an item that may be a reward
-     * or content of bot loot. Items that are tested as valid may be in a player backpack or stash.
-     * @param {string} tpl template id of item to check
-     * @returns True if item is valid reward
-     */
-    protected isValidRewardItem(tpl: string, repeatableQuestConfig: IRepeatableQuestConfig, itemBaseWhitelist: string[]): boolean;
     /**
      * Generates the base object of quest type format given as templates in assets/database/templates/repeatableQuests.json
      * The templates include Elimination, Completion and Extraction quest types

types/generators/RepeatableQuestRewardGenerator.d.ts

@@ -0,0 +1,106 @@
+import { HandbookHelper } from "@spt-aki/helpers/HandbookHelper";
+import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
+import { PresetHelper } from "@spt-aki/helpers/PresetHelper";
+import { Item } from "@spt-aki/models/eft/common/tables/IItem";
+import { IQuestReward, IQuestRewards } from "@spt-aki/models/eft/common/tables/IQuest";
+import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
+import { IBaseQuestConfig, IQuestConfig, IRepeatableQuestConfig } from "@spt-aki/models/spt/config/IQuestConfig";
+import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
+import { ConfigServer } from "@spt-aki/servers/ConfigServer";
+import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
+import { ItemFilterService } from "@spt-aki/services/ItemFilterService";
+import { LocalisationService } from "@spt-aki/services/LocalisationService";
+import { SeasonalEventService } from "@spt-aki/services/SeasonalEventService";
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
+import { MathUtil } from "@spt-aki/utils/MathUtil";
+import { ObjectId } from "@spt-aki/utils/ObjectId";
+import { RandomUtil } from "@spt-aki/utils/RandomUtil";
+export declare class RepeatableQuestRewardGenerator {
+    protected logger: ILogger;
+    protected randomUtil: RandomUtil;
+    protected mathUtil: MathUtil;
+    protected jsonUtil: JsonUtil;
+    protected databaseServer: DatabaseServer;
+    protected itemHelper: ItemHelper;
+    protected presetHelper: PresetHelper;
+    protected handbookHelper: HandbookHelper;
+    protected localisationService: LocalisationService;
+    protected objectId: ObjectId;
+    protected itemFilterService: ItemFilterService;
+    protected seasonalEventService: SeasonalEventService;
+    protected configServer: ConfigServer;
+    protected questConfig: IQuestConfig;
+    constructor(logger: ILogger, randomUtil: RandomUtil, mathUtil: MathUtil, jsonUtil: JsonUtil, databaseServer: DatabaseServer, itemHelper: ItemHelper, presetHelper: PresetHelper, handbookHelper: HandbookHelper, localisationService: LocalisationService, objectId: ObjectId, itemFilterService: ItemFilterService, seasonalEventService: SeasonalEventService, configServer: ConfigServer);
+    /**
+     * Generate the reward for a mission. A reward can consist of
+     * - Experience
+     * - Money
+     * - Items
+     * - Trader Reputation
+     *
+     * The reward is dependent on the player level as given by the wiki. The exact mapping of pmcLevel to
+     * experience / money / items / trader reputation can be defined in QuestConfig.js
+     *
+     * There's also a random variation of the reward the spread of which can be also defined in the config.
+     *
+     * Additionally, a scaling factor w.r.t. quest difficulty going from 0.2...1 can be used
+     *
+     * @param   {integer}   pmcLevel            player's level
+     * @param   {number}    difficulty          a reward scaling factor from 0.2 to 1
+     * @param   {string}    traderId            the trader for reputation gain (and possible in the future filtering of reward item type based on trader)
+     * @param   {object}    repeatableConfig    The configuration for the repeatable kind (daily, weekly) as configured in QuestConfig for the requested quest
+     * @returns {object}                        object of "Reward"-type that can be given for a repeatable mission
+     */
+    generateReward(pmcLevel: number, difficulty: number, traderId: string, repeatableConfig: IRepeatableQuestConfig, questConfig: IBaseQuestConfig): IQuestRewards;
+    /**
+     * @param rewardItems List of reward items to filter
+     * @param roublesBudget The budget remaining for rewards
+     * @param minPrice The minimum priced item to include
+     * @returns True if any items remain in `rewardItems`, false otherwise
+     */
+    protected filterRewardPoolWithinBudget(rewardItems: ITemplateItem[], roublesBudget: number, minPrice: number): ITemplateItem[];
+    /**
+     * Get a randomised number a reward items stack size should be based on its handbook price
+     * @param item Reward item to get stack size for
+     * @returns Stack size value
+     */
+    protected getRandomisedRewardItemStackSizeByPrice(item: ITemplateItem): number;
+    /**
+     * Should reward item have stack size increased (25% chance)
+     * @param item Item to possibly increase stack size of
+     * @param maxRoublePriceToStack Maximum rouble price an item can be to still be chosen for stacking
+     * @returns True if it should
+     */
+    protected canIncreaseRewardItemStackSize(item: ITemplateItem, maxRoublePriceToStack: number): boolean;
+    protected calculateAmmoStackSizeThatFitsBudget(itemSelected: ITemplateItem, roublesBudget: number, rewardNumItems: number): number;
+    /**
+     * Select a number of items that have a colelctive value of the passed in parameter
+     * @param repeatableConfig Config
+     * @param roublesBudget Total value of items to return
+     * @returns Array of reward items that fit budget
+     */
+    protected chooseRewardItemsWithinBudget(repeatableConfig: IRepeatableQuestConfig, roublesBudget: number, traderId: string): ITemplateItem[];
+    /**
+     * Helper to create a reward item structured as required by the client
+     *
+     * @param   {string}    tpl             ItemId of the rewarded item
+     * @param   {integer}   value           Amount of items to give
+     * @param   {integer}   index           All rewards will be appended to a list, for unknown reasons the client wants the index
+     * @returns {object}                    Object of "Reward"-item-type
+     */
+    protected generateRewardItem(tpl: string, value: number, index: number, preset?: Item[]): IQuestReward;
+    /**
+     * Picks rewardable items from items.json. This means they need to fit into the inventory and they shouldn't be keys (debatable)
+     * @param repeatableQuestConfig Config file
+     * @returns List of rewardable items [[_tpl, itemTemplate],...]
+     */
+    getRewardableItems(repeatableQuestConfig: IRepeatableQuestConfig, traderId: string): [string, ITemplateItem][];
+    /**
+     * Checks if an id is a valid item. Valid meaning that it's an item that may be a reward
+     * or content of bot loot. Items that are tested as valid may be in a player backpack or stash.
+     * @param {string} tpl template id of item to check
+     * @returns True if item is valid reward
+     */
+    protected isValidRewardItem(tpl: string, repeatableQuestConfig: IRepeatableQuestConfig, itemBaseWhitelist: string[]): boolean;
+    protected addMoneyReward(traderId: string, rewards: IQuestRewards, rewardRoubles: number, rewardIndex: number): void;
+}

types/generators/ScavCaseRewardGenerator.d.ts

@@ -10,6 +10,7 @@ import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { ItemFilterService } from "@spt-aki/services/ItemFilterService";
 import { RagfairPriceService } from "@spt-aki/services/RagfairPriceService";
+import { SeasonalEventService } from "@spt-aki/services/SeasonalEventService";
 import { HashUtil } from "@spt-aki/utils/HashUtil";
 import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { RandomUtil } from "@spt-aki/utils/RandomUtil";
@@ -25,12 +26,13 @@ export declare class ScavCaseRewardGenerator {
     protected presetHelper: PresetHelper;
     protected databaseServer: DatabaseServer;
     protected ragfairPriceService: RagfairPriceService;
+    protected seasonalEventService: SeasonalEventService;
     protected itemFilterService: ItemFilterService;
     protected configServer: ConfigServer;
     protected scavCaseConfig: IScavCaseConfig;
     protected dbItemsCache: ITemplateItem[];
     protected dbAmmoItemsCache: ITemplateItem[];
-    constructor(logger: ILogger, randomUtil: RandomUtil, jsonUtil: JsonUtil, hashUtil: HashUtil, itemHelper: ItemHelper, presetHelper: PresetHelper, databaseServer: DatabaseServer, ragfairPriceService: RagfairPriceService, itemFilterService: ItemFilterService, configServer: ConfigServer);
+    constructor(logger: ILogger, randomUtil: RandomUtil, jsonUtil: JsonUtil, hashUtil: HashUtil, itemHelper: ItemHelper, presetHelper: PresetHelper, databaseServer: DatabaseServer, ragfairPriceService: RagfairPriceService, seasonalEventService: SeasonalEventService, itemFilterService: ItemFilterService, configServer: ConfigServer);
     /**
      * Create an array of rewards that will be given to the player upon completing their scav case build
      * @param recipeId recipe of the scav case craft

types/generators/WeatherGenerator.d.ts

@@ -29,13 +29,13 @@ export declare class WeatherGenerator {
      * @param currentDate current date
      * @returns formatted time
      */
-    protected getBsgFormattedInRaidTime(currentDate: Date): string;
+    protected getBsgFormattedInRaidTime(): string;
     /**
      * Get the current in-raid time
      * @param currentDate (new Date())
      * @returns Date object of current in-raid time
      */
-    getInRaidTime(currentDate: Date): Date;
+    getInRaidTime(): Date;
     /**
      * Get current time formatted to fit BSGs requirement
      * @param date date to format into bsg style

types/generators/weapongen/implementations/ExternalInventoryMagGen.d.ts

@@ -1,5 +1,6 @@
 import { IInventoryMagGen } from "@spt-aki/generators/weapongen/IInventoryMagGen";
 import { InventoryMagGen } from "@spt-aki/generators/weapongen/InventoryMagGen";
+import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper";
 import { BotWeaponGeneratorHelper } from "@spt-aki/helpers/BotWeaponGeneratorHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
@@ -11,8 +12,9 @@ export declare class ExternalInventoryMagGen implements IInventoryMagGen {
     protected itemHelper: ItemHelper;
     protected localisationService: LocalisationService;
     protected botWeaponGeneratorHelper: BotWeaponGeneratorHelper;
+    protected botGeneratorHelper: BotGeneratorHelper;
     protected randomUtil: RandomUtil;
-    constructor(logger: ILogger, itemHelper: ItemHelper, localisationService: LocalisationService, botWeaponGeneratorHelper: BotWeaponGeneratorHelper, randomUtil: RandomUtil);
+    constructor(logger: ILogger, itemHelper: ItemHelper, localisationService: LocalisationService, botWeaponGeneratorHelper: BotWeaponGeneratorHelper, botGeneratorHelper: BotGeneratorHelper, randomUtil: RandomUtil);
     getPriority(): number;
     canHandleInventoryMagGen(inventoryMagGen: InventoryMagGen): boolean;
     process(inventoryMagGen: InventoryMagGen): void;

types/helpers/BotGeneratorHelper.d.ts

@@ -1,8 +1,12 @@
 import { ApplicationContext } from "@spt-aki/context/ApplicationContext";
+import { ContainerHelper } from "@spt-aki/helpers/ContainerHelper";
 import { DurabilityLimitsHelper } from "@spt-aki/helpers/DurabilityLimitsHelper";
+import { InventoryHelper } from "@spt-aki/helpers/InventoryHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
+import { Inventory } from "@spt-aki/models/eft/common/tables/IBotBase";
 import { Item, Repairable, Upd } from "@spt-aki/models/eft/common/tables/IItem";
-import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
+import { Grid, ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
+import { ItemAddedResult } from "@spt-aki/models/enums/ItemAddedResult";
 import { IChooseRandomCompatibleModResult } from "@spt-aki/models/spt/bots/IChooseRandomCompatibleModResult";
 import { EquipmentFilters, IBotConfig, IRandomisedResourceValues } from "@spt-aki/models/spt/config/IBotConfig";
 import { IPmcConfig } from "@spt-aki/models/spt/config/IPmcConfig";
@@ -10,7 +14,6 @@ import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
-import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { RandomUtil } from "@spt-aki/utils/RandomUtil";
 export declare class BotGeneratorHelper {
     protected logger: ILogger;
@@ -18,12 +21,14 @@ export declare class BotGeneratorHelper {
     protected databaseServer: DatabaseServer;
     protected durabilityLimitsHelper: DurabilityLimitsHelper;
     protected itemHelper: ItemHelper;
+    protected inventoryHelper: InventoryHelper;
+    protected containerHelper: ContainerHelper;
     protected applicationContext: ApplicationContext;
     protected localisationService: LocalisationService;
     protected configServer: ConfigServer;
     protected botConfig: IBotConfig;
     protected pmcConfig: IPmcConfig;
-    constructor(logger: ILogger, randomUtil: RandomUtil, databaseServer: DatabaseServer, durabilityLimitsHelper: DurabilityLimitsHelper, itemHelper: ItemHelper, applicationContext: ApplicationContext, localisationService: LocalisationService, configServer: ConfigServer);
+    constructor(logger: ILogger, randomUtil: RandomUtil, databaseServer: DatabaseServer, durabilityLimitsHelper: DurabilityLimitsHelper, itemHelper: ItemHelper, inventoryHelper: InventoryHelper, containerHelper: ContainerHelper, applicationContext: ApplicationContext, localisationService: LocalisationService, configServer: ConfigServer);
     /**
      * Adds properties to an item
      * e.g. Repairable / HasHinge / Foldable / MaxDurability
@@ -78,15 +83,21 @@ export declare class BotGeneratorHelper {
      * @returns Equipment role (e.g. pmc / assault / bossTagilla)
      */
     getBotEquipmentRole(botRole: string): string;
-}
+    /**
-/** TODO - move into own class */
+     * Adds an item with all its children into specified equipmentSlots, wherever it fits.
-export declare class ExhaustableArray<T> {
+     * @param equipmentSlots Slot to add item+children into
-    private itemPool;
+     * @param rootItemId Root item id to use as mod items parentid
-    private randomUtil;
+     * @param rootItemTplId Root itms tpl id
-    private jsonUtil;
+     * @param itemWithChildren Item to add
-    private pool;
+     * @param inventory Inventory to add item+children into
-    constructor(itemPool: T[], randomUtil: RandomUtil, jsonUtil: JsonUtil);
+     * @returns ItemAddedResult result object
-    getRandomValue(): T;
+     */
-    getFirstValue(): T;
+    addItemWithChildrenToEquipmentSlot(equipmentSlots: string[], rootItemId: string, rootItemTplId: string, itemWithChildren: Item[], inventory: Inventory): ItemAddedResult;
-    hasValues(): boolean;
+    /**
+     * Is the provided item allowed inside a container
+     * @param slotGrid Items sub-grid we want to place item inside
+     * @param itemTpl Item tpl being placed
+     * @returns True if allowed
+     */
+    protected itemAllowedInContainer(slotGrid: Grid, itemTpl: string): boolean;
 }

types/helpers/BotWeaponGeneratorHelper.d.ts

@@ -1,13 +1,11 @@
-import { ContainerHelper } from "@spt-aki/helpers/ContainerHelper";
+import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper";
-import { InventoryHelper } from "@spt-aki/helpers/InventoryHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { WeightedRandomHelper } from "@spt-aki/helpers/WeightedRandomHelper";
 import { Inventory } from "@spt-aki/models/eft/common/tables/IBotBase";
 import { GenerationData } from "@spt-aki/models/eft/common/tables/IBotType";
 import { Item } from "@spt-aki/models/eft/common/tables/IItem";
-import { Grid, ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
+import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
 import { EquipmentSlots } from "@spt-aki/models/enums/EquipmentSlots";
-import { ItemAddedResult } from "@spt-aki/models/enums/ItemAddedResult";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
@@ -19,11 +17,10 @@ export declare class BotWeaponGeneratorHelper {
     protected itemHelper: ItemHelper;
     protected randomUtil: RandomUtil;
     protected hashUtil: HashUtil;
-    protected inventoryHelper: InventoryHelper;
     protected weightedRandomHelper: WeightedRandomHelper;
+    protected botGeneratorHelper: BotGeneratorHelper;
     protected localisationService: LocalisationService;
-    protected containerHelper: ContainerHelper;
+    constructor(logger: ILogger, databaseServer: DatabaseServer, itemHelper: ItemHelper, randomUtil: RandomUtil, hashUtil: HashUtil, weightedRandomHelper: WeightedRandomHelper, botGeneratorHelper: BotGeneratorHelper, localisationService: LocalisationService);
-    constructor(logger: ILogger, databaseServer: DatabaseServer, itemHelper: ItemHelper, randomUtil: RandomUtil, hashUtil: HashUtil, inventoryHelper: InventoryHelper, weightedRandomHelper: WeightedRandomHelper, localisationService: LocalisationService, containerHelper: ContainerHelper);
     /**
      * Get a randomized number of bullets for a specific magazine
      * @param magCounts Weights of magazines
@@ -65,22 +62,4 @@ export declare class BotWeaponGeneratorHelper {
      * @returns tpl of magazine
      */
     getWeaponsDefaultMagazineTpl(weaponTemplate: ITemplateItem): string;
-    /**
-     * TODO - move into BotGeneratorHelper, this is not the class for it
-     * Adds an item with all its children into specified equipmentSlots, wherever it fits.
-     * @param equipmentSlots Slot to add item+children into
-     * @param rootItemId Root item id to use as mod items parentid
-     * @param rootItemTplId Root itms tpl id
-     * @param itemWithChildren Item to add
-     * @param inventory Inventory to add item+children into
-     * @returns ItemAddedResult result object
-     */
-    addItemWithChildrenToEquipmentSlot(equipmentSlots: string[], rootItemId: string, rootItemTplId: string, itemWithChildren: Item[], inventory: Inventory): ItemAddedResult;
-    /**
-     * Is the provided item allowed inside a container
-     * @param slotGrid Items sub-grid we want to place item inside
-     * @param itemTpl Item tpl being placed
-     * @returns True if allowed
-     */
-    protected itemAllowedInContainer(slotGrid: Grid, itemTpl: string): boolean;
 }

types/helpers/Dialogue/SptDialogueChatBot.d.ts

@@ -3,6 +3,7 @@ import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { ISendMessageRequest } from "@spt-aki/models/eft/dialog/ISendMessageRequest";
 import { IUserDialogInfo } from "@spt-aki/models/eft/profile/IAkiProfile";
 import { ICoreConfig } from "@spt-aki/models/spt/config/ICoreConfig";
+import { IWeatherConfig } from "@spt-aki/models/spt/config/IWeatherConfig";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { GiftService } from "@spt-aki/services/GiftService";
 import { MailSendService } from "@spt-aki/services/MailSendService";
@@ -14,6 +15,7 @@ export declare class SptDialogueChatBot implements IDialogueChatBot {
     protected giftService: GiftService;
     protected configServer: ConfigServer;
     protected coreConfig: ICoreConfig;
+    protected weatherConfig: IWeatherConfig;
     constructor(profileHelper: ProfileHelper, randomUtil: RandomUtil, mailSendService: MailSendService, giftService: GiftService, configServer: ConfigServer);
     getChatBot(): IUserDialogInfo;
     /**

types/helpers/HideoutHelper.d.ts

@@ -10,6 +10,7 @@ import { IHideoutProduction } from "@spt-aki/models/eft/hideout/IHideoutProducti
 import { IHideoutSingleProductionStartRequestData } from "@spt-aki/models/eft/hideout/IHideoutSingleProductionStartRequestData";
 import { IHideoutTakeProductionRequestData } from "@spt-aki/models/eft/hideout/IHideoutTakeProductionRequestData";
 import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse";
+import { SkillTypes } from "@spt-aki/models/enums/SkillTypes";
 import { IHideoutConfig } from "@spt-aki/models/spt/config/IHideoutConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder";
@@ -19,6 +20,7 @@ import { LocalisationService } from "@spt-aki/services/LocalisationService";
 import { PlayerService } from "@spt-aki/services/PlayerService";
 import { HashUtil } from "@spt-aki/utils/HashUtil";
 import { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil";
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 export declare class HideoutHelper {
     protected logger: ILogger;
@@ -33,6 +35,7 @@ export declare class HideoutHelper {
     protected localisationService: LocalisationService;
     protected itemHelper: ItemHelper;
     protected configServer: ConfigServer;
+    protected jsonUtil: JsonUtil;
     static bitcoinFarm: string;
     static bitcoinProductionId: string;
     static waterCollector: string;
@@ -40,7 +43,7 @@ export declare class HideoutHelper {
     static expeditionaryFuelTank: string;
     static maxSkillPoint: number;
     protected hideoutConfig: IHideoutConfig;
-    constructor(logger: ILogger, hashUtil: HashUtil, timeUtil: TimeUtil, databaseServer: DatabaseServer, eventOutputHolder: EventOutputHolder, httpResponse: HttpResponseUtil, profileHelper: ProfileHelper, inventoryHelper: InventoryHelper, playerService: PlayerService, localisationService: LocalisationService, itemHelper: ItemHelper, configServer: ConfigServer);
+    constructor(logger: ILogger, hashUtil: HashUtil, timeUtil: TimeUtil, databaseServer: DatabaseServer, eventOutputHolder: EventOutputHolder, httpResponse: HttpResponseUtil, profileHelper: ProfileHelper, inventoryHelper: InventoryHelper, playerService: PlayerService, localisationService: LocalisationService, itemHelper: ItemHelper, configServer: ConfigServer, jsonUtil: JsonUtil);
     /**
      * Add production to profiles' Hideout.Production array
      * @param pmcData Profile to add production to
@@ -82,6 +85,16 @@ export declare class HideoutHelper {
         waterCollectorHasFilter: boolean;
     };
     protected doesWaterCollectorHaveFilter(waterCollector: HideoutArea): boolean;
+    /**
+     * Iterate over productions and update their progress timers
+     * @param pmcData Profile to check for productions and update
+     * @param hideoutProperties Hideout properties
+     */
+    protected updateProductionTimers(pmcData: IPmcData, hideoutProperties: {
+        btcFarmCGs: number;
+        isGeneratorOn: boolean;
+        waterCollectorHasFilter: boolean;
+    }): void;
     /**
      * Update progress timer for water collector
      * @param pmcData profile to update
@@ -93,16 +106,6 @@ export declare class HideoutHelper {
         isGeneratorOn: boolean;
         waterCollectorHasFilter: boolean;
     }): void;
-    /**
-     * Iterate over productions and update their progress timers
-     * @param pmcData Profile to check for productions and update
-     * @param hideoutProperties Hideout properties
-     */
-    protected updateProductionTimers(pmcData: IPmcData, hideoutProperties: {
-        btcFarmCGs: number;
-        isGeneratorOn: boolean;
-        waterCollectorHasFilter: boolean;
-    }): void;
     /**
      * Update a productions progress value based on the amount of time that has passed
      * @param pmcData Player profile
@@ -147,7 +150,19 @@ export declare class HideoutHelper {
      * @param isGeneratorOn Is the generator turned on since last update
      */
     protected updateFuel(generatorArea: HideoutArea, pmcData: IPmcData, isGeneratorOn: boolean): void;
-    protected updateWaterCollector(sessionId: string, pmcData: IPmcData, area: HideoutArea, isGeneratorOn: boolean): void;
+    protected updateWaterCollector(sessionId: string, pmcData: IPmcData, area: HideoutArea, hideoutProperties: {
+        btcFarmCGs: number;
+        isGeneratorOn: boolean;
+        waterCollectorHasFilter: boolean;
+    }): void;
+    /**
+     * Get craft time and make adjustments to account for dev profile + crafting skill level
+     * @param pmcData Player profile making craft
+     * @param recipeId Recipe being crafted
+     * @param applyHideoutManagementBonus should the hideout mgmt bonus be appled to the calculation
+     * @returns Items craft time with bonuses subtracted
+     */
+    protected getAdjustedCraftTimeWithSkills(pmcData: IPmcData, recipeId: string, applyHideoutManagementBonus?: boolean): number;
     /**
      * Adjust water filter objects resourceValue or delete when they reach 0 resource
      * @param waterFilterArea water filter area to update
@@ -163,9 +178,9 @@ export declare class HideoutHelper {
      * @param totalProductionTime Total time collecting water
      * @param productionProgress how far water collector has progressed
      * @param baseFilterDrainRate Base drain rate
-     * @returns
+     * @returns drain rate (adjusted)
      */
-    protected adjustWaterFilterDrainRate(secondsSinceServerTick: number, totalProductionTime: number, productionProgress: number, baseFilterDrainRate: number): number;
+    protected getTimeAdjustedWaterFilterDrainRate(secondsSinceServerTick: number, totalProductionTime: number, productionProgress: number, baseFilterDrainRate: number): number;
     /**
      * Get the water filter drain rate based on hideout bonues player has
      * @param pmcData Player profile
@@ -185,7 +200,7 @@ export declare class HideoutHelper {
      * @param resourceUnitsConsumed
      * @returns Upd
      */
-    protected getAreaUpdObject(stackCount: number, resourceValue: number, resourceUnitsConsumed: number): Upd;
+    protected getAreaUpdObject(stackCount: number, resourceValue: number, resourceUnitsConsumed: number, isFoundInRaid: boolean): Upd;
     protected updateAirFilters(airFilterArea: HideoutArea, pmcData: IPmcData, isGeneratorOn: boolean): void;
     protected updateBitcoinFarm(pmcData: IPmcData, btcFarmCGs: number, isGeneratorOn: boolean): Production;
     /**
@@ -220,12 +235,21 @@ export declare class HideoutHelper {
      */
     protected getHideoutManagementConsumptionBonus(pmcData: IPmcData): number;
     /**
-     * Adjust craft time based on crafting skill level found in player profile
+     * Get a multipler based on players skill level and value per level
+     * @param pmcData Player profile
+     * @param skill Player skill from profile
+     * @param valuePerLevel Value from globals.config.SkillsSettings - `PerLevel`
+     * @returns Multipler from 0 to 1
+     */
+    protected getSkillBonusMultipliedBySkillLevel(pmcData: IPmcData, skill: SkillTypes, valuePerLevel: number): number;
+    /**
      * @param pmcData Player profile
      * @param productionTime Time to complete hideout craft in seconds
-     * @returns Adjusted craft time in seconds
+     * @param skill Skill bonus to get reduction from
+     * @param amountPerLevel Skill bonus amount to apply
+     * @returns Seconds to reduce craft time by
      */
-    protected getCraftingSkillProductionTimeReduction(pmcData: IPmcData, productionTime: number): number;
+    getSkillProductionTimeReduction(pmcData: IPmcData, productionTime: number, skill: SkillTypes, amountPerLevel: number): number;
     isProduction(productive: Productive): productive is Production;
     /**
      * Gather crafted BTC from hideout area and add to inventory

types/helpers/InRaidHelper.d.ts

@@ -3,7 +3,7 @@ import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { PaymentHelper } from "@spt-aki/helpers/PaymentHelper";
 import { QuestHelper } from "@spt-aki/helpers/QuestHelper";
 import { IPmcData, IPostRaidPmcData } from "@spt-aki/models/eft/common/IPmcData";
-import { IQuestStatus, TraderInfo, Victim } from "@spt-aki/models/eft/common/tables/IBotBase";
+import { IQuestStatus, TraderInfo } from "@spt-aki/models/eft/common/tables/IBotBase";
 import { Item } from "@spt-aki/models/eft/common/tables/IItem";
 import { ISaveProgressRequestData } from "@spt-aki/models/eft/inRaid/ISaveProgressRequestData";
 import { IInRaidConfig } from "@spt-aki/models/spt/config/IInRaidConfig";
@@ -47,19 +47,6 @@ export declare class InRaidHelper {
      * @param items Items array to check
      */
     addUpdToMoneyFromRaid(items: Item[]): void;
-    /**
-     * Add karma changes up and return the new value
-     * @param existingFenceStanding Current fence standing level
-     * @param victims Array of kills player performed
-     * @returns adjusted karma level after kills are taken into account
-     */
-    calculateFenceStandingChangeFromKills(existingFenceStanding: number, victims: Victim[]): number;
-    /**
-     * Get the standing gain/loss for killing an npc
-     * @param victim Who was killed by player
-     * @returns a numerical standing gain or loss
-     */
-    protected getFenceStandingChangeForKillAsScav(victim: Victim): number;
     /**
      * Reset a profile to a baseline, used post-raid
      * Reset points earned during session property
@@ -137,9 +124,8 @@ export declare class InRaidHelper {
      * @param sessionID Session id
      * @param serverProfile Profile to update
      * @param postRaidProfile Profile returned by client after a raid
-     * @returns Updated profile
      */
-    setInventory(sessionID: string, serverProfile: IPmcData, postRaidProfile: IPmcData): IPmcData;
+    setInventory(sessionID: string, serverProfile: IPmcData, postRaidProfile: IPmcData): void;
     /**
      * Clear PMC inventory of all items except those that are exempt
      * Used post-raid to remove items after death

types/helpers/InventoryHelper.d.ts

@@ -16,6 +16,7 @@ import { IInventoryMergeRequestData } from "@spt-aki/models/eft/inventory/IInven
 import { IInventoryMoveRequestData } from "@spt-aki/models/eft/inventory/IInventoryMoveRequestData";
 import { IInventoryRemoveRequestData } from "@spt-aki/models/eft/inventory/IInventoryRemoveRequestData";
 import { IInventorySplitRequestData } from "@spt-aki/models/eft/inventory/IInventorySplitRequestData";
+import { IInventoryTransferRequestData } from "@spt-aki/models/eft/inventory/IInventoryTransferRequestData";
 import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse";
 import { IInventoryConfig, RewardDetails } from "@spt-aki/models/spt/config/IInventoryConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
@@ -73,14 +74,41 @@ export declare class InventoryHelper {
      * @param itemWithChildren An item
      * @param foundInRaid Item was found in raid
      */
-    private setFindInRaidStatusForItem;
+    protected setFindInRaidStatusForItem(itemWithChildren: Item[], foundInRaid: boolean): void;
     /**
-     * Remove properties from a Upd object used by a trader/ragfair
+     * Remove properties from a Upd object used by a trader/ragfair that are unnecessary to a player
      * @param upd Object to update
      */
     protected removeTraderRagfairRelatedUpdProperties(upd: Upd): void;
+    /**
+     * Can all probided items be added into player inventory
+     * @param sessionId Player id
+     * @param itemsWithChildren array of items with children to try and fit
+     * @returns True all items fit
+     */
     canPlaceItemsInInventory(sessionId: string, itemsWithChildren: Item[][]): boolean;
-    canPlaceItemInInventory(stashFS2D: number[][], itemWithChildren: Item[]): boolean;
+    /**
+     * Do the provided items all fit into the grid
+     * @param containerFS2D Container grid to fit items into
+     * @param itemsWithChildren items to try and fit into grid
+     * @returns True all fit
+     */
+    canPlaceItemsInContainer(containerFS2D: number[][], itemsWithChildren: Item[][]): boolean;
+    /**
+     * Does an item fit into a container grid
+     * @param containerFS2D Container grid
+     * @param itemWithChildren item to check fits
+     * @returns True it fits
+     */
+    canPlaceItemInContainer(containerFS2D: number[][], itemWithChildren: Item[]): boolean;
+    /**
+     * Find a free location inside a container to fit the item
+     * @param containerFS2D Container grid to add item to
+     * @param itemWithChildren Item to add to grid
+     * @param containerId Id of the container we're fitting item into
+     * @param desiredSlotId slot id value to use, default is "hideout"
+     */
+    placeItemInContainer(containerFS2D: number[][], itemWithChildren: Item[], containerId: string, desiredSlotId?: string): void;
     /**
      * Find a location to place an item into inventory and place it
      * @param stashFS2D 2-dimensional representation of the container slots
@@ -92,9 +120,10 @@ export declare class InventoryHelper {
      */
     protected placeItemInInventory(stashFS2D: number[][], sortingTableFS2D: number[][], itemWithChildren: Item[], playerInventory: Inventory, useSortingTable: boolean, output: IItemEventRouterResponse): void;
     /**
+     * Split an items stack size based on its StackMaxSize value
      * @param assortItems Items to add to inventory
      * @param requestItem Details of purchased item to add to inventory
-     * @param result Array split stacks are added to
+     * @param result Array split stacks are appended to
      */
     protected splitStackIntoSmallerChildStacks(assortItems: Item[], requestItem: AddItem, result: IAddItemTempObject[]): void;
     /**
@@ -104,16 +133,51 @@ export declare class InventoryHelper {
      * @param profile Profile to remove item from (pmc or scav)
      * @param itemId Items id to remove
      * @param sessionID Session id
-     * @param output Existing IItemEventRouterResponse object to append data to, creates new one by default if not supplied
+     * @param output OPTIONAL - IItemEventRouterResponse
+     */
+    removeItem(profile: IPmcData, itemId: string, sessionID: string, output?: IItemEventRouterResponse): void;
+    /**
+     * Delete desired item from a player profiles mail
+     * @param sessionId Session id
+     * @param removeRequest Remove request
+     * @param output OPTIONAL - IItemEventRouterResponse
+     */
+    removeItemAndChildrenFromMailRewards(sessionId: string, removeRequest: IInventoryRemoveRequestData, output?: IItemEventRouterResponse): void;
+    /**
+     * Find item by id in player inventory and remove x of its count
+     * @param pmcData player profile
+     * @param itemId Item id to decrement StackObjectsCount of
+     * @param countToRemove Number of item to remove
+     * @param sessionID Session id
+     * @param output IItemEventRouterResponse
      * @returns IItemEventRouterResponse
      */
-    removeItem(profile: IPmcData, itemId: string, sessionID: string, output?: IItemEventRouterResponse): IItemEventRouterResponse;
+    removeItemByCount(pmcData: IPmcData, itemId: string, countToRemove: number, sessionID: string, output?: IItemEventRouterResponse): IItemEventRouterResponse;
-    removeItemAndChildrenFromMailRewards(sessionId: string, removeRequest: IInventoryRemoveRequestData, output: IItemEventRouterResponse): void;
+    /**
-    removeItemByCount(pmcData: IPmcData, itemId: string, count: number, sessionID: string, output?: IItemEventRouterResponse): IItemEventRouterResponse;
+     * Get the height and width of an item - can have children that alter size
+     * @param itemTpl Item to get size of
+     * @param itemID Items id to get size of
+     * @param inventoryItems
+     * @returns [width, height]
+     */
     getItemSize(itemTpl: string, itemID: string, inventoryItems: Item[]): number[];
     protected getSizeByInventoryItemHash(itemTpl: string, itemID: string, inventoryItemHash: InventoryHelper.InventoryItemHash): number[];
+    /**
+     * Get a blank two-dimentional representation of a container
+     * @param containerH Horizontal size of container
+     * @param containerY Vertical size of container
+     * @returns Two-dimensional representation of container
+     */
+    protected getBlankContainerMap(containerH: number, containerY: number): number[][];
+    /**
+     * @param containerH Horizontal size of container
+     * @param containerV Vertical size of container
+     * @param itemList
+     * @param containerId Id of the container
+     * @returns Two-dimensional representation of container
+     */
+    getContainerMap(containerH: number, containerV: number, itemList: Item[], containerId: string): number[][];
     protected getInventoryItemHash(inventoryItem: Item[]): InventoryHelper.InventoryItemHash;
-    getContainerMap(containerW: number, containerH: number, itemList: Item[], containerId: string): number[][];
     /**
      * Return the inventory that needs to be modified (scav/pmc etc)
      * Changes made to result apply to character inventory
@@ -122,19 +186,31 @@ export declare class InventoryHelper {
      * @param sessionId Session id / playerid
      * @returns OwnerInventoryItems with inventory of player/scav to adjust
      */
-    getOwnerInventoryItems(request: IInventoryMoveRequestData | IInventorySplitRequestData | IInventoryMergeRequestData, sessionId: string): IOwnerInventoryItems;
+    getOwnerInventoryItems(request: IInventoryMoveRequestData | IInventorySplitRequestData | IInventoryMergeRequestData | IInventoryTransferRequestData, sessionId: string): IOwnerInventoryItems;
     /**
-     * Made a 2d array table with 0 - free slot and 1 - used slot
+     * Get a two dimensional array to represent stash slots
-     * @param {Object} pmcData
+     * 0 value = free, 1 = taken
-     * @param {string} sessionID
+     * @param pmcData Player profile
-     * @returns Array
+     * @param sessionID session id
+     * @returns 2-dimensional array
      */
     protected getStashSlotMap(pmcData: IPmcData, sessionID: string): number[][];
+    /**
+     * Get a blank two-dimensional array representation of a container
+     * @param containerTpl Container to get data for
+     * @returns blank two-dimensional array
+     */
+    getContainerSlotMap(containerTpl: string): number[][];
+    /**
+     * Get a two-dimensional array representation of the players sorting table
+     * @param pmcData Player profile
+     * @returns two-dimensional array
+     */
     protected getSortingTableSlotMap(pmcData: IPmcData): number[][];
     /**
-     * Get Player Stash Proper Size
+     * Get Players Stash Size
-     * @param sessionID Playerid
+     * @param sessionID Players id
-     * @returns Array of 2 values, x and y stash size
+     * @returns Array of 2 values, horizontal and vertical stash size
      */
     protected getPlayerStashSize(sessionID: string): Record<number, number>;
     /**

types/helpers/ItemHelper.d.ts

@@ -59,12 +59,28 @@ export declare class ItemHelper {
      * @returns Does item have the possibility ot need soft inserts
      */
     armorItemCanHoldMods(itemTpl: string): boolean;
+    /**
+     * Does the provided item tpl need soft/removable inserts to function
+     * @param itemTpl Armor item
+     * @returns True if item needs some kind of insert
+     */
+    armorItemHasRemovableOrSoftInsertSlots(itemTpl: string): boolean;
+    /**
+     * Does the pased in tpl have ability to hold removable plate items
+     * @param itemTpl item tpl to check for plate support
+     * @returns True when armor can hold plates
+     */
+    armorItemHasRemovablePlateSlots(itemTpl: string): boolean;
     /**
      * Does the provided item tpl require soft inserts to become a valid armor item
      * @param itemTpl Item tpl to check
      * @returns True if it needs armor inserts
      */
     itemRequiresSoftInserts(itemTpl: string): boolean;
+    /**
+     * Get all soft insert slot ids
+     * @returns An array of soft insert ids (e.g. soft_armor_back, helmet_top)
+     */
     getSoftInsertSlotIds(): string[];
     /**
      * Returns the items total price based on the handbook or as a fallback from the prices.json if the item is not
@@ -215,6 +231,12 @@ export declare class ItemHelper {
      * @returns Item[]
      */
     replaceIDs(originalItems: Item[], pmcData?: IPmcData | null, insuredItems?: InsuredItem[] | null, fastPanel?: any): Item[];
+    /**
+     * Mark the passed in array of items as found in raid.
+     * Modifies passed in items
+     * @param items The list of items to mark as FiR
+     */
+    setFoundInRaid(items: Item[]): void;
     /**
      * WARNING, SLOW. Recursively loop down through an items hierarchy to see if any of the ids match the supplied list, return true if any do
      * @param {string} tpl Items tpl to check parents of
@@ -426,6 +448,13 @@ export declare class ItemHelper {
      * @returns A Map where the keys are the item IDs and the values are the corresponding Item objects.
      */
     generateItemsMap(items: Item[]): Map<string, Item>;
+    /**
+     * Add a blank upd object to passed in item if it does not exist already
+     * @param item item to add upd to
+     * @param warningMessageWhenMissing text to write to log when upd object was not found
+     * @returns True when upd object was added
+     */
+    addUpdObjectToItem(item: Item, warningMessageWhenMissing?: string): boolean;
 }
 declare namespace ItemHelper {
     interface ItemSize {

types/helpers/PresetHelper.d.ts

@@ -38,4 +38,10 @@ export declare class PresetHelper {
      */
     getDefaultPreset(templateId: string): IPreset;
     getBaseItemTpl(presetId: string): string;
+    /**
+     * Return the price of the preset for the given item tpl, or for the tpl itself if no preset exists
+     * @param tpl The item template to get the price of
+     * @returns The price of the given item preset, or base item if no preset exists
+     */
+    getDefaultPresetOrItemPrice(tpl: string): number;
 }

types/helpers/ProfileHelper.d.ts

@@ -4,17 +4,21 @@ import { Common, CounterKeyValue, Stats } from "@spt-aki/models/eft/common/table
 import { IAkiProfile } from "@spt-aki/models/eft/profile/IAkiProfile";
 import { IValidateNicknameRequestData } from "@spt-aki/models/eft/profile/IValidateNicknameRequestData";
 import { SkillTypes } from "@spt-aki/models/enums/SkillTypes";
+import { IInventoryConfig } from "@spt-aki/models/spt/config/IInventoryConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
+import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
 import { SaveServer } from "@spt-aki/servers/SaveServer";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
 import { ProfileSnapshotService } from "@spt-aki/services/ProfileSnapshotService";
+import { HashUtil } from "@spt-aki/utils/HashUtil";
 import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 import { Watermark } from "@spt-aki/utils/Watermark";
 export declare class ProfileHelper {
     protected logger: ILogger;
     protected jsonUtil: JsonUtil;
+    protected hashUtil: HashUtil;
     protected watermark: Watermark;
     protected timeUtil: TimeUtil;
     protected saveServer: SaveServer;
@@ -22,7 +26,9 @@ export declare class ProfileHelper {
     protected itemHelper: ItemHelper;
     protected profileSnapshotService: ProfileSnapshotService;
     protected localisationService: LocalisationService;
-    constructor(logger: ILogger, jsonUtil: JsonUtil, watermark: Watermark, timeUtil: TimeUtil, saveServer: SaveServer, databaseServer: DatabaseServer, itemHelper: ItemHelper, profileSnapshotService: ProfileSnapshotService, localisationService: LocalisationService);
+    protected configServer: ConfigServer;
+    protected inventoryConfig: IInventoryConfig;
+    constructor(logger: ILogger, jsonUtil: JsonUtil, hashUtil: HashUtil, watermark: Watermark, timeUtil: TimeUtil, saveServer: SaveServer, databaseServer: DatabaseServer, itemHelper: ItemHelper, profileSnapshotService: ProfileSnapshotService, localisationService: LocalisationService, configServer: ConfigServer);
     /**
      * Remove/reset a completed quest condtion from players profile quest data
      * @param sessionID Session id
@@ -34,6 +40,11 @@ export declare class ProfileHelper {
      * @returns Dictionary of profiles
      */
     getProfiles(): Record<string, IAkiProfile>;
+    /**
+     * Get the pmc and scav profiles as an array by profile id
+     * @param sessionID
+     * @returns Array of IPmcData objects
+     */
     getCompleteProfile(sessionID: string): IPmcData[];
     /**
      * Fix xp doubling on post-raid xp reward screen by sending a 'dummy' profile to the post-raid screen
@@ -45,37 +56,70 @@ export declare class ProfileHelper {
      * @param output pmc and scav profiles array
      * @param pmcProfile post-raid pmc profile
      * @param scavProfile post-raid scav profile
-     * @returns updated profile array
+     * @returns Updated profile array
      */
     protected postRaidXpWorkaroundFix(sessionId: string, output: IPmcData[], pmcProfile: IPmcData, scavProfile: IPmcData): IPmcData[];
     /**
      * Check if a nickname is used by another profile loaded by the server
-     * @param nicknameRequest
+     * @param nicknameRequest nickname request object
      * @param sessionID Session id
      * @returns True if already used
      */
     isNicknameTaken(nicknameRequest: IValidateNicknameRequestData, sessionID: string): boolean;
     protected profileHasInfoProperty(profile: IAkiProfile): boolean;
-    protected nicknameMatches(profileName: string, nicknameRequest: string): boolean;
+    protected stringsMatch(stringA: string, stringB: string): boolean;
-    protected sessionIdMatchesProfileId(profileId: string, sessionId: string): boolean;
     /**
      * Add experience to a PMC inside the players profile
      * @param sessionID Session id
      * @param experienceToAdd Experience to add to PMC character
      */
     addExperienceToPmc(sessionID: string, experienceToAdd: number): void;
+    /**
+     * Iterate all profiles and find matching pmc profile by provided id
+     * @param pmcId Profile id to find
+     * @returns IPmcData
+     */
     getProfileByPmcId(pmcId: string): IPmcData;
+    /**
+     * Get the experiecne for the given level
+     * @param level level to get xp for
+     * @returns Number of xp points for level
+     */
     getExperience(level: number): number;
+    /**
+     * Get the max level a player can be
+     * @returns Max level
+     */
     getMaxLevel(): number;
     getDefaultAkiDataObject(): any;
+    /**
+     * Get full representation of a players profile json
+     * @param sessionID Profile id to get
+     * @returns IAkiProfile object
+     */
     getFullProfile(sessionID: string): IAkiProfile;
+    /**
+     * Get a PMC profile by its session id
+     * @param sessionID Profile id to return
+     * @returns IPmcData object
+     */
     getPmcProfile(sessionID: string): IPmcData;
+    /**
+     * Get a full profiles scav-specific sub-profile
+     * @param sessionID Profiles id
+     * @returns IPmcData object
+     */
     getScavProfile(sessionID: string): IPmcData;
     /**
      * Get baseline counter values for a fresh profile
-     * @returns Stats
+     * @returns Default profile Stats object
      */
     getDefaultCounters(): Stats;
+    /**
+     * is this profile flagged for data removal
+     * @param sessionID Profile id
+     * @returns True if profile is to be wiped of data/progress
+     */
     protected isWiped(sessionID: string): boolean;
     protected getServerVersion(): string;
     /**
@@ -120,6 +164,23 @@ export declare class ProfileHelper {
      * @returns
      */
     addSkillPointsToPlayer(pmcProfile: IPmcData, skill: SkillTypes, pointsToAdd: number, useSkillProgressRateMultipler?: boolean): void;
+    /**
+     * Get a speciic common skill from supplied profile
+     * @param pmcData Player profile
+     * @param skill Skill to look up and return value from
+     * @returns Common skill object from desired profile
+     */
     getSkillFromProfile(pmcData: IPmcData, skill: SkillTypes): Common;
+    /**
+     * Is the provided session id for a developer account
+     * @param sessionID Profile id ot check
+     * @returns True if account is developer
+     */
     isDeveloperAccount(sessionID: string): boolean;
+    /**
+     * Add stash row bonus to profile or increments rows given count if it already exists
+     * @param sessionId Profile id to give rows to
+     * @param rowsToAdd How many rows to give profile
+     */
+    addStashRowsBonusToProfile(sessionId: string, rowsToAdd: number): void;
 }

types/helpers/QuestHelper.d.ts

@@ -128,6 +128,12 @@ export declare class QuestHelper {
      * @returns Quests accessible to player incuding newly unlocked quests now quest (startedQuestId) was started
      */
     getNewlyAccessibleQuestsWhenStartingQuest(startedQuestId: string, sessionID: string): IQuest[];
+    /**
+     * Is the quest for the opposite side the player is on
+     * @param playerSide Player side (usec/bear)
+     * @param questId QuestId to check
+     */
+    questIsForOtherSide(playerSide: string, questId: string): boolean;
     /**
      * Get quests that can be shown to player after failing a quest
      * @param failedQuestId Id of the quest failed by player
@@ -178,9 +184,8 @@ export declare class QuestHelper {
      * @param failRequest Fail quest request data
      * @param sessionID Session id
      * @param output Client output
-     * @returns Item event router response
      */
-    failQuest(pmcData: IPmcData, failRequest: IFailQuestRequestData, sessionID: string, output?: IItemEventRouterResponse): IItemEventRouterResponse;
+    failQuest(pmcData: IPmcData, failRequest: IFailQuestRequestData, sessionID: string, output?: IItemEventRouterResponse): void;
     /**
      * Get List of All Quests from db
      * NOT CLONED

types/helpers/RagfairOfferHelper.d.ts

@@ -157,6 +157,13 @@ export declare class RagfairOfferHelper {
      * @returns True
      */
     protected passesSearchFilterCriteria(searchRequest: ISearchRequestData, offer: IRagfairOffer, pmcData: IPmcData): boolean;
+    /**
+     * Check that the passed in offer item is functional
+     * @param offerRootItem The root item of the offer
+     * @param offer The flea offer
+     * @returns True if the given item is functional
+     */
+    isItemFunctional(offerRootItem: Item, offer: IRagfairOffer): boolean;
     /**
      * Should a ragfair offer be visible to the player
      * @param searchRequest Search request

types/helpers/RagfairServerHelper.d.ts

@@ -53,6 +53,12 @@ export declare class RagfairServerHelper {
      * @returns True if its blacklsited
      */
     protected isItemOnCustomFleaBlacklist(itemTemplateId: string): boolean;
+    /**
+     * Is supplied parent id on the ragfair custom item category blacklist
+     * @param parentId Parent Id to check is blacklisted
+     * @returns true if blacklisted
+     */
+    protected isItemCategoryOnCustomFleaBlacklist(itemParentId: string): boolean;
     /**
      * is supplied id a trader
      * @param traderId

types/helpers/TradeHelper.d.ts

@@ -56,13 +56,6 @@ export declare class TradeHelper {
      * @param output IItemEventRouterResponse
      */
     sellItem(profileWithItemsToSell: IPmcData, profileToReceiveMoney: IPmcData, sellRequest: IProcessSellTradeRequestData, sessionID: string, output: IItemEventRouterResponse): void;
-    /**
-     * Increment the assorts buy count by number of items purchased
-     * Show error on screen if player attempts to buy more than what the buy max allows
-     * @param assortBeingPurchased assort being bought
-     * @param itemsPurchasedCount number of items being bought
-     */
-    protected incrementAssortBuyCount(assortBeingPurchased: Item, itemsPurchasedCount: number): void;
     /**
      * Traders allow a limited number of purchases per refresh cycle (default 60 mins)
      * @param sessionId Session id

types/helpers/TraderHelper.d.ts

@@ -59,7 +59,7 @@ export declare class TraderHelper {
     /**
      * Reset a profiles trader data back to its initial state as seen by a level 1 player
      * Does NOT take into account different profile levels
-     * @param sessionID session id
+     * @param sessionID session id of player
      * @param traderID trader id to reset
      */
     resetTrader(sessionID: string, traderID: string): void;
@@ -74,13 +74,13 @@ export declare class TraderHelper {
      * Alter a traders unlocked status
      * @param traderId Trader to alter
      * @param status New status to use
-     * @param sessionId Session id
+     * @param sessionId Session id of player
      */
     setTraderUnlockedState(traderId: string, status: boolean, sessionId: string): void;
     /**
      * Add standing to a trader and level them up if exp goes over level threshold
-     * @param sessionId Session id
+     * @param sessionId Session id of player
-     * @param traderId Traders id
+     * @param traderId Traders id to add standing to
      * @param standingToAdd Standing value to add to trader
      */
     addStandingToTrader(sessionId: string, traderId: string, standingToAdd: number): void;
@@ -121,7 +121,7 @@ export declare class TraderHelper {
             count: number;
         }[];
         traderId: string;
-    }): void;
+    }, itemPurchased: Item): void;
     /**
      * Get the highest rouble price for an item from traders
      * UNUSED

types/ide/BleedingEdgeModsEntry.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+import "source-map-support/register";

types/loaders/BundleLoader.d.ts

@@ -1,33 +1,33 @@
 import { HttpServerHelper } from "@spt-aki/helpers/HttpServerHelper";
+import { BundleHashCacheService } from "@spt-aki/services/cache/BundleHashCacheService";
 import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 import { VFS } from "@spt-aki/utils/VFS";
-declare class BundleInfo {
+export declare class BundleInfo {
-    modPath: string;
+    modpath: string;
-    key: string;
+    filename: string;
-    path: string;
+    crc: number;
-    filepath: string;
+    dependencies: string[];
-    dependencyKeys: string[];
+    constructor(modpath: string, bundle: BundleManifestEntry, bundleHash: number);
-    constructor(modpath: string, bundle: any, bundlePath: string, bundleFilepath: string);
 }
 export declare class BundleLoader {
     protected httpServerHelper: HttpServerHelper;
     protected vfs: VFS;
     protected jsonUtil: JsonUtil;
+    protected bundleHashCacheService: BundleHashCacheService;
     protected bundles: Record<string, BundleInfo>;
-    constructor(httpServerHelper: HttpServerHelper, vfs: VFS, jsonUtil: JsonUtil);
+    constructor(httpServerHelper: HttpServerHelper, vfs: VFS, jsonUtil: JsonUtil, bundleHashCacheService: BundleHashCacheService);
     /**
      * Handle singleplayer/bundles
      */
-    getBundles(local: boolean): BundleInfo[];
+    getBundles(): BundleInfo[];
-    getBundle(key: string, local: boolean): BundleInfo;
+    getBundle(key: string): BundleInfo;
     addBundles(modpath: string): void;
     addBundle(key: string, b: BundleInfo): void;
 }
 export interface BundleManifest {
-    manifest: Array<BundleManifestEntry>;
+    manifest: BundleManifestEntry[];
 }
 export interface BundleManifestEntry {
     key: string;
-    path: string;
+    dependencyKeys: string[];
 }
-export {};

types/loaders/PostAkiModLoader.d.ts

@@ -1,21 +1,17 @@
 import { DependencyContainer } from "tsyringe";
-import { BundleLoader } from "@spt-aki/loaders/BundleLoader";
 import { ModTypeCheck } from "@spt-aki/loaders/ModTypeCheck";
 import { PreAkiModLoader } from "@spt-aki/loaders/PreAkiModLoader";
 import { IModLoader } from "@spt-aki/models/spt/mod/IModLoader";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
-import { VFS } from "@spt-aki/utils/VFS";
 export declare class PostAkiModLoader implements IModLoader {
     protected logger: ILogger;
-    protected bundleLoader: BundleLoader;
-    protected vfs: VFS;
     protected preAkiModLoader: PreAkiModLoader;
     protected localisationService: LocalisationService;
     protected modTypeCheck: ModTypeCheck;
-    constructor(logger: ILogger, bundleLoader: BundleLoader, vfs: VFS, preAkiModLoader: PreAkiModLoader, localisationService: LocalisationService, modTypeCheck: ModTypeCheck);
+    protected container: DependencyContainer;
+    constructor(logger: ILogger, preAkiModLoader: PreAkiModLoader, localisationService: LocalisationService, modTypeCheck: ModTypeCheck);
     getModPath(mod: string): string;
     load(): Promise<void>;
-    protected executeMods(container: DependencyContainer): Promise<void>;
+    protected executeModsAsync(): Promise<void>;
-    protected addBundles(): void;
 }

types/loaders/PostDBModLoader.d.ts

@@ -1,17 +1,21 @@
 import { DependencyContainer } from "tsyringe";
 import { OnLoad } from "@spt-aki/di/OnLoad";
+import { BundleLoader } from "@spt-aki/loaders/BundleLoader";
 import { ModTypeCheck } from "@spt-aki/loaders/ModTypeCheck";
 import { PreAkiModLoader } from "@spt-aki/loaders/PreAkiModLoader";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
 export declare class PostDBModLoader implements OnLoad {
     protected logger: ILogger;
+    protected bundleLoader: BundleLoader;
     protected preAkiModLoader: PreAkiModLoader;
     protected localisationService: LocalisationService;
     protected modTypeCheck: ModTypeCheck;
-    constructor(logger: ILogger, preAkiModLoader: PreAkiModLoader, localisationService: LocalisationService, modTypeCheck: ModTypeCheck);
+    protected container: DependencyContainer;
+    constructor(logger: ILogger, bundleLoader: BundleLoader, preAkiModLoader: PreAkiModLoader, localisationService: LocalisationService, modTypeCheck: ModTypeCheck);
     onLoad(): Promise<void>;
     getRoute(): string;
     getModPath(mod: string): string;
-    protected executeMods(container: DependencyContainer): Promise<void>;
+    protected executeModsAsync(): Promise<void>;
+    protected addBundles(): void;
 }

types/loaders/PreAkiModLoader.d.ts

@@ -1,5 +1,4 @@
 import { DependencyContainer } from "tsyringe";
-import { BundleLoader } from "@spt-aki/loaders/BundleLoader";
 import { ModLoadOrder } from "@spt-aki/loaders/ModLoadOrder";
 import { ModTypeCheck } from "@spt-aki/loaders/ModTypeCheck";
 import { ModDetails } from "@spt-aki/models/eft/profile/IAkiProfile";
@@ -17,12 +16,11 @@ export declare class PreAkiModLoader implements IModLoader {
     protected vfs: VFS;
     protected jsonUtil: JsonUtil;
     protected modCompilerService: ModCompilerService;
-    protected bundleLoader: BundleLoader;
     protected localisationService: LocalisationService;
     protected configServer: ConfigServer;
     protected modLoadOrder: ModLoadOrder;
     protected modTypeCheck: ModTypeCheck;
-    protected static container: DependencyContainer;
+    protected container: DependencyContainer;
     protected readonly basepath = "user/mods/";
     protected readonly modOrderPath = "user/mods/order.json";
     protected order: Record<string, number>;
@@ -30,7 +28,7 @@ export declare class PreAkiModLoader implements IModLoader {
     protected akiConfig: ICoreConfig;
     protected serverDependencies: Record<string, string>;
     protected skippedMods: Set<string>;
-    constructor(logger: ILogger, vfs: VFS, jsonUtil: JsonUtil, modCompilerService: ModCompilerService, bundleLoader: BundleLoader, localisationService: LocalisationService, configServer: ConfigServer, modLoadOrder: ModLoadOrder, modTypeCheck: ModTypeCheck);
+    constructor(logger: ILogger, vfs: VFS, jsonUtil: JsonUtil, modCompilerService: ModCompilerService, localisationService: LocalisationService, configServer: ConfigServer, modLoadOrder: ModLoadOrder, modTypeCheck: ModTypeCheck);
     load(container: DependencyContainer): Promise<void>;
     /**
      * Returns a list of mods with preserved load order
@@ -68,10 +66,9 @@ export declare class PreAkiModLoader implements IModLoader {
     protected isModCombatibleWithAki(mod: IPackageJsonData): boolean;
     /**
      * Execute each mod found in this.imported
-     * @param container Dependence container to give to mod when it runs
      * @returns void promise
      */
-    protected executeModsAsync(container: DependencyContainer): Promise<void>;
+    protected executeModsAsync(): Promise<void>;
     /**
      * Read loadorder.json (create if doesnt exist) and return sorted list of mods
      * @returns string array of sorted mod names

types/models/eft/common/IGlobals.d.ts

@@ -40,6 +40,7 @@ export interface IConfig {
     BaseLoadTime: number;
     BaseUnloadTime: number;
     BaseCheckTime: number;
+    BluntDamageReduceFromSoftArmorMod: number;
     Customization: ICustomization;
     UncheckOnShot: boolean;
     BotsEnabled: boolean;
@@ -682,6 +683,7 @@ export interface IBodyPartsSetting {
     Minimum: number;
     Maximum: number;
     Default: number;
+    EnvironmentDamageMultiplier: number;
     OverDamageReceivedMultiplier: number;
 }
 export interface IHealthFactorsSettings {

types/models/eft/common/ILocation.d.ts

@@ -1,9 +1,10 @@
-import { ILocationBase } from "@spt-aki/models/eft/common/ILocationBase";
+import { Exit, ILocationBase } from "@spt-aki/models/eft/common/ILocationBase";
 import { ILooseLoot } from "@spt-aki/models/eft/common/ILooseLoot";
 export interface ILocation {
     base: ILocationBase;
     looseLoot: ILooseLoot;
     statics: IStaticContainer;
+    allExtracts: Exit[];
 }
 export interface IStaticContainer {
     containersGroups: Record<string, IContainerMinMax>;

types/models/eft/common/ILocationBase.d.ts

@@ -205,6 +205,7 @@ export interface Exit {
     PassageRequirement: string;
     PlayersCount: number;
     RequirementTip: string;
+    Side?: string;
 }
 export interface MaxItemCountInLocation {
     TemplateId: string;

types/models/eft/common/tables/IBotBase.d.ts

@@ -54,6 +54,7 @@ export interface Info {
     LowerNickname: string;
     Side: string;
     SquadInviteRestriction: boolean;
+    HasCoopExtension: boolean;
     Voice: string;
     Level: number;
     Experience: number;
@@ -181,6 +182,7 @@ export interface IEftStats {
     LastPlayerState?: LastPlayerState;
     TotalInGameTime: number;
     SurvivorClass?: string;
+    sptLastRaidFenceRepChange?: number;
 }
 export interface IDroppedItem {
     QuestId: string;
@@ -314,6 +316,8 @@ export interface Productive {
     sptIsComplete?: boolean;
     /** Is the craft a Continuous, e.g bitcoins/water collector */
     sptIsContinuous?: boolean;
+    /** Stores a list of tools used in this craft and whether they're FiR, to give back once the craft is done */
+    sptRequiredTools?: Item[];
 }
 export interface Production extends Productive {
     RecipeId: string;

types/models/eft/common/tables/IBotType.d.ts

@@ -120,7 +120,7 @@ export interface GenerationData {
     /** key: number of items, value: weighting */
     weights: Record<string, number>;
     /** Array of item tpls */
-    whitelist: string[];
+    whitelist: Record<string, number>;
 }
 export interface Health {
     BodyParts: BodyPart[];
@@ -160,10 +160,10 @@ export interface Equipment {
     TacticalVest: Record<string, number>;
 }
 export interface Items {
-    Backpack: string[];
+    Backpack: Record<string, number>;
-    Pockets: string[];
+    Pockets: Record<string, number>;
-    SecuredContainer: string[];
+    SecuredContainer: Record<string, number>;
-    SpecialLoot: string[];
+    SpecialLoot: Record<string, number>;
-    TacticalVest: string[];
+    TacticalVest: Record<string, number>;
 }
 export type Mods = Record<string, Record<string, string[]>>;

types/models/eft/common/tables/IItem.d.ts

@@ -33,6 +33,7 @@ export interface Upd {
     Foldable?: Foldable;
     SideEffect?: SideEffect;
     RepairKit?: RepairKit;
+    CultistAmulet?: ICultistAmulet;
 }
 export interface Buff {
     rarity: string;
@@ -119,3 +120,6 @@ export interface SideEffect {
 export interface RepairKit {
     Resource: number;
 }
+export interface ICultistAmulet {
+    NumberOfUsages: number;
+}

types/models/eft/common/tables/ITemplateItem.d.ts

@@ -175,6 +175,7 @@ export interface Props {
     armorClass?: string | number;
     armorColliders?: string[];
     armorPlateColliders?: string[];
+    bluntDamageReduceFromSoftArmor?: boolean;
     mousePenalty?: number;
     weaponErgonomicPenalty?: number;
     BluntThroughput?: number;

types/models/eft/hideout/IHideoutSingleProductionStartRequestData.d.ts

@@ -2,6 +2,7 @@ export interface IHideoutSingleProductionStartRequestData {
     Action: "HideoutSingleProductionStart";
     recipeId: string;
     items: Item[];
+    tools: Item[];
     timestamp: number;
 }
 export interface Item {

types/models/eft/itemEvent/IItemEventRouterResponse.d.ts

@@ -1,3 +1,4 @@
 import { IItemEventRouterBase } from "@spt-aki/models/eft/itemEvent/IItemEventRouterBase";
+/** An object sent back to the game client that contains alterations the client must make to ensure server/client are in sync */
 export interface IItemEventRouterResponse extends IItemEventRouterBase {
 }

types/models/eft/match/IDeclineGroupInviteRequest.d.ts

@@ -0,0 +1,2 @@
+export interface IDeclineGroupInviteRequest {
+}

types/models/eft/match/IGetRaidConfigurationRequestData.d.ts

@@ -9,6 +9,8 @@ export interface IGetRaidConfigurationRequestData {
     timeAndWeatherSettings: TimeAndWeatherSettings;
     botSettings: BotSettings;
     wavesSettings: WavesSettings;
+    CanShowGroupPreview: boolean;
+    MaxGroupCount: number;
 }
 export interface TimeAndWeatherSettings {
     isRandomTime: boolean;

types/models/enums/BackendErrorCodes.d.ts

@@ -62,6 +62,7 @@ export declare enum BackendErrorCodes {
     BANNEDERRORCODE = 1513,
     INSUFFICIENTNUMBERINSTOCK = 1516,
     TOOMANYITEMSTOSELL = 1517,
+    INCORRECTCLIENTPRICE = 1519,
     EXAMINATIONFAILED = 22001,
     ITEMALREADYEXAMINED = 22002,
     UNKNOWNNGINXERROR = 9000,
@@ -81,5 +82,6 @@ export declare enum BackendErrorCodes {
     PLAYERISNOTSEARCHINGFORGROUP = 502018,
     PLAYERALREADYLOOKINGFORGAME = 503001,
     PLAYERINRAID = 503002,
-    LIMITFORPRESETSREACHED = 504001
+    LIMITFORPRESETSREACHED = 504001,
+    PLAYERPROFILENOTFOUND = 505001
 }

types/models/enums/BaseClasses.d.ts

@@ -95,7 +95,7 @@ export declare enum BaseClasses {
     PORTABLE_RANGE_FINDER = "61605ddea09d851a0a0c1bbc",
     ITEM = "54009119af1c881c07000029",
     CYLINDER_MAGAZINE = "610720f290b75a49ff2e5e25",
-    AUXILARY_MOD = "5a74651486f7744e73386dd1",
+    AUXILIARY_MOD = "5a74651486f7744e73386dd1",
     BIPOD = "55818afb4bdc2dde698b456d",
     HEADPHONES = "5645bcb74bdc2ded0b8b4578",
     RANDOM_LOOT_CONTAINER = "62f109593b54472778797866",
@@ -103,5 +103,11 @@ export declare enum BaseClasses {
     BUILT_IN_INSERTS = "65649eb40bf0ed77b8044453",
     ARMOR_PLATE = "644120aa86ffbe10ee032b6f",
     CULTIST_AMULET = "64b69b0c8f3be32ed22682f8",
-    RADIO_TRANSMITTER = "62e9103049c018f425059f38"
+    RADIO_TRANSMITTER = "62e9103049c018f425059f38",
+    HANDGUARD = "55818a104bdc2db9688b4569",
+    PISTOL_GRIP = "55818a684bdc2ddd698b456d",
+    RECEIVER = "55818a304bdc2db5418b457d",
+    BARREL = "555ef6e44bdc2de9068b457e",
+    CHARGING_HANDLE = "55818a6f4bdc2db9688b456b",
+    COMB_MUZZLE_DEVICE = "550aa4dd4bdc2dc9348b4569 "
 }

types/models/enums/BonusType.d.ts

@@ -28,5 +28,6 @@ export declare enum BonusType {
     STASH_SIZE = "StashSize",
     MAXIMUM_ENERGY_RESERVE = "MaximumEnergyReserve",
     TEXT_BONUS = "TextBonus",
-    SKILL_GROUP_LEVELING_BOOST = "SkillGroupLevelingBoost"
+    SKILL_GROUP_LEVELING_BOOST = "SkillGroupLevelingBoost",
+    STASH_ROWS = "StashRows"
 }

types/models/enums/WildSpawnTypeNumber.d.ts

@@ -39,6 +39,12 @@ export declare enum WildSpawnTypeNumber {
     PEACEFULLZRYACHIYEVENT = 38,
     SECTACTPRIESTEVENT = 39,
     RAVANGEZRYACHIYEVENT = 40,
-    SPTUSEC = 41,
+    FOLLOWERBOARCLOSE1 = 41,
-    SPTBEAR = 42
+    FOLLOWERBOARCLOSE2 = 42,
+    BOSSKOLONTAY = 43,
+    FOLLOWERKOLONTAYASSAULT = 44,
+    FOLLOWERKOLONTAYSECURITY = 45,
+    SHOOTERBTR = 46,
+    SPTUSEC = 47,
+    SPTBEAR = 48
 }

types/models/spt/bots/IBotLootCache.d.ts

@@ -1,15 +1,14 @@
-import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
 export interface IBotLootCache {
-    backpackLoot: ITemplateItem[];
+    backpackLoot: Record<string, number>;
-    pocketLoot: ITemplateItem[];
+    pocketLoot: Record<string, number>;
-    vestLoot: ITemplateItem[];
+    vestLoot: Record<string, number>;
-    secureLoot: ITemplateItem[];
+    secureLoot: Record<string, number>;
-    combinedPoolLoot: ITemplateItem[];
+    combinedPoolLoot: Record<string, number>;
-    specialItems: ITemplateItem[];
+    specialItems: Record<string, number>;
-    healingItems: ITemplateItem[];
+    healingItems: Record<string, number>;
-    drugItems: ITemplateItem[];
+    drugItems: Record<string, number>;
-    stimItems: ITemplateItem[];
+    stimItems: Record<string, number>;
-    grenadeItems: ITemplateItem[];
+    grenadeItems: Record<string, number>;
 }
 export declare enum LootCacheType {
     SPECIAL = "Special",

types/models/spt/bots/IItemSpawnLimitSettings.d.ts

@@ -0,0 +1,4 @@
+export interface IItemSpawnLimitSettings {
+    currentLimits: Record<string, number>;
+    globalLimits: Record<string, number>;
+}

types/models/spt/config/IBaseConfig.d.ts

@@ -1,3 +1,7 @@
 export interface IBaseConfig {
     kind: string;
 }
+export interface IRunIntervalValues {
+    inRaid: number;
+    outOfRaid: number;
+}

types/models/spt/config/IBotConfig.d.ts

@@ -14,8 +14,6 @@ export interface IBotConfig extends IBaseConfig {
     durability: IBotDurability;
     /** Controls the percentage values of randomization item resources */
     lootItemResourceRandomization: Record<string, IRandomisedResourceDetails>;
-    /** Control the weighting of how expensive an average loot item is on a PMC or Scav */
-    lootNValue: LootNvalue;
     /** Control what bots are added to a bots revenge list key: bottype, value: bottypes to revenge on seeing their death */
     revenge: Record<string, string[]>;
     /** Control how many items are allowed to spawn on a bot
@@ -37,6 +35,10 @@ export interface IBotConfig extends IBaseConfig {
     secureContainerAmmoStackCount: number;
     /** Bot roles in this array will be given a dog tag on generation */
     botRolesWithDogTags: string[];
+    /** Settings to control the items that get added into wallets on bots */
+    walletLoot: IWalletLootSettings;
+    /** Currency weights, Keyed by botrole / currency */
+    currencyStackSize: Record<string, Record<string, Record<string, number>>>;
 }
 /** Number of bots to generate and store in cache on raid start per bot type */
 export interface PresetBatch {
@@ -77,9 +79,14 @@ export interface PresetBatch {
     sptUsec: number;
     sptBear: number;
 }
-export interface LootNvalue {
+export interface IWalletLootSettings {
-    scav: number;
+    /** Chance wallets have loot in them */
-    pmc: number;
+    chancePercent: number;
+    itemCount: MinMax;
+    stackSizeWeight: Record<string, number>;
+    currencyWeight: Record<string, number>;
+    /** What wallets will have money in them */
+    walletTplPool: string[];
 }
 export interface EquipmentFilters {
     /** Limits for mod types per weapon .e.g. scopes */

types/models/spt/config/ICoreConfig.d.ts

@@ -7,6 +7,8 @@ export interface ICoreConfig extends IBaseConfig {
     serverName: string;
     profileSaveIntervalSeconds: number;
     sptFriendNickname: string;
+    bsgLogging: IBsgLogging;
+    release: IRelease;
     fixes: IGameFixes;
     features: IServerFeatures;
     /** Commit hash build server was created from */
@@ -14,6 +16,37 @@ export interface ICoreConfig extends IBaseConfig {
     /** Timestamp of server build */
     buildTime?: string;
 }
+export interface IBsgLogging {
+    /**
+     * verbosity of what to log, yes I know this is backwards, but its how nlog deals with ordinals.
+     * complain to them about it! In all cases, better exceptions will be logged.
+     * WARNING: trace-info logging will quickly create log files in the megabytes.
+     * 0 - trace
+     * 1 - debug
+     * 2 - info
+     * 3 - warn
+     * 4 - error
+     * 5 - fatal
+     * 6 - off
+     */
+    verbosity: number;
+    sendToServer: boolean;
+}
+export interface IRelease {
+    betaDisclaimerText?: string;
+    betaDisclaimerAcceptText: string;
+    serverModsLoadedText: string;
+    serverModsLoadedDebugText: string;
+    clientModsLoadedText: string;
+    clientModsLoadedDebugText: string;
+    illegalPluginsLoadedText: string;
+    illegalPluginsExceptionText: string;
+    releaseSummaryText?: string;
+    isBeta?: boolean;
+    isModdable?: boolean;
+    isModded: boolean;
+    betaDisclaimerTimeoutDelay: number;
+}
 export interface IGameFixes {
     /** Shotguns use a different value than normal guns causing huge pellet dispersion  */
     fixShotgunDispersion: boolean;

types/models/spt/config/IHideoutConfig.d.ts

@@ -1,7 +1,10 @@
-import { IBaseConfig } from "@spt-aki/models/spt/config/IBaseConfig";
+import { IBaseConfig, IRunIntervalValues } from "@spt-aki/models/spt/config/IBaseConfig";
 export interface IHideoutConfig extends IBaseConfig {
     kind: "aki-hideout";
+    /** How many seconds should pass before hideout crafts / fuel usage is checked and procesed */
     runIntervalSeconds: number;
+    /** Default values used to hydrate `runIntervalSeconds` with */
+    runIntervalValues: IRunIntervalValues;
     hoursForSkillCrafting: number;
     expCraftAmount: number;
 }

types/models/spt/config/IInRaidConfig.d.ts

@@ -20,6 +20,8 @@ export interface IInRaidConfig extends IBaseConfig {
     pmcKillProbabilityForScavGain: number;
     /** On death should items in your secure keep their Find in raid status regardless of how you finished the raid */
     keepFiRSecureContainerOnDeath: boolean;
+    /** Percentage chance a player scav hot is hostile to the player when scavving */
+    playerScavHostileChancePercent: number;
 }
 export interface RaidMenuSettings {
     aiAmount: string;

types/models/spt/config/IInventoryConfig.d.ts

@@ -8,6 +8,8 @@ export interface IInventoryConfig extends IBaseConfig {
     sealedAirdropContainer: ISealedAirdropContainerSettings;
     /** Contains item tpls that the server should consider money and treat the same as roubles/euros/dollars */
     customMoneyTpls: string[];
+    /** Multipliers for skill gain when inside menus, NOT in-game */
+    skillGainMultiplers: Record<string, number>;
 }
 export interface RewardDetails {
     rewardCount: number;

types/models/spt/config/IItemConfig.d.ts

@@ -3,6 +3,8 @@ export interface IItemConfig extends IBaseConfig {
     kind: "aki-item";
     /** Items that should be globally blacklisted */
     blacklist: string[];
+    /** items that should not be given as rewards */
+    rewardItemBlacklist: string[];
     /** Items that can only be found on bosses */
     bossItems: string[];
     handbookPriceOverride: Record<string, number>;

types/models/spt/config/ILocationConfig.d.ts

@@ -42,6 +42,8 @@ export interface ILocationConfig extends IBaseConfig {
     scavRaidTimeSettings: IScavRaidTimeSettings;
     /** Settings to adjust mods for lootable equipment in raid */
     equipmentLootSettings: IEquipmentLootSettings;
+    /** Sets the max Patrol Value of the Boxzone on the map Ground Zero*/
+    sandboxMaxPatrolvalue: number;
 }
 export interface IEquipmentLootSettings {
     modSpawnChancePercent: Record<string, number>;

types/models/spt/config/ILostOnDeathConfig.d.ts

@@ -16,6 +16,7 @@ export interface Equipment {
     ArmorVest: boolean;
     Eyewear: boolean;
     TacticalVest: boolean;
+    PocketItems: boolean;
     Backpack: boolean;
     Holster: boolean;
     FirstPrimaryWeapon: boolean;

types/models/spt/config/IPlayerScavConfig.d.ts

@@ -9,7 +9,7 @@ export interface KarmaLevel {
     modifiers: Modifiers;
     itemLimits: ItemLimits;
     equipmentBlacklist: Record<string, string[]>;
-    labsAccessCardChancePercent: number;
+    lootItemsToAddChancePercent: Record<string, number>;
 }
 export interface Modifiers {
     equipment: Record<string, number>;

types/models/spt/config/IPmcConfig.d.ts

@@ -13,7 +13,6 @@ export interface IPmcConfig extends IBaseConfig {
     pocketLoot: SlotLootSettings;
     /** Global whitelist/blacklist of backpack loot for PMCs */
     backpackLoot: SlotLootSettings;
-    dynamicLoot: DynamicLoot;
     /** Use difficulty defined in config/bot.json/difficulty instead of chosen difficulty dropdown value */
     useDifficultyOverride: boolean;
     /** Difficulty override e.g. "AsOnline/Hard" */
@@ -55,8 +54,4 @@ export interface PmcTypes {
 export interface SlotLootSettings {
     whitelist: string[];
     blacklist: string[];
-    moneyStackLimits: Record<string, number>;
-}
-export interface DynamicLoot {
-    moneyStackLimits: Record<string, number>;
 }

types/models/spt/config/IRagfairConfig.d.ts

@@ -1,9 +1,11 @@
 import { MinMax } from "@spt-aki/models/common/MinMax";
-import { IBaseConfig } from "@spt-aki/models/spt/config/IBaseConfig";
+import { IBaseConfig, IRunIntervalValues } from "@spt-aki/models/spt/config/IBaseConfig";
 export interface IRagfairConfig extends IBaseConfig {
     kind: "aki-ragfair";
     /** How many seconds should pass before expired offers and procesed + player offers checked if sold */
     runIntervalSeconds: number;
+    /** Default values used to hydrate `runIntervalSeconds` with */
+    runIntervalValues: IRunIntervalValues;
     /** Player listing settings */
     sell: Sell;
     /** Trader ids + should their assorts be listed on flea*/
@@ -16,9 +18,7 @@ export interface Sell {
     /** Settings to control chances of offer being sold */
     chance: Chance;
     /** Settings to control how long it takes for a player offer to sell */
-    time: Time;
+    time: MinMax;
-    /** Player offer reputation gain/loss settings */
-    reputation: Reputation;
     /**Seconds from clicking remove to remove offer from market */
     expireSeconds: number;
 }
@@ -32,13 +32,6 @@ export interface Chance {
     /** Min possible sell chance % for a player listed offer */
     minSellChancePercent: number;
 }
-export interface Time extends MinMax {
-    base: number;
-}
-export interface Reputation {
-    gain: number;
-    loss: number;
-}
 export interface Dynamic {
     purchasesAreFoundInRaid: boolean;
     /** Use the highest trader price for an offer if its greater than the price in templates/prices.json */
@@ -65,6 +58,8 @@ export interface Dynamic {
     nonStackableCount: MinMax;
     /** Range of rating offers for items being listed */
     rating: MinMax;
+    /** Armor specific flea settings */
+    armor: IArmorSettings;
     /** A multipler to apply to individual tpls price just prior to item quality adjustment */
     itemPriceMultiplier: Record<string, number>;
     /** Percentages to sell offers in each currency */
@@ -136,6 +131,10 @@ export interface Blacklist {
     traderItems: boolean;
     /** Maximum level an armor plate can be found in a flea-listed armor item */
     armorPlate: IArmorPlateBlacklistSettings;
+    /** Should specific categories be blacklisted from the flea, true = use blacklist */
+    enableCustomItemCategoryList: boolean;
+    /** Custom category blacklist for parent Ids */
+    customItemCategoryList: string[];
 }
 export interface IArmorPlateBlacklistSettings {
     /** Max level of plates an armor can have without being removed */
@@ -151,3 +150,9 @@ export interface IUnreasonableModPrices {
     /** The new multiplier for items found using above property, e.g. a value of 4 means set items price to 4x handbook price */
     newPriceHandbookMultiplier: number;
 }
+export interface IArmorSettings {
+    /** % chance / 100 that armor plates will be removed from an offer before listing */
+    removeRemovablePlateChance: number;
+    /** What slots are to be removed when removeRemovablePlateChance is true */
+    plateSlotIdToRemovePool: string[];
+}

types/models/spt/config/ITraderConfig.d.ts

@@ -5,15 +5,16 @@ export interface ITraderConfig extends IBaseConfig {
     kind: "aki-trader";
     updateTime: UpdateTime[];
     purchasesAreFoundInRaid: boolean;
+    /** Should trader reset times be set based on server start time (false = bsg time - on the hour) */
+    tradersResetFromServerStart: boolean;
     updateTimeDefault: number;
     traderPriceMultipler: number;
-    /** Keep track of purchased trader-limited items beyond server restarts to prevent server-restart item scumming */
-    persistPurchaseDataInProfile: boolean;
     fence: FenceConfig;
 }
 export interface UpdateTime {
     traderId: string;
-    seconds: number;
+    /** Seconds between trader resets */
+    seconds: MinMax;
 }
 export interface FenceConfig {
     discountOptions: DiscountOptions;
@@ -24,12 +25,14 @@ export interface FenceConfig {
     equipmentPresetMinMax: MinMax;
     itemPriceMult: number;
     presetPriceMult: number;
-    armorMaxDurabilityPercentMinMax: MinMax;
+    armorMaxDurabilityPercentMinMax: IItemDurabilityCurrentMax;
-    presetMaxDurabilityPercentMinMax: MinMax;
+    weaponDurabilityPercentMinMax: IItemDurabilityCurrentMax;
     chancePlateExistsInArmorPercent: number;
     /** Key: item tpl */
     itemStackSizeOverrideMinMax: Record<string, MinMax>;
     itemTypeLimits: Record<string, number>;
+    /** Prevent duplicate offers of items of specific categories by parentId*/
+    preventDuplicateOffersOfCategory: string[];
     regenerateAssortsOnRefresh: boolean;
     /** Max rouble price before item is not listed on flea */
     itemCategoryRoublePriceLimit: Record<string, number>;
@@ -41,6 +44,10 @@ export interface FenceConfig {
     coopExtractGift: CoopExtractReward;
     btrDeliveryExpireHours: number;
 }
+export interface IItemDurabilityCurrentMax {
+    current: MinMax;
+    max: MinMax;
+}
 export interface CoopExtractReward extends LootRequest {
     sendGift: boolean;
     messageLocaleIds: string[];

types/models/spt/generators/IBotGenerator.d.ts

@@ -3,8 +3,3 @@ import { Chances, Generation, Inventory } from "@spt-aki/models/eft/common/table
 export interface IBotGenerator {
     generateInventory(templateInventory: Inventory, equipmentChances: Chances, generation: Generation, botRole: string, isPmc: boolean): PmcInventory;
 }
-export interface IExhaustableArray<T> {
-    getRandomValue(): T;
-    getFirstValue(): T;
-    hasValues(): boolean;
-}

types/models/spt/logging/LogTextColor.d.ts

@@ -7,5 +7,5 @@ export declare enum LogTextColor {
     MAGENTA = "magenta",
     CYAN = "cyan",
     WHITE = "white",
-    GRAY = ""
+    GRAY = "gray"
 }

types/models/spt/server/ExhaustableArray.d.ts

@@ -0,0 +1,17 @@
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
+import { RandomUtil } from "@spt-aki/utils/RandomUtil";
+export declare class ExhaustableArray<T> implements IExhaustableArray<T> {
+    private itemPool;
+    private randomUtil;
+    private jsonUtil;
+    private pool;
+    constructor(itemPool: T[], randomUtil: RandomUtil, jsonUtil: JsonUtil);
+    getRandomValue(): T;
+    getFirstValue(): T;
+    hasValues(): boolean;
+}
+export interface IExhaustableArray<T> {
+    getRandomValue(): T;
+    getFirstValue(): T;
+    hasValues(): boolean;
+}

types/models/spt/server/ILocations.d.ts

@@ -1,28 +1,23 @@
-import { ILocationBase } from "@spt-aki/models/eft/common/ILocationBase";
+import { ILocation } from "@spt-aki/models/eft/common/ILocation";
-import { ILooseLoot } from "@spt-aki/models/eft/common/ILooseLoot";
 import { ILocationsBase } from "@spt-aki/models/eft/common/tables/ILocationsBase";
 export interface ILocations {
-    bigmap?: ILocationData;
+    bigmap?: ILocation;
-    develop?: ILocationData;
+    develop?: ILocation;
-    factory4_day?: ILocationData;
+    factory4_day?: ILocation;
-    factory4_night?: ILocationData;
+    factory4_night?: ILocation;
-    hideout?: ILocationData;
+    hideout?: ILocation;
-    interchange?: ILocationData;
+    interchange?: ILocation;
-    laboratory?: ILocationData;
+    laboratory?: ILocation;
-    lighthouse?: ILocationData;
+    lighthouse?: ILocation;
-    privatearea?: ILocationData;
+    privatearea?: ILocation;
-    rezervbase?: ILocationData;
+    rezervbase?: ILocation;
-    shoreline?: ILocationData;
+    shoreline?: ILocation;
-    suburbs?: ILocationData;
+    suburbs?: ILocation;
-    tarkovstreets?: ILocationData;
+    tarkovstreets?: ILocation;
-    terminal?: ILocationData;
+    terminal?: ILocation;
-    town?: ILocationData;
+    town?: ILocation;
-    woods?: ILocationData;
+    woods?: ILocation;
-    sandbox?: ILocationData;
+    sandbox?: ILocation;
     /** Holds a mapping of the linkages between locations on the UI */
     base?: ILocationsBase;
 }
-export interface ILocationData {
-    base: ILocationBase;
-    looseLoot?: ILooseLoot;
-}

types/models/spt/services/ITraderServiceModel.d.ts

@@ -1,6 +1,18 @@
 import { TraderServiceType } from "@spt-aki/models/enums/TraderServiceType";
 export interface ITraderServiceModel {
     serviceType: TraderServiceType;
-    itemsToPay?: Record<string, number>[];
+    itemsToPay?: {
-    subServices?: Record<string, number>[];
+        [key: string]: number;
+    };
+    itemsToReceive?: string[];
+    subServices?: {
+        [key: string]: number;
+    };
+    requirements?: ITraderServiceRequirementsModel;
+}
+export interface ITraderServiceRequirementsModel {
+    completedQuests?: string[];
+    standings?: {
+        [key: string]: number;
+    };
 }

types/routers/ItemEventRouter.d.ts

@@ -5,13 +5,15 @@ import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEve
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 export declare class ItemEventRouter {
     protected logger: ILogger;
+    protected jsonUtil: JsonUtil;
     protected profileHelper: ProfileHelper;
     protected itemEventRouters: ItemEventRouterDefinition[];
     protected localisationService: LocalisationService;
     protected eventOutputHolder: EventOutputHolder;
-    constructor(logger: ILogger, profileHelper: ProfileHelper, itemEventRouters: ItemEventRouterDefinition[], localisationService: LocalisationService, eventOutputHolder: EventOutputHolder);
+    constructor(logger: ILogger, jsonUtil: JsonUtil, profileHelper: ProfileHelper, itemEventRouters: ItemEventRouterDefinition[], localisationService: LocalisationService, eventOutputHolder: EventOutputHolder);
     /**
      * @param info Event request
      * @param sessionID Session id

types/routers/item_events/HideoutItemEventRouter.d.ts

@@ -6,5 +6,5 @@ export declare class HideoutItemEventRouter extends ItemEventRouterDefinition {
     protected hideoutCallbacks: HideoutCallbacks;
     constructor(hideoutCallbacks: HideoutCallbacks);
     getHandledRoutes(): HandledRoute[];
-    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string): IItemEventRouterResponse;
+    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
 }

types/routers/item_events/InventoryItemEventRouter.d.ts

@@ -8,5 +8,5 @@ export declare class InventoryItemEventRouter extends ItemEventRouterDefinition
     protected hideoutCallbacks: HideoutCallbacks;
     constructor(inventoryCallbacks: InventoryCallbacks, hideoutCallbacks: HideoutCallbacks);
     getHandledRoutes(): HandledRoute[];
-    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string): IItemEventRouterResponse;
+    handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
 }

types/servers/HttpServer.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import http, { IncomingMessage, ServerResponse } from "node:http";
+import { IncomingMessage, ServerResponse } from "node:http";
 import { ApplicationContext } from "@spt-aki/context/ApplicationContext";
 import { HttpServerHelper } from "@spt-aki/helpers/HttpServerHelper";
 import { IHttpConfig } from "@spt-aki/models/spt/config/IHttpConfig";
@@ -25,5 +25,5 @@ export declare class HttpServer {
      */
     load(): void;
     protected handleRequest(req: IncomingMessage, resp: ServerResponse): void;
-    protected getCookies(req: http.IncomingMessage): Record<string, string>;
+    protected getCookies(req: IncomingMessage): Record<string, string>;
 }

types/servers/SaveServer.d.ts

@@ -75,8 +75,9 @@ export declare class SaveServer {
      * Save changes from in-memory profile to user/profiles json
      * Execute onBeforeSaveCallbacks callbacks prior to being saved to json
      * @param sessionID profile id (user/profiles/id.json)
+     * @returns time taken to save in MS
      */
-    saveProfile(sessionID: string): void;
+    saveProfile(sessionID: string): number;
     /**
      * Remove a physical profile json from user/profiles
      * @param sessionID Profile id to remove

types/services/BotGenerationCacheService.d.ts

@@ -11,6 +11,7 @@ export declare class BotGenerationCacheService {
     protected localisationService: LocalisationService;
     protected botHelper: BotHelper;
     protected storedBots: Map<string, IBotBase[]>;
+    protected activeBotsInRaid: IBotBase[];
     constructor(logger: ILogger, randomUtil: RandomUtil, jsonUtil: JsonUtil, localisationService: LocalisationService, botHelper: BotHelper);
     /**
      * Store array of bots in cache, shuffle results before storage
@@ -24,6 +25,18 @@ export declare class BotGenerationCacheService {
      * @returns IBotBase object
      */
     getBot(key: string): IBotBase;
+    /**
+     * Cache a bot that has been sent to the client in memory for later use post-raid to determine if player killed a traitor scav
+     * @param botToStore Bot object to store
+     */
+    storeUsedBot(botToStore: IBotBase): void;
+    /**
+     * Get a bot by its profileId that has been generated and sent to client for current raid
+     * Cache is wiped post-raid in client/match/offline/end  endOfflineRaid()
+     * @param profileId Id of bot to get
+     * @returns IBotBase
+     */
+    getUsedBot(profileId: string): IBotBase;
     /**
      * Remove all cached bot profiles from memory
      */

types/services/BotLootCacheService.d.ts

@@ -30,7 +30,7 @@ export declare class BotLootCacheService {
      * @param botJsonTemplate Base json db file for the bot having its loot generated
      * @returns ITemplateItem array
      */
-    getLootFromCache(botRole: string, isPmc: boolean, lootType: LootCacheType, botJsonTemplate: IBotType): ITemplateItem[];
+    getLootFromCache(botRole: string, isPmc: boolean, lootType: LootCacheType, botJsonTemplate: IBotType): Record<string, number>;
     /**
      * Generate loot for a bot and store inside a private class property
      * @param botRole bots role (assault / pmcBot etc)
@@ -38,17 +38,13 @@ export declare class BotLootCacheService {
      * @param botJsonTemplate db template for bot having its loot generated
      */
     protected addLootToCache(botRole: string, isPmc: boolean, botJsonTemplate: IBotType): void;
-    /**
-     * Sort a pool of item objects by its flea price
-     * @param poolToSort pool of items to sort
-     */
-    protected sortPoolByRagfairPrice(poolToSort: ITemplateItem[]): void;
     /**
      * Add unique items into combined pool
-     * @param combinedItemPool Pool of items to add to
+     * @param poolToAddTo Pool of items to add to
      * @param itemsToAdd items to add to combined pool if unique
      */
-    protected addUniqueItemsToPool(combinedItemPool: ITemplateItem[], itemsToAdd: ITemplateItem[]): void;
+    protected addUniqueItemsToPool(poolToAddTo: ITemplateItem[], itemsToAdd: ITemplateItem[]): void;
+    protected addItemsToPool(poolToAddTo: Record<string, number>, poolOfItemsToAdd: Record<string, number>): void;
     /**
      * Ammo/grenades have this property
      * @param props

types/services/FenceService.d.ts

@@ -1,13 +1,12 @@
 import { HandbookHelper } from "@spt-aki/helpers/HandbookHelper";
 import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
 import { PresetHelper } from "@spt-aki/helpers/PresetHelper";
-import { MinMax } from "@spt-aki/models/common/MinMax";
 import { IFenceLevel } from "@spt-aki/models/eft/common/IGlobals";
 import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
 import { Item, Repairable } from "@spt-aki/models/eft/common/tables/IItem";
 import { ITemplateItem } from "@spt-aki/models/eft/common/tables/ITemplateItem";
-import { ITraderAssort } from "@spt-aki/models/eft/common/tables/ITrader";
+import { IBarterScheme, ITraderAssort } from "@spt-aki/models/eft/common/tables/ITrader";
-import { ITraderConfig } from "@spt-aki/models/spt/config/ITraderConfig";
+import { IItemDurabilityCurrentMax, ITraderConfig } from "@spt-aki/models/spt/config/ITraderConfig";
 import { IFenceAssortGenerationValues, IGenerationAssortValues } from "@spt-aki/models/spt/fence/IFenceAssortGenerationValues";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
@@ -64,7 +63,7 @@ export declare class FenceService {
      * @param itemMultipler multipler to use on items
      * @param presetMultiplier preset multipler to use on presets
      */
-    protected adjustAssortItemPrices(assort: ITraderAssort, itemMultipler: number, presetMultiplier: number): void;
+    protected adjustAssortItemPricesByConfigMultiplier(assort: ITraderAssort, itemMultipler: number, presetMultiplier: number): void;
     /**
      * Merge two trader assort files together
      * @param firstAssort assort 1#
@@ -153,14 +152,44 @@ export declare class FenceService {
      * Add item assorts to existing assort data
      * @param assortCount Number to add
      * @param assorts Assorts data to add to
-     * @param baseFenceAssort Base data to draw from
+     * @param baseFenceAssortClone Base data to draw from
-     * @param itemTypeCounts
+     * @param itemTypeLimits
      * @param loyaltyLevel Loyalty level to set new item to
      */
-    protected addItemAssorts(assortCount: number, assorts: ITraderAssort, baseFenceAssort: ITraderAssort, itemTypeCounts: Record<string, {
+    protected addItemAssorts(assortCount: number, assorts: ITraderAssort, baseFenceAssortClone: ITraderAssort, itemTypeLimits: Record<string, {
         current: number;
         max: number;
     }>, loyaltyLevel: number): void;
+    /**
+     * Find an assort item that matches the first parameter, also matches based on upd properties
+     * e.g. salewa hp resource units left
+     * @param rootItemBeingAdded item to look for a match against
+     * @param itemDbDetails Db details of matching item
+     * @param fenceItemAssorts Items to search through
+     * @returns Matching assort item
+     */
+    protected getMatchingItem(rootItemBeingAdded: Item, itemDbDetails: ITemplateItem, fenceItemAssorts: Item[]): Item;
+    /**
+     * Should this item be forced into only 1 stack on fence
+     * @param existingItem Existing item from fence assort
+     * @param itemDbDetails Item we want to add db details
+     * @returns True item should be force stacked
+     */
+    protected itemShouldBeForceStacked(existingItem: Item, itemDbDetails: ITemplateItem): boolean;
+    /**
+     * Adjust price of item based on what is left to buy (resource/uses left)
+     * @param barterSchemes All barter scheme for item having price adjusted
+     * @param itemRoot Root item having price adjusted
+     * @param itemTemplate Db template of item
+     */
+    protected adjustItemPriceByQuality(barterSchemes: Record<string, IBarterScheme[][]>, itemRoot: Item, itemTemplate: ITemplateItem): void;
+    protected getMatchingItemLimit(itemTypeLimits: Record<string, {
+        current: number;
+        max: number;
+    }>, itemTpl: string): {
+        current: number;
+        max: number;
+    };
     /**
      * Find presets in base fence assort and add desired number to 'assorts' parameter
      * @param desiredWeaponPresetsCount
@@ -202,10 +231,10 @@ export declare class FenceService {
     /**
      * Generate a randomised current and max durabiltiy value for an armor item
      * @param itemDetails Item to create values for
-     * @param maxDurabilityMinMaxPercent Max durabiltiy percent min/max values
+     * @param equipmentDurabilityLimits Max durabiltiy percent min/max values
      * @returns Durability + MaxDurability values
      */
-    protected getRandomisedArmorDurabilityValues(itemDetails: ITemplateItem, maxDurabilityMinMaxPercent: MinMax): Repairable;
+    protected getRandomisedArmorDurabilityValues(itemDetails: ITemplateItem, equipmentDurabilityLimits: IItemDurabilityCurrentMax): Repairable;
     /**
      * Construct item limit record to hold max and current item count
      * @param limits limits as defined in config

types/services/InsuranceService.d.ts

@@ -70,12 +70,6 @@ export declare class InsuranceService {
      * @param mapId Id of the map player died/exited that caused the insurance to be issued on
      */
     sendInsuredItems(pmcData: IPmcData, sessionID: string, mapId: string): void;
-    /**
-     * Send a message to player informing them gear was completely lost
-     * @param sessionId Session id
-     * @param locationName name of map insurance was lost on
-     */
-    sendLostInsuranceMessage(sessionId: string, locationName?: string): void;
     /**
      * Check all root insured items and remove location property + set slotId to 'hideout'
      * @param sessionId Session id

types/services/ItemFilterService.d.ts

@@ -15,6 +15,17 @@ export declare class ItemFilterService {
      * @returns true if blacklisted
      */
     isItemBlacklisted(tpl: string): boolean;
+    /**
+     * Check if item is blacklisted from being a reward for player
+     * @param tpl item tpl to check is on blacklist
+     * @returns True when blacklisted
+     */
+    isItemRewardBlacklisted(tpl: string): boolean;
+    /**
+     * Get an array of items that should never be given as a reward to player
+     * @returns string array of item tpls
+     */
+    getItemRewardBlacklist(): string[];
     /**
      * Return every template id blacklisted in config/item.json
      * @returns string array of blacklisted tempalte ids

types/services/MatchLocationService.d.ts

@@ -1,4 +1,3 @@
-import { ICreateGroupRequestData } from "@spt-aki/models/eft/match/ICreateGroupRequestData";
 import { SaveServer } from "@spt-aki/servers/SaveServer";
 import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 export declare class MatchLocationService {
@@ -6,6 +5,5 @@ export declare class MatchLocationService {
     protected saveServer: SaveServer;
     protected locations: {};
     constructor(timeUtil: TimeUtil, saveServer: SaveServer);
-    createGroup(sessionID: string, info: ICreateGroupRequestData): any;
     deleteGroup(info: any): void;
 }

types/services/ModCompilerService.d.ts

@@ -1,13 +1,13 @@
 import ts from "typescript";
 import type { ILogger } from "@spt-aki/models/spt/utils/ILogger";
-import { HashCacheService } from "@spt-aki/services/HashCacheService";
+import { ModHashCacheService } from "@spt-aki/services/cache/ModHashCacheService";
 import { VFS } from "@spt-aki/utils/VFS";
 export declare class ModCompilerService {
     protected logger: ILogger;
-    protected hashCacheService: HashCacheService;
+    protected modHashCacheService: ModHashCacheService;
     protected vfs: VFS;
     protected serverDependencies: string[];
-    constructor(logger: ILogger, hashCacheService: HashCacheService, vfs: VFS);
+    constructor(logger: ILogger, modHashCacheService: ModHashCacheService, vfs: VFS);
     /**
      * Convert a mods TS into JS
      * @param modName Name of mod

types/services/PaymentService.d.ts

@@ -27,12 +27,12 @@ export declare class PaymentService {
     constructor(logger: ILogger, hashUtil: HashUtil, httpResponse: HttpResponseUtil, databaseServer: DatabaseServer, handbookHelper: HandbookHelper, traderHelper: TraderHelper, itemHelper: ItemHelper, inventoryHelper: InventoryHelper, localisationService: LocalisationService, paymentHelper: PaymentHelper);
     /**
      * Take money and insert items into return to server request
-     * @param {IPmcData} pmcData Player profile
+     * @param pmcData Pmc profile
-     * @param {IProcessBuyTradeRequestData} request
+     * @param request Buy item request
-     * @param {string} sessionID
+     * @param sessionID Session id
-     * @returns IItemEventRouterResponse
+     * @param output Client response
      */
-    payMoney(pmcData: IPmcData, request: IProcessBuyTradeRequestData, sessionID: string, output: IItemEventRouterResponse): IItemEventRouterResponse;
+    payMoney(pmcData: IPmcData, request: IProcessBuyTradeRequestData, sessionID: string, output: IItemEventRouterResponse): void;
     /**
      * Get the item price of a specific traders assort
      * @param traderAssortId Id of assort to look up

types/services/RagfairPriceService.d.ts

@@ -73,7 +73,7 @@ export declare class RagfairPriceService implements OnLoad {
      */
     getStaticPriceForItem(itemTpl: string): number;
     /**
-     * Get prices for all items on flea, priorities dynamic prices from prices.json, use handbook prices if missing
+     * Get prices for all items on flea, prioritize handbook prices first, use prices from prices.json if missing
      * @returns Dictionary of item tpls and rouble cost
      */
     getAllFleaPrices(): Record<string, number>;
@@ -93,12 +93,12 @@ export declare class RagfairPriceService implements OnLoad {
     getBarterPrice(barterScheme: IBarterScheme[]): number;
     /**
      * Generate a currency cost for an item and its mods
-     * @param items Item with mods to get price for
+     * @param offerItems Item with mods to get price for
      * @param desiredCurrency Currency price desired in
      * @param isPackOffer Price is for a pack type offer
      * @returns cost of item in desired currency
      */
-    getDynamicOfferPriceForOffer(items: Item[], desiredCurrency: string, isPackOffer: boolean): number;
+    getDynamicOfferPriceForOffer(offerItems: Item[], desiredCurrency: string, isPackOffer: boolean): number;
     /**
      * using data from config, adjust an items price to be relative to its handbook price
      * @param handbookPrices Prices of items in handbook

types/services/TraderPurchasePersisterService.d.ts

@@ -4,6 +4,7 @@ import { ITraderConfig } from "@spt-aki/models/spt/config/ITraderConfig";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { ConfigServer } from "@spt-aki/servers/ConfigServer";
 import { LocalisationService } from "@spt-aki/services/LocalisationService";
+import { RandomUtil } from "@spt-aki/utils/RandomUtil";
 import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 /**
  * Help with storing limited item purchases from traders in profile to persist them over server restarts
@@ -11,11 +12,12 @@ import { TimeUtil } from "@spt-aki/utils/TimeUtil";
 export declare class TraderPurchasePersisterService {
     protected logger: ILogger;
     protected timeUtil: TimeUtil;
+    protected randomUtil: RandomUtil;
     protected profileHelper: ProfileHelper;
     protected localisationService: LocalisationService;
     protected configServer: ConfigServer;
     protected traderConfig: ITraderConfig;
-    constructor(logger: ILogger, timeUtil: TimeUtil, profileHelper: ProfileHelper, localisationService: LocalisationService, configServer: ConfigServer);
+    constructor(logger: ILogger, timeUtil: TimeUtil, randomUtil: RandomUtil, profileHelper: ProfileHelper, localisationService: LocalisationService, configServer: ConfigServer);
     /**
      * Get the purchases made from a trader for this profile before the last trader reset
      * @param sessionId Session id

types/services/TraderServicesService.d.ts

@@ -1,9 +1,13 @@
+import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
 import { ITraderServiceModel } from "@spt-aki/models/spt/services/ITraderServiceModel";
 import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
 import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
+import { JsonUtil } from "@spt-aki/utils/JsonUtil";
 export declare class TraderServicesService {
+    protected profileHelper: ProfileHelper;
+    protected jsonUtil: JsonUtil;
     protected logger: ILogger;
     protected databaseServer: DatabaseServer;
-    constructor(logger: ILogger, databaseServer: DatabaseServer);
+    constructor(profileHelper: ProfileHelper, jsonUtil: JsonUtil, logger: ILogger, databaseServer: DatabaseServer);
-    getTraderServices(traderId: string): ITraderServiceModel[];
+    getTraderServices(sessionId: string, traderId: string): ITraderServiceModel[];
 }