marvinlehmann/SPT-NivramTweaks
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial release for SPT 3.9

Browse Source
This commit is contained in:
Marvin Lehmann
2024-07-20 18:08:38 +02:00
parent 7df25ba694
commit c83da69a3e
713 changed files with 34110 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
types/models/spt/bindings/Route.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
export interface IRoute {
spt: any;
}

26
types/models/spt/bots/BotGenerationDetails.d.ts vendored Normal file
View File

@@ -0,0 +1,26 @@
import { MinMax } from "@spt/models/common/MinMax";
export interface BotGenerationDetails {
/** Should the bot be generated as a PMC */
isPmc: boolean;
/** assault/pmcBot etc */
role: string;
/** Side of bot */
side: string;
/** Active players current level */
playerLevel?: number;
playerName?: string;
/** Level specific overrides for PMC level */
locationSpecificPmcLevelOverride?: MinMax;
/** Delta of highest level of bot e.g. 50 means 50 levels above player */
botRelativeLevelDeltaMax: number;
/** Delta of lowest level of bot e.g. 50 means 50 levels below player */
botRelativeLevelDeltaMin: number;
/** How many to create and store */
botCountToGenerate: number;
/** Desired difficulty of the bot */
botDifficulty: string;
/** Will the generated bot be a player scav */
isPlayerScav: boolean;
eventRole?: string;
allPmcsHaveSameNameAsPlayer?: boolean;
}

10
types/models/spt/bots/GenerateWeaponResult.d.ts vendored Normal file
View File

@@ -0,0 +1,10 @@
import { Mods } from "@spt/models/eft/common/tables/IBotType";
import { Item } from "@spt/models/eft/common/tables/IItem";
import { ITemplateItem } from "@spt/models/eft/common/tables/ITemplateItem";
export declare class GenerateWeaponResult {
weapon: Item[];
chosenAmmoTpl: string;
chosenUbglAmmoTpl: string;
weaponMods: Mods;
weaponTemplate: ITemplateItem;
}

30
types/models/spt/bots/IBotLootCache.d.ts vendored Normal file
View File

@@ -0,0 +1,30 @@
export interface IBotLootCache {
backpackLoot: Record<string, number>;
pocketLoot: Record<string, number>;
vestLoot: Record<string, number>;
secureLoot: Record<string, number>;
combinedPoolLoot: Record<string, number>;
specialItems: Record<string, number>;
healingItems: Record<string, number>;
drugItems: Record<string, number>;
foodItems: Record<string, number>;
drinkItems: Record<string, number>;
currencyItems: Record<string, number>;
stimItems: Record<string, number>;
grenadeItems: Record<string, number>;
}
export declare enum LootCacheType {
SPECIAL = "Special",
BACKPACK = "Backpack",
POCKET = "Pocket",
VEST = "Vest",
SECURE = "SecuredContainer",
COMBINED = "Combined",
HEALING_ITEMS = "HealingItems",
DRUG_ITEMS = "DrugItems",
STIM_ITEMS = "StimItems",
GRENADE_ITEMS = "GrenadeItems",
FOOD_ITEMS = "FoodItems",
DRINK_ITEMS = "DrinkItems",
CURRENCY_ITEMS = "CurrencyItems"
}

8
types/models/spt/bots/IBots.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { IBotBase } from "@spt/models/eft/common/tables/IBotBase";
import { IBotCore } from "@spt/models/eft/common/tables/IBotCore";
import { IBotType } from "@spt/models/eft/common/tables/IBotType";
export interface IBots {
types: Record<string, IBotType>;
base: IBotBase;
core: IBotCore;
}

7
types/models/spt/bots/IChooseRandomCompatibleModResult.d.ts vendored Normal file
View File

@@ -0,0 +1,7 @@
export interface IChooseRandomCompatibleModResult {
incompatible: boolean;
found?: boolean;
chosenTpl?: string;
reason: string;
slotBlocked?: boolean;
}

11
types/models/spt/bots/IFilterPlateModsForSlotByLevelResult.d.ts vendored Normal file
View File

@@ -0,0 +1,11 @@
export interface IFilterPlateModsForSlotByLevelResult {
result: Result;
plateModTpls: string[];
}
export declare enum Result {
UNKNOWN_FAILURE = -1,
SUCCESS = 1,
NO_DEFAULT_FILTER = 2,
NOT_PLATE_HOLDING_SLOT = 3,
LACKS_PLATE_WEIGHTS = 4
}

22
types/models/spt/bots/IGenerateEquipmentProperties.d.ts vendored Normal file
View File

@@ -0,0 +1,22 @@
import { Inventory as PmcInventory } from "@spt/models/eft/common/tables/IBotBase";
import { Chances, Mods } from "@spt/models/eft/common/tables/IBotType";
import { EquipmentFilters, RandomisationDetails } from "@spt/models/spt/config/IBotConfig";
export interface IGenerateEquipmentProperties {
/** Root Slot being generated */
rootEquipmentSlot: string;
/** Equipment pool for root slot being generated */
rootEquipmentPool: Record<string, number>;
modPool: Mods;
/** Dictionary of mod items and their chance to spawn for this bot type */
spawnChances: Chances;
/** Role being generated for */
botRole: string;
/** Level of bot being generated */
botLevel: number;
inventory: PmcInventory;
botEquipmentConfig: EquipmentFilters;
/** Settings from bot.json to adjust how item is generated */
randomisationDetails: RandomisationDetails;
/** OPTIONAL - Do not generate mods for tpls in this array */
generateModsBlacklist?: string[];
}

37
types/models/spt/bots/IGenerateWeaponRequest.d.ts vendored Normal file
View File

@@ -0,0 +1,37 @@
import { Mods, ModsChances } from "@spt/models/eft/common/tables/IBotType";
import { Item } from "@spt/models/eft/common/tables/IItem";
import { ITemplateItem } from "@spt/models/eft/common/tables/ITemplateItem";
import { BotModLimits } from "@spt/services/BotWeaponModLimitService";
export interface IGenerateWeaponRequest {
/** Weapon to add mods to / result that is returned */
weapon: Item[];
/** Pool of compatible mods to attach to weapon */
modPool: Mods;
/** ParentId of weapon */
weaponId: string;
/** Weapon which mods will be generated on */
parentTemplate: ITemplateItem;
/** Chance values mod will be added */
modSpawnChances: ModsChances;
/** Ammo tpl to use when generating magazines/cartridges */
ammoTpl: string;
/** Bot-specific properties */
botData: IBotData;
/** limits placed on certain mod types per gun */
modLimits: BotModLimits;
/** Info related to the weapon being generated */
weaponStats: IWeaponStats;
}
export interface IBotData {
/** Role of bot weapon is generated for */
role: string;
/** Level of the bot weapon is being generated for */
level: number;
/** role of bot when accessing bot.json equipment config settings */
equipmentRole: string;
}
export interface IWeaponStats {
hasOptic?: boolean;
hasFrontIronSight?: boolean;
hasRearIronSight?: boolean;
}

4
types/models/spt/bots/IItemSpawnLimitSettings.d.ts vendored Normal file
View File

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

27
types/models/spt/bots/IModToSpawnRequest.d.ts vendored Normal file
View File

@@ -0,0 +1,27 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
import { ITemplateItem } from "@spt/models/eft/common/tables/ITemplateItem";
import { ModSpawn } from "@spt/models/enums/ModSpawn";
import { IWeaponStats } from "@spt/models/spt/bots/IGenerateWeaponRequest";
import { EquipmentFilterDetails } from "@spt/models/spt/config/IBotConfig";
export interface IModToSpawnRequest {
/** Slot mod will fit into */
modSlot: string;
/** Will generate a randomised mod pool if true */
isRandomisableSlot: boolean;
/** Parent slot the item will be a part of */
botWeaponSightWhitelist: Record<string, string[]>;
/** Blacklist to prevent mods from being picked */
botEquipBlacklist: EquipmentFilterDetails;
/** Pool of items to pick from */
itemModPool: Record<string, string[]>;
/** Array with only weapon tpl in it, ready for mods to be added */
weapon: Item[];
/** Ammo tpl to use if slot requires a cartridge to be added (e.g. mod_magazine) */
ammoTpl: string;
/** Parent item the mod will go into */
parentTemplate: ITemplateItem;
/** Should mod be spawned/skipped/use default */
modSpawnResult: ModSpawn;
/** Weapon stats for weapon being generated */
weaponStats: IWeaponStats;
}

10
types/models/spt/callbacks/IBotCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,10 @@
import { IGenerateBotsRequestData } from "@spt/models/eft/bot/IGenerateBotsRequestData";
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IBotBase } from "@spt/models/eft/common/tables/IBotBase";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
export interface IBotCallbacks {
getBotLimit(url: string, info: IEmptyRequestData, sessionID: string): string;
getBotDifficulty(url: string, info: IEmptyRequestData, sessionID: string): string;
generateBots(url: string, info: IGenerateBotsRequestData, sessionID: string): IGetBodyResponseData<IBotBase[]>;
getBotCap(): string;
}

5
types/models/spt/callbacks/IBundleCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
export interface IBundleCallbacks {
sendBundle(sessionID: string, req: any, resp: any, body: any): any;
getBundles(url: string, info: any, sessionID: string): string;
getBundle(url: string, info: any, sessionID: string): string;
}

12
types/models/spt/callbacks/ICustomizationCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,12 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { ISuit } from "@spt/models/eft/common/tables/ITrader";
import { IBuyClothingRequestData } from "@spt/models/eft/customization/IBuyClothingRequestData";
import { IWearClothingRequestData } from "@spt/models/eft/customization/IWearClothingRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
export interface ICustomizationCallbacks {
getSuits(url: string, info: any, sessionID: string): IGetBodyResponseData<any>;
getTraderSuits(url: string, info: any, sessionID: string): IGetBodyResponseData<ISuit[]>;
wearClothing(pmcData: IPmcData, body: IWearClothingRequestData, sessionID: string): IItemEventRouterResponse;
buyClothing(pmcData: IPmcData, body: IBuyClothingRequestData, sessionID: string): IItemEventRouterResponse;
}

23
types/models/spt/callbacks/IDataCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,23 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IGlobals } from "@spt/models/eft/common/IGlobals";
import { IHideoutArea } from "@spt/models/eft/hideout/IHideoutArea";
import { IHideoutProduction } from "@spt/models/eft/hideout/IHideoutProduction";
import { IHideoutScavCase } from "@spt/models/eft/hideout/IHideoutScavCase";
import { IHideoutSettingsBase } from "@spt/models/eft/hideout/IHideoutSettingsBase";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { ISettingsBase } from "@spt/models/spt/server/ISettingsBase";
export interface IDataCallbacks {
getSettings(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<ISettingsBase>;
getGlobals(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IGlobals>;
getTemplateItems(url: string, info: IEmptyRequestData, sessionID: string): string;
getTemplateHandbook(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
getTemplateSuits(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
getTemplateCharacter(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<string[]>;
getHideoutSettings(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IHideoutSettingsBase>;
getHideoutAreas(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IHideoutArea[]>;
gethideoutProduction(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IHideoutProduction[]>;
getHideoutScavcase(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IHideoutScavCase[]>;
getLocalesLanguages(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<Record<string, string>>;
getLocalesMenu(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
getLocalesGlobal(url: string, info: IEmptyRequestData, sessionID: string): string;
}

34
types/models/spt/callbacks/IDialogueCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,34 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IFriendRequestData } from "@spt/models/eft/dialog/IFriendRequestData";
import { IGetAllAttachmentsRequestData } from "@spt/models/eft/dialog/IGetAllAttachmentsRequestData";
import { IGetAllAttachmentsResponse } from "@spt/models/eft/dialog/IGetAllAttachmentsResponse";
import { IGetChatServerListRequestData } from "@spt/models/eft/dialog/IGetChatServerListRequestData";
import { IGetFriendListDataResponse } from "@spt/models/eft/dialog/IGetFriendListDataResponse";
import { IGetMailDialogInfoRequestData } from "@spt/models/eft/dialog/IGetMailDialogInfoRequestData";
import { IGetMailDialogListRequestData } from "@spt/models/eft/dialog/IGetMailDialogListRequestData";
import { IGetMailDialogViewRequestData } from "@spt/models/eft/dialog/IGetMailDialogViewRequestData";
import { IGetMailDialogViewResponseData } from "@spt/models/eft/dialog/IGetMailDialogViewResponseData";
import { IPinDialogRequestData } from "@spt/models/eft/dialog/IPinDialogRequestData";
import { IRemoveDialogRequestData } from "@spt/models/eft/dialog/IRemoveDialogRequestData";
import { ISendMessageRequest } from "@spt/models/eft/dialog/ISendMessageRequest";
import { ISetDialogReadRequestData } from "@spt/models/eft/dialog/ISetDialogReadRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { INullResponseData } from "@spt/models/eft/httpResponse/INullResponseData";
import { DialogueInfo } from "@spt/models/eft/profile/ISptProfile";
export interface IDialogueCallbacks {
getFriendList(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IGetFriendListDataResponse>;
getChatServerList(url: string, info: IGetChatServerListRequestData, sessionID: string): IGetBodyResponseData<any[]>;
getMailDialogList(url: string, info: IGetMailDialogListRequestData, sessionID: string): IGetBodyResponseData<DialogueInfo[]>;
getMailDialogView(url: string, info: IGetMailDialogViewRequestData, sessionID: string): IGetBodyResponseData<IGetMailDialogViewResponseData>;
getMailDialogInfo(url: string, info: IGetMailDialogInfoRequestData, sessionID: string): IGetBodyResponseData<any>;
removeDialog(url: string, info: IRemoveDialogRequestData, sessionID: string): IGetBodyResponseData<any[]>;
pinDialog(url: string, info: IPinDialogRequestData, sessionID: string): IGetBodyResponseData<any[]>;
unpinDialog(url: string, info: IPinDialogRequestData, sessionID: string): IGetBodyResponseData<any[]>;
setRead(url: string, info: ISetDialogReadRequestData, sessionID: string): IGetBodyResponseData<any[]>;
getAllAttachments(url: string, info: IGetAllAttachmentsRequestData, sessionID: string): IGetBodyResponseData<IGetAllAttachmentsResponse>;
listOutbox(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any[]>;
listInbox(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any[]>;
sendFriendRequest(url: string, request: IFriendRequestData, sessionID: string): INullResponseData;
sendMessage(url: string, request: ISendMessageRequest, sessionID: string): IGetBodyResponseData<number>;
update(): boolean;
}

16
types/models/spt/callbacks/IGameCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,16 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IGameConfigResponse } from "@spt/models/eft/game/IGameConfigResponse";
import { IGameEmptyCrcRequestData } from "@spt/models/eft/game/IGameEmptyCrcRequestData";
import { IVersionValidateRequestData } from "@spt/models/eft/game/IVersionValidateRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { INullResponseData } from "@spt/models/eft/httpResponse/INullResponseData";
export interface IGameCallbacks {
versionValidate(url: string, info: IVersionValidateRequestData, sessionID: string): INullResponseData;
gameStart(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
gameLogout(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
getGameConfig(url: string, info: IGameEmptyCrcRequestData, sessionID: string): IGetBodyResponseData<IGameConfigResponse>;
getServer(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
validateGameVersion(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
gameKeepalive(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
getVersion(url: string, info: IEmptyRequestData, sessionID: string): string;
}

3
types/models/spt/callbacks/IHandbookCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
export interface IHandbookCallbacks {
load(): void;
}

13
types/models/spt/callbacks/IHealthCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IHealthTreatmentRequestData } from "@spt/models/eft/health/IHealthTreatmentRequestData";
import { IOffraidEatRequestData } from "@spt/models/eft/health/IOffraidEatRequestData";
import { IOffraidHealRequestData } from "@spt/models/eft/health/IOffraidHealRequestData";
import { ISyncHealthRequestData } from "@spt/models/eft/health/ISyncHealthRequestData";
import { ISptProfile } from "@spt/models/eft/profile/ISptProfile";
export interface IHealthCallbacks {
onLoad(sessionID: string): ISptProfile;
syncHealth(url: string, info: ISyncHealthRequestData, sessionID: string): any;
offraidEat(pmcData: IPmcData, body: IOffraidEatRequestData, sessionID: string): any;
offraidHeal(pmcData: IPmcData, body: IOffraidHealRequestData, sessionID: string): any;
healthTreatment(pmcData: IPmcData, info: IHealthTreatmentRequestData, sessionID: string): any;
}

23
types/models/spt/callbacks/IHideoutCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,23 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IHideoutContinuousProductionStartRequestData } from "@spt/models/eft/hideout/IHideoutContinuousProductionStartRequestData";
import { IHideoutPutItemInRequestData } from "@spt/models/eft/hideout/IHideoutPutItemInRequestData";
import { IHideoutScavCaseStartRequestData } from "@spt/models/eft/hideout/IHideoutScavCaseStartRequestData";
import { IHideoutSingleProductionStartRequestData } from "@spt/models/eft/hideout/IHideoutSingleProductionStartRequestData";
import { IHideoutTakeItemOutRequestData } from "@spt/models/eft/hideout/IHideoutTakeItemOutRequestData";
import { IHideoutTakeProductionRequestData } from "@spt/models/eft/hideout/IHideoutTakeProductionRequestData";
import { IHideoutToggleAreaRequestData } from "@spt/models/eft/hideout/IHideoutToggleAreaRequestData";
import { IHideoutUpgradeCompleteRequestData } from "@spt/models/eft/hideout/IHideoutUpgradeCompleteRequestData";
import { IHideoutUpgradeRequestData } from "@spt/models/eft/hideout/IHideoutUpgradeRequestData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
export interface IHideoutCallbacks {
upgrade(pmcData: IPmcData, body: IHideoutUpgradeRequestData, sessionID: string): IItemEventRouterResponse;
upgradeComplete(pmcData: IPmcData, body: IHideoutUpgradeCompleteRequestData, sessionID: string): IItemEventRouterResponse;
putItemsInAreaSlots(pmcData: IPmcData, body: IHideoutPutItemInRequestData, sessionID: string): IItemEventRouterResponse;
takeItemsFromAreaSlots(pmcData: IPmcData, body: IHideoutTakeItemOutRequestData, sessionID: string): IItemEventRouterResponse;
toggleArea(pmcData: IPmcData, body: IHideoutToggleAreaRequestData, sessionID: string): IItemEventRouterResponse;
singleProductionStart(pmcData: IPmcData, body: IHideoutSingleProductionStartRequestData, sessionID: string): IItemEventRouterResponse;
scavCaseProductionStart(pmcData: IPmcData, body: IHideoutScavCaseStartRequestData, sessionID: string): IItemEventRouterResponse;
continuousProductionStart(pmcData: IPmcData, body: IHideoutContinuousProductionStartRequestData, sessionID: string): IItemEventRouterResponse;
takeProduction(pmcData: IPmcData, body: IHideoutTakeProductionRequestData, sessionID: string): IItemEventRouterResponse;
update(timeSinceLastRun: number): boolean;
}

5
types/models/spt/callbacks/IHttpCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
export interface IHttpCallbacks {
load(): void;
sendImage(sessionID: string, req: any, resp: any, body: any): void;
getImage(): string;
}

14
types/models/spt/callbacks/IInraidCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,14 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { INullResponseData } from "@spt/models/eft/httpResponse/INullResponseData";
import { IRegisterPlayerRequestData } from "@spt/models/eft/inRaid/IRegisterPlayerRequestData";
import { ISaveProgressRequestData } from "@spt/models/eft/inRaid/ISaveProgressRequestData";
import { ISptProfile } from "@spt/models/eft/profile/ISptProfile";
export interface IInraidCallbacks {
onLoad(sessionID: string): ISptProfile;
registerPlayer(url: string, info: IRegisterPlayerRequestData, sessionID: string): INullResponseData;
saveProgress(url: string, info: ISaveProgressRequestData, sessionID: string): INullResponseData;
getRaidEndState(): string;
getRaidMenuSettings(url: string, info: IEmptyRequestData, sessionID: string): string;
getWeaponDurability(url: string, info: any, sessionID: string): string;
getAirdropConfig(url: string, info: any, sessionID: string): string;
}

10
types/models/spt/callbacks/IInsuranceCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,10 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IGetInsuranceCostRequestData } from "@spt/models/eft/insurance/IGetInsuranceCostRequestData";
import { IInsureRequestData } from "@spt/models/eft/insurance/IInsureRequestData";
import { ISptProfile } from "@spt/models/eft/profile/ISptProfile";
export interface IInsuranceCallbacks {
onLoad(sessionID: string): ISptProfile;
getInsuranceCost(url: string, info: IGetInsuranceCostRequestData, sessionID: string): any;
insure(pmcData: IPmcData, body: IInsureRequestData, sessionID: string): any;
update(secondsSinceLastRun: number): boolean;
}

36
types/models/spt/callbacks/IInventoryCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,36 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IInventoryBindRequestData } from "@spt/models/eft/inventory/IInventoryBindRequestData";
import { IInventoryCreateMarkerRequestData } from "@spt/models/eft/inventory/IInventoryCreateMarkerRequestData";
import { IInventoryDeleteMarkerRequestData } from "@spt/models/eft/inventory/IInventoryDeleteMarkerRequestData";
import { IInventoryEditMarkerRequestData } from "@spt/models/eft/inventory/IInventoryEditMarkerRequestData";
import { IInventoryExamineRequestData } from "@spt/models/eft/inventory/IInventoryExamineRequestData";
import { IInventoryFoldRequestData } from "@spt/models/eft/inventory/IInventoryFoldRequestData";
import { IInventoryMergeRequestData } from "@spt/models/eft/inventory/IInventoryMergeRequestData";
import { IInventoryMoveRequestData } from "@spt/models/eft/inventory/IInventoryMoveRequestData";
import { IInventoryReadEncyclopediaRequestData } from "@spt/models/eft/inventory/IInventoryReadEncyclopediaRequestData";
import { IInventoryRemoveRequestData } from "@spt/models/eft/inventory/IInventoryRemoveRequestData";
import { IInventorySortRequestData } from "@spt/models/eft/inventory/IInventorySortRequestData";
import { IInventorySplitRequestData } from "@spt/models/eft/inventory/IInventorySplitRequestData";
import { IInventorySwapRequestData } from "@spt/models/eft/inventory/IInventorySwapRequestData";
import { IInventoryTagRequestData } from "@spt/models/eft/inventory/IInventoryTagRequestData";
import { IInventoryToggleRequestData } from "@spt/models/eft/inventory/IInventoryToggleRequestData";
import { IInventoryTransferRequestData } from "@spt/models/eft/inventory/IInventoryTransferRequestData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
export interface IInventoryCallbacks {
moveItem(pmcData: IPmcData, body: IInventoryMoveRequestData, sessionID: string): IItemEventRouterResponse;
removeItem(pmcData: IPmcData, body: IInventoryRemoveRequestData, sessionID: string): IItemEventRouterResponse;
splitItem(pmcData: IPmcData, body: IInventorySplitRequestData, sessionID: string): IItemEventRouterResponse;
mergeItem(pmcData: IPmcData, body: IInventoryMergeRequestData, sessionID: string): IItemEventRouterResponse;
transferItem(pmcData: IPmcData, body: IInventoryTransferRequestData, sessionID: string): IItemEventRouterResponse;
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;
examineItem(pmcData: IPmcData, body: IInventoryExamineRequestData, sessionID: string): IItemEventRouterResponse;
readEncyclopedia(pmcData: IPmcData, body: IInventoryReadEncyclopediaRequestData, sessionID: string): IItemEventRouterResponse;
sortInventory(pmcData: IPmcData, body: IInventorySortRequestData, sessionID: string): IItemEventRouterResponse;
createMapMarker(pmcData: IPmcData, body: IInventoryCreateMarkerRequestData, sessionID: string): IItemEventRouterResponse;
deleteMapMarker(pmcData: IPmcData, body: IInventoryDeleteMarkerRequestData, sessionID: string): IItemEventRouterResponse;
editMapMarker(pmcData: IPmcData, body: IInventoryEditMarkerRequestData, sessionID: string): IItemEventRouterResponse;
}

6
types/models/spt/callbacks/IItemEventCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,6 @@
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IItemEventRouterRequest } from "@spt/models/eft/itemEvent/IItemEventRouterRequest";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
export interface IItemEventCallbacks {
handleEvents(url: string, info: IItemEventRouterRequest, sessionID: string): IGetBodyResponseData<IItemEventRouterResponse>;
}

20
types/models/spt/callbacks/ILauncherCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,20 @@
import { IChangeRequestData } from "@spt/models/eft/launcher/IChangeRequestData";
import { IGetMiniProfileRequestData } from "@spt/models/eft/launcher/IGetMiniProfileRequestData";
import { ILoginRequestData } from "@spt/models/eft/launcher/ILoginRequestData";
import { IRegisterData } from "@spt/models/eft/launcher/IRegisterData";
import { IRemoveProfileData } from "@spt/models/eft/launcher/IRemoveProfileData";
export interface ILauncherCallbacks {
connect(): string;
login(url: string, info: ILoginRequestData, sessionID: string): string;
register(url: string, info: IRegisterData, sessionID: string): "FAILED" | "OK";
get(url: string, info: ILoginRequestData, sessionID: string): string;
changeUsername(url: string, info: IChangeRequestData, sessionID: string): "FAILED" | "OK";
changePassword(url: string, info: IChangeRequestData, sessionID: string): "FAILED" | "OK";
wipe(url: string, info: IRegisterData, sessionID: string): "FAILED" | "OK";
getMiniProfile(url: string, info: IGetMiniProfileRequestData, sessionID: string): string;
getAllMiniProfiles(url: string, info: any, sessionID: string): string;
getServerVersion(): string;
ping(url: string, info: any, sessionID: string): string;
removeProfile(url: string, info: IRemoveProfileData, sessionID: string): string;
getCompatibleTarkovVersion(): string;
}

8
types/models/spt/callbacks/ILocationCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { ILocationBase } from "@spt/models/eft/common/ILocationBase";
import { ILocationsGenerateAllResponse } from "@spt/models/eft/common/ILocationsSourceDestinationBase";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IGetLocationRequestData } from "@spt/models/eft/location/IGetLocationRequestData";
export interface ILocationCallbacks {
getLocationData(url: string, info: any, sessionID: string): IGetBodyResponseData<ILocationsGenerateAllResponse>;
getLocation(url: string, info: IGetLocationRequestData, sessionID: string): IGetBodyResponseData<ILocationBase>;
}

6
types/models/spt/callbacks/IModCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,6 @@
export interface IModCallbacks {
load(): void;
sendBundle(sessionID: string, req: any, resp: any, body: any): void;
getBundles(url: string, info: any, sessionID: string): string;
getBundle(url: string, info: any, sessionID: string): string;
}

8
types/models/spt/callbacks/INoteCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { INoteActionData } from "@spt/models/eft/notes/INoteActionData";
export interface INoteCallbacks {
addNote(pmcData: IPmcData, body: INoteActionData, sessionID: string): IItemEventRouterResponse;
editNote(pmcData: IPmcData, body: INoteActionData, sessionID: string): IItemEventRouterResponse;
deleteNote(pmcData: IPmcData, body: INoteActionData, sessionID: string): IItemEventRouterResponse;
}

17
types/models/spt/callbacks/INotifierCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,17 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IUIDRequestData } from "@spt/models/eft/common/request/IUIDRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { INotifierChannel } from "@spt/models/eft/notifier/INotifier";
export interface INotifierCallbacks {
/**
* If we don't have anything to send, it's ok to not send anything back
* because notification requests can be long-polling. In fact, we SHOULD wait
* until we actually have something to send because otherwise we'd spam the client
* and the client would abort the connection due to spam.
*/
sendNotification(sessionID: string, req: any, resp: any, data: any): void;
getNotifier(url: string, info: any, sessionID: string): IGetBodyResponseData<any[]>;
createNotifierChannel(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<INotifierChannel>;
selectProfile(url: string, info: IUIDRequestData, sessionID: string): IGetBodyResponseData<any>;
notify(url: string, info: any, sessionID: string): string;
}

12
types/models/spt/callbacks/IPresetBuildCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,12 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IPresetBuildActionRequestData } from "@spt/models/eft/presetBuild/IPresetBuildActionRequestData";
import { IWeaponBuild } from "@spt/models/eft/profile/ISptProfile";
export interface IPresetBuildCallbacks {
getHandbookUserlist(url: string, info: any, sessionID: string): IGetBodyResponseData<IWeaponBuild[]>;
saveWeaponBuild(pmcData: IPmcData, body: IPresetBuildActionRequestData, sessionID: string): IItemEventRouterResponse;
removeWeaponBuild(pmcData: IPmcData, body: IPresetBuildActionRequestData, sessionID: string): IItemEventRouterResponse;
saveEquipmentBuild(pmcData: IPmcData, body: IPresetBuildActionRequestData, sessionID: string): IItemEventRouterResponse;
removeEquipmentBuild(pmcData: IPmcData, body: IPresetBuildActionRequestData, sessionID: string): IItemEventRouterResponse;
}

3
types/models/spt/callbacks/IPresetCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,3 @@
export interface IPresetCallbacks {
load(): void;
}

21
types/models/spt/callbacks/IProfileCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,21 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { INullResponseData } from "@spt/models/eft/httpResponse/INullResponseData";
import { IProfileChangeNicknameRequestData } from "@spt/models/eft/profile/IProfileChangeNicknameRequestData";
import { IProfileChangeVoiceRequestData } from "@spt/models/eft/profile/IProfileChangeVoiceRequestData";
import { IProfileCreateRequestData } from "@spt/models/eft/profile/IProfileCreateRequestData";
import { ISearchFriendRequestData } from "@spt/models/eft/profile/ISearchFriendRequestData";
import { ISearchFriendResponse } from "@spt/models/eft/profile/ISearchFriendResponse";
import { IValidateNicknameRequestData } from "@spt/models/eft/profile/IValidateNicknameRequestData";
export interface IProfileCallbacks {
onLoad(sessionID: string): any;
createProfile(url: string, info: IProfileCreateRequestData, sessionID: string): IGetBodyResponseData<any>;
getProfileData(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
regenerateScav(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
changeVoice(url: string, info: IProfileChangeVoiceRequestData, sessionID: string): INullResponseData;
changeNickname(url: string, info: IProfileChangeNicknameRequestData, sessionID: string): IGetBodyResponseData<any>;
validateNickname(url: string, info: IValidateNicknameRequestData, sessionID: string): IGetBodyResponseData<any>;
getReservedNickname(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<string>;
getProfileStatus(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
searchFriend(url: string, info: ISearchFriendRequestData, sessionID: string): IGetBodyResponseData<ISearchFriendResponse>;
}

19
types/models/spt/callbacks/IQuestCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,19 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IQuest } from "@spt/models/eft/common/tables/IQuest";
import { IPmcDataRepeatableQuest } from "@spt/models/eft/common/tables/IRepeatableQuests";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IAcceptQuestRequestData } from "@spt/models/eft/quests/IAcceptQuestRequestData";
import { ICompleteQuestRequestData } from "@spt/models/eft/quests/ICompleteQuestRequestData";
import { IHandoverQuestRequestData } from "@spt/models/eft/quests/IHandoverQuestRequestData";
import { IListQuestsRequestData } from "@spt/models/eft/quests/IListQuestsRequestData";
import { IRepeatableQuestChangeRequest } from "@spt/models/eft/quests/IRepeatableQuestChangeRequest";
export interface IQuestCallbacks {
changeRepeatableQuest(pmcData: IPmcData, body: IRepeatableQuestChangeRequest, sessionID: string): IItemEventRouterResponse;
acceptQuest(pmcData: IPmcData, body: IAcceptQuestRequestData, sessionID: string): IItemEventRouterResponse;
completeQuest(pmcData: IPmcData, body: ICompleteQuestRequestData, sessionID: string): IItemEventRouterResponse;
handoverQuest(pmcData: IPmcData, body: IHandoverQuestRequestData, sessionID: string): IItemEventRouterResponse;
listQuests(url: string, info: IListQuestsRequestData, sessionID: string): IGetBodyResponseData<IQuest[]>;
activityPeriods(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<IPmcDataRepeatableQuest[]>;
}

21
types/models/spt/callbacks/IRagfairCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,21 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IAddOfferRequestData } from "@spt/models/eft/ragfair/IAddOfferRequestData";
import { IExtendOfferRequestData } from "@spt/models/eft/ragfair/IExtendOfferRequestData";
import { IGetItemPriceResult } from "@spt/models/eft/ragfair/IGetItemPriceResult";
import { IGetMarketPriceRequestData } from "@spt/models/eft/ragfair/IGetMarketPriceRequestData";
import { IRemoveOfferRequestData } from "@spt/models/eft/ragfair/IRemoveOfferRequestData";
import { ISearchRequestData } from "@spt/models/eft/ragfair/ISearchRequestData";
export interface IRagfairCallbacks {
load(): void;
search(url: string, info: ISearchRequestData, sessionID: string): IGetBodyResponseData<any>;
getMarketPrice(url: string, info: IGetMarketPriceRequestData, sessionID: string): IGetBodyResponseData<IGetItemPriceResult>;
getItemPrices(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
addOffer(pmcData: IPmcData, info: IAddOfferRequestData, sessionID: string): IItemEventRouterResponse;
removeOffer(pmcData: IPmcData, info: IRemoveOfferRequestData, sessionID: string): IItemEventRouterResponse;
extendOffer(pmcData: IPmcData, info: IExtendOfferRequestData, sessionID: string): IItemEventRouterResponse;
update(timeSinceLastRun: number): boolean;
updatePlayer(timeSinceLastRun: number): boolean;
}

8
types/models/spt/callbacks/IRepairCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IRepairActionDataRequest } from "@spt/models/eft/repair/IRepairActionDataRequest";
import { ITraderRepairActionDataRequest } from "@spt/models/eft/repair/ITraderRepairActionDataRequest";
export interface IRepairCallbacks {
traderRepair(pmcData: IPmcData, body: ITraderRepairActionDataRequest, sessionID: string): IItemEventRouterResponse;
repair(pmcData: IPmcData, body: IRepairActionDataRequest, sessionID: string): IItemEventRouterResponse;
}

4
types/models/spt/callbacks/ISaveCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
export interface ISaveCallbacks {
load(): void;
update(secondsSinceLastRun: number): boolean;
}

8
types/models/spt/callbacks/ITradeCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IProcessBaseTradeRequestData } from "@spt/models/eft/trade/IProcessBaseTradeRequestData";
import { IProcessRagfairTradeRequestData } from "@spt/models/eft/trade/IProcessRagfairTradeRequestData";
export interface ITradeCallbacks {
processTrade(pmcData: IPmcData, body: IProcessBaseTradeRequestData, sessionID: string): IItemEventRouterResponse;
processRagfairTrade(pmcData: IPmcData, body: IProcessRagfairTradeRequestData, sessionID: string): IItemEventRouterResponse;
}

10
types/models/spt/callbacks/ITraderCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,10 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { ITraderAssort, ITraderBase } from "@spt/models/eft/common/tables/ITrader";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
export interface ITraderCallbacks {
load(): void;
getTraderSettings(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<ITraderBase[]>;
getTrader(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<ITraderBase>;
getAssort(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<ITraderAssort>;
update(): boolean;
}

5
types/models/spt/callbacks/IWeatherCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IGetBodyResponseData } from "@spt/models/eft/httpResponse/IGetBodyResponseData";
export interface IWeatherCallbacks {
getWeather(url: string, info: IEmptyRequestData, sessionID: string): IGetBodyResponseData<any>;
}

7
types/models/spt/callbacks/IWishlistCallbacks.d.ts vendored Normal file
View File

@@ -0,0 +1,7 @@
import { IPmcData } from "@spt/models/eft/common/IPmcData";
import { IItemEventRouterResponse } from "@spt/models/eft/itemEvent/IItemEventRouterResponse";
import { IWishlistActionData } from "@spt/models/eft/wishlist/IWishlistActionData";
export interface IWishlistCallbacks {
addToWishlist(pmcData: IPmcData, body: IWishlistActionData, sessionID: string): IItemEventRouterResponse;
removeFromWishlist(pmcData: IPmcData, body: IWishlistActionData, sessionID: string): IItemEventRouterResponse;
}

60
types/models/spt/config/IAirdropConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,60 @@
import { MinMax } from "@spt/models/common/MinMax";
import { AirdropTypeEnum } from "@spt/models/enums/AirdropType";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IAirdropConfig extends IBaseConfig {
kind: "spt-airdrop";
airdropChancePercent: AirdropChancePercent;
airdropTypeWeightings: Record<AirdropTypeEnum, number>;
/** Lowest point plane will fly at */
planeMinFlyHeight: number;
/** Highest point plane will fly at */
planeMaxFlyHeight: number;
/** Loudness of plane engine */
planeVolume: number;
/** Speed plane flies overhead */
planeSpeed: number;
/** Speed loot crate falls after being dropped */
crateFallSpeed: number;
/** Container tpls to use when spawning crate - affects container size, keyed by drop type e.g. mixed/weaponArmor/foodMedical/barter */
containerIds: Record<string, string>;
/** Earliest time aircraft will spawn in raid */
airdropMinStartTimeSeconds: number;
/** Latest time aircraft will spawn in raid */
airdropMaxStartTimeSeconds: number;
/** What rewards will the loot crate contain, keyed by drop type e.g. mixed/weaponArmor/foodMedical/barter */
loot: Record<string, AirdropLoot>;
}
/** Chance map will have an airdrop occur out of 100 - locations not included count as 0% */
export interface AirdropChancePercent {
bigmap: number;
woods: number;
lighthouse: number;
shoreline: number;
interchange: number;
reserve: number;
tarkovStreets: number;
sandbox: number;
}
/** Loot inside crate */
export interface AirdropLoot {
/** Min/max of weapons inside crate */
weaponPresetCount?: MinMax;
/** Min/max of armors (head/chest/rig) inside crate */
armorPresetCount?: MinMax;
/** Min/max of items inside crate */
itemCount: MinMax;
/** Min/max of sealed weapon boxes inside crate */
weaponCrateCount: MinMax;
/** Items to never allow - tpls */
itemBlacklist: string[];
/** Item type (parentId) to allow inside crate */
itemTypeWhitelist: string[];
/** Item type/ item tpls to limit count of inside crate - key: item base type: value: max count */
itemLimits: Record<string, number>;
/** Items to limit stack size of key: item tpl value: min/max stack size */
itemStackLimits: Record<string, MinMax>;
/** Armor levels to allow inside crate e.g. [4,5,6] */
armorLevelWhitelist?: number[];
/** Should boss items be added to airdrop crate */
allowBossItems: boolean;
}

13
types/models/spt/config/IBTRConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IBTRConfig extends IBaseConfig {
kind: "spt-btr";
/** How fast the BTR moves */
moveSpeed: number;
/** How long the cover fire service lasts for */
coverFireTime: number;
/** How long the BTR waits at every point in its path */
pointWaitTime: MinMax;
/** How long after purchasing the taxi service before the BTR leaves */
taxiWaitTime: number;
}

7
types/models/spt/config/IBaseConfig.d.ts vendored Normal file
View File

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

192
types/models/spt/config/IBotConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,192 @@
import { MinMax } from "@spt/models/common/MinMax";
import { GenerationData } from "@spt/models/eft/common/tables/IBotType";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
import { IBotDurability } from "@spt/models/spt/config/IBotDurability";
export interface IBotConfig extends IBaseConfig {
kind: "spt-bot";
/** How many variants of each bot should be generated on raid start */
presetBatch: PresetBatch;
/** Bot roles that should not have PMC types (pmcBEAR/pmcUSEC) added as enemies to */
botsToNotAddPMCsAsEnemiesTo: string[];
/** What bot types should be classified as bosses */
bosses: string[];
/** Control weapon/armor durability min/max values for each bot type */
durability: IBotDurability;
/** Controls the percentage values of randomization item resources */
lootItemResourceRandomization: Record<string, IRandomisedResourceDetails>;
/** 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
* key: bottype, value: <key: itemTpl: value: max item count> */
itemSpawnLimits: Record<string, Record<string, number>>;
/** Blacklist/whitelist items on a bot */
equipment: Record<string, EquipmentFilters>;
/** Show a bots botType value after their name */
showTypeInNickname: boolean;
/** What ai brain should a normal scav use per map */
assaultBrainType: Record<string, Record<string, number>>;
/** What ai brain should a player scav use per map */
playerScavBrainType: Record<string, Record<string, number>>;
/** Max number of bots that can be spawned in a raid at any one time */
maxBotCap: Record<string, number>;
/** Chance scav has fake pscav name e.g. Scav name (player name) */
chanceAssaultScavHasPlayerScavName: number;
/** How many stacks of secret ammo should a bot have in its bot secure container */
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>>>;
/** Tpls for low profile gas blocks */
lowProfileGasBlockTpls: string[];
/** What bottypes should be excluded from having loot generated on them (backpack/pocket/vest) does not disable food/drink/special/ */
disableLootOnBotTypes: string[];
assaultToBossConversion: IAssaultToBossConversion;
}
export interface IAssaultToBossConversion {
bossConvertEnabled: boolean;
bossesToConvertToWeights: Record<string, number>;
bossConvertMinMax: Record<string, MinMax>;
}
/** Number of bots to generate and store in cache on raid start per bot type */
export interface PresetBatch {
assault: number;
bossBully: number;
bossGluhar: number;
bossKilla: number;
bossKojaniy: number;
bossSanitar: number;
bossTagilla: number;
bossKnight: number;
bossTest: number;
cursedAssault: number;
followerBully: number;
followerGluharAssault: number;
followerGluharScout: number;
followerGluharSecurity: number;
followerGluharSnipe: number;
followerKojaniy: number;
followerSanitar: number;
followerTagilla: number;
followerBirdEye: number;
followerBigPipe: number;
followerTest: number;
followerBoar: number;
marksman: number;
pmcBot: number;
sectantPriest: number;
sectantWarrior: number;
gifter: number;
test: number;
exUsec: number;
arenaFighterEvent: number;
arenaFighter: number;
crazyAssaultEvent: number;
bossBoar: number;
bossBoarSniper: number;
pmcUSEC: number;
pmcBEAR: number;
}
export interface IWalletLootSettings {
/** Chance wallets have loot in them */
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 */
weaponModLimits: ModLimits;
/** Whitelist for weapon sight types allowed per gun */
weaponSightWhitelist: Record<string, string[]>;
/** Chance face shield is down/active */
faceShieldIsActiveChancePercent?: number;
/** Chance gun flashlight is active during the day */
lightIsActiveDayChancePercent?: number;
/** Chance gun flashlight is active during the night */
lightIsActiveNightChancePercent?: number;
/** Chance gun laser is active during the day */
laserIsActiveChancePercent?: number;
/** Chance NODS are down/active during the day */
nvgIsActiveChanceDayPercent?: number;
/** Chance NODS are down/active during the night */
nvgIsActiveChanceNightPercent?: number;
forceOnlyArmoredRigWhenNoArmor?: boolean;
/** Should plates be filtered by level */
filterPlatesByLevel?: boolean;
/** What additional slot ids should be seen as required when choosing a mod to add to a weapon */
weaponSlotIdsToMakeRequired?: string[];
/** Adjust weighting/chances of items on bot by level of bot */
randomisation: RandomisationDetails[];
/** Blacklist equipment by level of bot */
blacklist: EquipmentFilterDetails[];
/** Whitelist equipment by level of bot */
whitelist: EquipmentFilterDetails[];
/** Adjust equipment/ammo */
weightingAdjustmentsByBotLevel: WeightingAdjustmentDetails[];
/** Same as weightingAdjustments but based on player level instead of bot level */
weightingAdjustmentsByPlayerLevel?: WeightingAdjustmentDetails[];
/** Should the stock mod be forced to spawn on bot */
forceStock?: boolean;
armorPlateWeighting?: IArmorPlateWeights[];
}
export interface ModLimits {
/** How many scopes are allowed on a weapon - hard coded to work with OPTIC_SCOPE, ASSAULT_SCOPE, COLLIMATOR, COMPACT_COLLIMATOR */
scopeLimit?: number;
/** How many lasers or lights are allowed on a weapon - hard coded to work with TACTICAL_COMBO, and FLASHLIGHT */
lightLaserLimit?: number;
}
export interface RandomisationDetails {
/** Between what levels do these randomisation setting apply to */
levelRange: MinMax;
generation?: Record<string, GenerationData>;
/** Mod slots that should be fully randomised -ignores mods from bottype.json and instaed creates a pool using items.json */
randomisedWeaponModSlots?: string[];
/** Armor slots that should be randomised e.g. 'Headwear, Armband' */
randomisedArmorSlots?: string[];
/** Equipment chances */
equipment?: Record<string, number>;
/** Weapon mod chances */
weaponMods?: Record<string, number>;
/** Equipment mod chances */
equipmentMods?: Record<string, number>;
}
export interface EquipmentFilterDetails {
/** Between what levels do these equipment filter setting apply to */
levelRange: MinMax;
/** Key: mod slot name e.g. mod_magazine, value: item tpls */
equipment: Record<string, string[]>;
/** Key: cartridge type e.g. Caliber23x75, value: item tpls */
cartridge: Record<string, string[]>;
}
export interface WeightingAdjustmentDetails {
/** Between what levels do these weight settings apply to */
levelRange: MinMax;
/** Key: ammo type e.g. Caliber556x45NATO, value: item tpl + weight */
ammo?: IAdjustmentDetails;
/** Key: equipment slot e.g. TacticalVest, value: item tpl + weight */
equipment?: IAdjustmentDetails;
/** Key: clothing slot e.g. feet, value: item tpl + weight */
clothing?: IAdjustmentDetails;
}
export interface IAdjustmentDetails {
add: Record<string, Record<string, number>>;
edit: Record<string, Record<string, number>>;
}
export interface IArmorPlateWeights extends Record<string, any> {
levelRange: MinMax;
}
export interface IRandomisedResourceDetails {
food: IRandomisedResourceValues;
meds: IRandomisedResourceValues;
}
export interface IRandomisedResourceValues {
/** Minimum percent of item to randomized between min and max resource */
resourcePercent: number;
/** Chance for randomization to not occur */
chanceMaxResourcePercent: number;
}

48
types/models/spt/config/IBotDurability.d.ts vendored Normal file
View File

@@ -0,0 +1,48 @@
export interface IBotDurability {
default: DefaultDurability;
pmc: PmcDurability;
boss: BotDurability;
follower: BotDurability;
assault: BotDurability;
cursedassault: BotDurability;
marksman: BotDurability;
pmcbot: BotDurability;
arenafighterevent: BotDurability;
arenafighter: BotDurability;
crazyassaultevent: BotDurability;
exusec: BotDurability;
gifter: BotDurability;
sectantpriest: BotDurability;
sectantwarrior: BotDurability;
}
/** Durability values to be used when a more specific bot type cant be found */
export interface DefaultDurability {
armor: ArmorDurability;
weapon: WeaponDurability;
}
export interface PmcDurability {
armor: PmcDurabilityArmor;
weapon: WeaponDurability;
}
export interface PmcDurabilityArmor {
lowestMaxPercent: number;
highestMaxPercent: number;
maxDelta: number;
minDelta: number;
}
export interface BotDurability {
armor: ArmorDurability;
weapon: WeaponDurability;
}
export interface ArmorDurability {
maxDelta: number;
minDelta: number;
minLimitPercent: number;
}
export interface WeaponDurability {
lowestMax: number;
highestMax: number;
maxDelta: number;
minDelta: number;
minLimitPercent: number;
}

76
types/models/spt/config/ICoreConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,76 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ICoreConfig extends IBaseConfig {
kind: "spt-core";
sptVersion: string;
projectName: string;
compatibleTarkovVersion: string;
serverName: string;
profileSaveIntervalSeconds: number;
sptFriendNickname: string;
allowProfileWipe: boolean;
bsgLogging: IBsgLogging;
release: IRelease;
fixes: IGameFixes;
features: IServerFeatures;
/** Commit hash build server was created from */
commit?: string;
/** Timestamp of server build */
buildTime?: string;
/** Server locale keys that will be added to the bottom of the startup watermark */
customWatermarkLocaleKeys?: 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;
/** Remove items added by mods when the mod no longer exists - can fix dead profiles stuck at game load */
removeModItemsFromProfile: boolean;
/** Fix issues that cause the game to not start due to inventory item issues */
fixProfileBreakingInventoryItemIssues: boolean;
}
export interface IServerFeatures {
autoInstallModDependencies: boolean;
compressProfile: boolean;
chatbotFeatures: IChatbotFeatures;
/** Keyed to profile type e.g. "Standard" or "SPT Developer" */
createNewProfileTypesBlacklist: string[];
}
export interface IChatbotFeatures {
sptFriendEnabled: boolean;
commandoEnabled: boolean;
commandoFeatures: ICommandoFeatures;
commandUseLimits: Record<string, number>;
}
export interface ICommandoFeatures {
giveCommandEnabled: boolean;
}

32
types/models/spt/config/IGiftsConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,32 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
import { IUserDialogInfo } from "@spt/models/eft/profile/ISptProfile";
import { GiftSenderType } from "@spt/models/enums/GiftSenderType";
import { SeasonalEventType } from "@spt/models/enums/SeasonalEventType";
import { Traders } from "@spt/models/enums/Traders";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
import { IProfileChangeEvent } from "@spt/models/spt/dialog/ISendMessageDetails";
export interface IGiftsConfig extends IBaseConfig {
kind: "spt-gifts";
gifts: Record<string, Gift>;
}
export interface Gift {
/** Items to send to player */
items: Item[];
/** Who is sending the gift to player */
sender: GiftSenderType;
/** Optinal - supply a users id to send from, not necessary when sending from SYSTEM or TRADER */
senderId?: string;
senderDetails: IUserDialogInfo;
/** Optional - supply a trader type to send from, not necessary when sending from SYSTEM or USER */
trader?: Traders;
messageText: string;
/** Optional - if sending text from the client locale file */
localeTextId?: string;
/** Optional - Used by Seasonal events to send on specific day */
timestampToSend?: number;
associatedEvent: SeasonalEventType;
collectionTimeHours: number;
/** Optional, can be used to change profile settings like level/skills */
profileChangeEvents?: IProfileChangeEvent[];
maxToSendPlayer?: number;
}

14
types/models/spt/config/IHealthConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,14 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IHealthConfig extends IBaseConfig {
kind: "spt-health";
healthMultipliers: HealthMultipliers;
save: Save;
}
export interface HealthMultipliers {
death: number;
blacked: number;
}
export interface Save {
health: boolean;
effects: boolean;
}

14
types/models/spt/config/IHideoutConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,14 @@
import { IBaseConfig, IRunIntervalValues } from "@spt/models/spt/config/IBaseConfig";
export interface IHideoutConfig extends IBaseConfig {
kind: "spt-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;
overrideCraftTimeSeconds: number;
overrideBuildTimeSeconds: number;
/** Only process a profiles hideout crafts when it has been active in the last x minutes */
updateProfileHideoutWhenActiveWithinMinutes: number;
}

14
types/models/spt/config/IHttpConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,14 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IHttpConfig extends IBaseConfig {
kind: "spt-http";
/** Address used by webserver */
ip: string;
port: number;
/** Address used by game client to connect to */
backendIp: string;
backendPort: string;
webSocketPingDelayMs: number;
logRequests: boolean;
/** e.g. "SPT_Data/Server/images/traders/579dc571d53a0658a154fbec.png": "SPT_Data/Server/images/traders/NewTraderImage.png" */
serverImagePathOverride: Record<string, string>;
}

39
types/models/spt/config/IInRaidConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,39 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IInRaidConfig extends IBaseConfig {
kind: "spt-inraid";
MIAOnRaidEnd: boolean;
/** Overrides to apply to the pre-raid settings screen */
raidMenuSettings: RaidMenuSettings;
/** What effects should be saved post-raid */
save: Save;
/** Names of car extracts */
carExtracts: string[];
/** Names of coop extracts */
coopExtracts: string[];
/** Fence rep gain from a single car extract */
carExtractBaseStandingGain: number;
/** Fence rep gain from a single coop extract */
coopExtractBaseStandingGain: number;
/** Fence rep gain when successfully extracting as pscav */
scavExtractGain: number;
/** The likelihood of PMC eliminating a minimum of 2 scavs while you engage them as a pscav. */
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;
aiDifficulty: string;
bossEnabled: boolean;
scavWars: boolean;
taggedAndCursed: boolean;
enablePve: boolean;
randomWeather: boolean;
randomTime: boolean;
}
export interface Save {
/** Should loot gained from raid be saved */
loot: boolean;
}

16
types/models/spt/config/IInsuranceConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,16 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IInsuranceConfig extends IBaseConfig {
kind: "spt-insurance";
/** Chance item is returned as insurance, keyed by trader id */
returnChancePercent: Record<string, number>;
/** Item slots that should never be returned as insurance */
blacklistedEquipment: string[];
/** Some slots should always be removed, e.g. 'cartridges' */
slotIdsToAlwaysRemove: string[];
/** Override to control how quickly insurance is processed/returned in second */
returnTimeOverrideSeconds: number;
/** How often server should process insurance in seconds */
runIntervalSeconds: number;
minAttachmentRoublePriceToBeTaken: number;
chanceNoAttachmentsTakenPercent: number;
}

29
types/models/spt/config/IInventoryConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,29 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IInventoryConfig extends IBaseConfig {
kind: "spt-inventory";
/** Should new items purchased by flagged as found in raid */
newItemsMarkedFound: boolean;
randomLootContainers: Record<string, RewardDetails>;
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;
foundInRaid: boolean;
rewardTplPool?: Record<string, number>;
rewardTypePool?: Record<string, number>;
}
export interface ISealedAirdropContainerSettings {
weaponRewardWeight: Record<string, number>;
defaultPresetsOnly: boolean;
/** Should contents be flagged as found in raid when opened */
foundInRaid: boolean;
weaponModRewardLimits: Record<string, MinMax>;
rewardTypeLimits: Record<string, MinMax>;
ammoBoxWhitelist: string[];
allowBossItems: boolean;
}

13
types/models/spt/config/IItemConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IItemConfig extends IBaseConfig {
kind: "spt-item";
/** Items that should be globally blacklisted */
blacklist: string[];
/** Items that should not be lootable from any location */
lootableItemBlacklist: 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>;
}

13
types/models/spt/config/ILocaleConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ILocaleConfig extends IBaseConfig {
kind: "spt-locale";
/** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */
gameLocale: string;
/** e.g. ru/en/cn/fr etc, or 'system', will take computer locale setting */
serverLocale: string;
/** Languages server can be translated into */
serverSupportedLocales: string[];
fallbacks: {
[locale: string]: string;
};
}

123
types/models/spt/config/ILocationConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,123 @@
import { MinMax } from "@spt/models/common/MinMax";
import { BossLocationSpawn, Wave } from "@spt/models/eft/common/ILocationBase";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ILocationConfig extends IBaseConfig {
kind: "spt-location";
/** Waves with a min/max of the same value don't spawn any bots, bsg only spawn the difference between min and max */
fixEmptyBotWavesSettings: IFixEmptyBotWavesSettings;
/** Rogues are classified as bosses and spawn immediatly, this can result in no scavs spawning, delay rogues spawning to allow scavs to spawn first */
rogueLighthouseSpawnTimeSettings: IRogueLighthouseSpawnTimeSettings;
/** When a map has hit max alive bots, any wave that should spawn will be reduced to 1 bot in size and placed in a spawn queue, this splits waves into smaller sizes to reduce the impact of this behaviour */
splitWaveIntoSingleSpawnsSettings: ISplitWaveSettings;
looseLootMultiplier: LootMultiplier;
staticLootMultiplier: LootMultiplier;
/** Custom bot waves to add to a locations base json on game start if addCustomBotWavesToMaps is true */
customWaves: CustomWaves;
/** Open zones to add to map */
openZones: Record<string, string[]>;
/** Key = map id, value = item tpls that should only have one forced loot spawn position */
forcedLootSingleSpawnById: Record<string, string[]>;
/** How many attempts should be taken to fit an item into a container before giving up */
fitLootIntoContainerAttempts: number;
/** Add all possible zones to each maps `OpenZones` property */
addOpenZonesToAllMaps: boolean;
/** Allow addition of custom bot waves designed by SPT to be added to maps - defined in configs/location.json.customWaves */
addCustomBotWavesToMaps: boolean;
/** Should the limits defined inside botTypeLimits to appled to locations on game start */
enableBotTypeLimits: boolean;
/** Add limits to a locations base.MinMaxBots array if enableBotTypeLimits is true */
botTypeLimits: Record<string, IBotTypeLimit[]>;
/** container randomisation settings */
containerRandomisationSettings: IContainerRandomistionSettings;
/** How full must a random loose magazine be % */
minFillLooseMagazinePercent: number;
/** How full must a random static magazine be % */
minFillStaticMagazinePercent: number;
allowDuplicateItemsInStaticContainers: boolean;
/** Chance loose magazines have ammo in them TODO - rename to dynamicMagazineLootHasAmmoChancePercent */
magazineLootHasAmmoChancePercent: number;
/** Chance static magazines have ammo in them */
staticMagazineLootHasAmmoChancePercent: number;
/** Key: map, value: loose loot ids to ignore */
looseLootBlacklist: Record<string, string[]>;
/** Key: map, value: settings to control how long scav raids are */
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>;
}
export interface IFixEmptyBotWavesSettings {
enabled: boolean;
ignoreMaps: string[];
}
export interface IRogueLighthouseSpawnTimeSettings {
enabled: boolean;
waitTimeSeconds: number;
}
export interface ISplitWaveSettings {
enabled: boolean;
ignoreMaps: string[];
waveSizeThreshold: number;
}
export interface CustomWaves {
/** Bosses spawn on raid start */
boss: Record<string, BossLocationSpawn[]>;
normal: Record<string, Wave[]>;
}
export interface IBotTypeLimit extends MinMax {
type: string;
}
/** Multiplier to apply to the loot count for a given map */
export interface LootMultiplier {
bigmap: number;
develop: number;
factory4_day: number;
factory4_night: number;
interchange: number;
laboratory: number;
rezervbase: number;
shoreline: number;
woods: number;
hideout: number;
lighthouse: number;
privatearea: number;
suburbs: number;
tarkovstreets: number;
terminal: number;
town: number;
sandbox: number;
}
export interface IContainerRandomistionSettings {
enabled: boolean;
/** What maps can use the container randomisation feature */
maps: Record<string, boolean>;
/** Some container types don't work when randomised */
containerTypesToNotRandomise: string[];
containerGroupMinSizeMultiplier: number;
containerGroupMaxSizeMultiplier: number;
}
export interface IScavRaidTimeSettings {
settings: IScavRaidTimeConfigSettings;
maps: Record<string, IScavRaidTimeLocationSettings>;
}
export interface IScavRaidTimeConfigSettings {
trainArrivalDelayObservedSeconds: number;
}
export interface IScavRaidTimeLocationSettings {
/** Should loot be reduced by same percent length of raid is reduced by */
reduceLootByPercent: boolean;
/** Smallest % of container loot that should be spawned */
minStaticLootPercent: number;
/** Smallest % of loose loot that should be spawned */
minDynamicLootPercent: number;
/** Chance raid time is reduced */
reducedChancePercent: number;
/** How much should raid time be reduced - weighted */
reductionPercentWeights: Record<string, number>;
/** Should bot waves be removed / spawn times be adjusted */
adjustWaves: boolean;
}

9
types/models/spt/config/ILootConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,9 @@
import { Spawnpoint } from "@spt/models/eft/common/ILooseLoot";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ILootConfig extends IBaseConfig {
kind: "spt-loot";
/** Spawn positions to add into a map, key=mapid */
looseLoot: Record<string, Spawnpoint[]>;
/** Loose loot probability adjustments to apply on game start */
looseLootSpawnPointAdjustments: Record<string, Record<string, number>>;
}

25
types/models/spt/config/ILostOnDeathConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,25 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ILostOnDeathConfig extends IBaseConfig {
kind: "spt-lostondeath";
/** What equipment in each slot should be lost on death */
equipment: Equipment;
/** Should special slot items be removed from quest inventory on death e.g. wifi camera/markers */
specialSlotItems: boolean;
/** Should quest items be removed from quest inventory on death */
questItems: boolean;
}
export interface Equipment {
ArmBand: boolean;
Headwear: boolean;
Earpiece: boolean;
FaceCover: boolean;
ArmorVest: boolean;
Eyewear: boolean;
TacticalVest: boolean;
PocketItems: boolean;
Backpack: boolean;
Holster: boolean;
FirstPrimaryWeapon: boolean;
SecondPrimaryWeapon: boolean;
Scabbard: boolean;
}

5
types/models/spt/config/IMatchConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IMatchConfig extends IBaseConfig {
kind: "spt-match";
enabled: boolean;
}

25
types/models/spt/config/IPlayerScavConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,25 @@
import { GenerationData } from "@spt/models/eft/common/tables/IBotType";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IPlayerScavConfig extends IBaseConfig {
kind: "spt-playerscav";
karmaLevel: Record<string, KarmaLevel>;
}
export interface KarmaLevel {
botTypeForLoot: string;
modifiers: Modifiers;
itemLimits: ItemLimits;
equipmentBlacklist: Record<string, string[]>;
lootItemsToAddChancePercent: Record<string, number>;
}
export interface Modifiers {
equipment: Record<string, number>;
mod: Record<string, number>;
}
export interface ItemLimits {
healing: GenerationData;
drugs: GenerationData;
stims: GenerationData;
looseLoot: GenerationData;
magazines: GenerationData;
grenades: GenerationData;
}

13
types/models/spt/config/IPmChatResponse.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IPmcChatResponse extends IBaseConfig {
kind: "spt-pmcchatresponse";
victim: IResponseSettings;
killer: IResponseSettings;
}
export interface IResponseSettings {
responseChancePercent: number;
responseTypeWeights: Record<string, number>;
stripCapitalisationChancePercent: number;
allCapsChancePercent: number;
appendBroToMessageEndChancePercent: number;
}

60
types/models/spt/config/IPmcConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,60 @@
import { MinMax } from "@spt/models/common/MinMax";
import { MemberCategory } from "@spt/models/enums/MemberCategory";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IPmcConfig extends IBaseConfig {
kind: "spt-pmc";
/** What game version should the PMC have */
gameVersionWeight: Record<string, number>;
/** What account type should the PMC have */
accountTypeWeight: Record<MemberCategory, number>;
/** Global whitelist/blacklist of vest loot for PMCs */
vestLoot: SlotLootSettings;
/** Global whitelist/blacklist of pocket loot for PMCs */
pocketLoot: SlotLootSettings;
/** Global whitelist/blacklist of backpack loot for PMCs */
backpackLoot: SlotLootSettings;
/** Use difficulty defined in config/bot.json/difficulty instead of chosen difficulty dropdown value */
useDifficultyOverride: boolean;
/** Difficulty override e.g. "AsOnline/Hard" */
difficulty: string;
/** Chance out of 100 to have a complete gun in backpack */
looseWeaponInBackpackChancePercent: number;
/** Chance out of 100 to have an enhancement applied to PMC weapon */
weaponHasEnhancementChancePercent: number;
/** MinMax count of weapons to have in backpack */
looseWeaponInBackpackLootMinMax: MinMax;
/** Percentage chance PMC will be USEC */
isUsec: number;
/** WildSpawnType enum value USEC PMCs use */
usecType: string;
/** WildSpawnType enum value BEAR PMCs use */
bearType: string;
chanceSameSideIsHostilePercent: number;
/** What 'brain' does a PMC use, keyed by map and side (USEC/BEAR) key: map location, value: type for usec/bear */
pmcType: Record<string, Record<string, Record<string, number>>>;
maxBackpackLootTotalRub: number;
maxPocketLootTotalRub: number;
maxVestLootTotalRub: number;
/** Percentage chance a bot from a wave is converted into a PMC, key = bot wildspawn tpye (assault/exusec), value: min+max chance to be converted */
convertIntoPmcChance: Record<string, MinMax>;
/** WildSpawnType bots PMCs should see as hostile */
enemyTypes: string[];
/** How many levels above player level can a PMC be */
botRelativeLevelDeltaMax: number;
/** How many levels below player level can a PMC be */
botRelativeLevelDeltaMin: number;
/** Force a number of healing items into PMCs secure container to ensure they can heal */
forceHealingItemsIntoSecure: boolean;
allPMCsHavePlayerNameWithRandomPrefixChance: number;
locationSpecificPmcLevelOverride: Record<string, MinMax>;
/** Should secure container loot from usec.json/bear.json be added to pmc bots secure */
addSecureContainerLootFromBotConfig: boolean;
}
export interface PmcTypes {
usec: string;
bear: string;
}
export interface SlotLootSettings {
whitelist: string[];
blacklist: string[];
}

144
types/models/spt/config/IQuestConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,144 @@
import { MinMax } from "@spt/models/common/MinMax";
import { ELocationName } from "@spt/models/enums/ELocationName";
import { SeasonalEventType } from "@spt/models/enums/SeasonalEventType";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IQuestConfig extends IBaseConfig {
kind: "spt-quest";
mailRedeemTimeHours: Record<string, number>;
questTemplateIds: IPlayerTypeQuestIds;
/** Show non-seasonal quests be shown to player */
showNonSeasonalEventQuests: boolean;
eventQuests: Record<string, IEventQuestData>;
repeatableQuests: IRepeatableQuestConfig[];
locationIdMap: Record<string, string>;
bearOnlyQuests: string[];
usecOnlyQuests: string[];
}
export interface IPlayerTypeQuestIds {
pmc: IQuestTypeIds;
scav: IQuestTypeIds;
}
export interface IQuestTypeIds {
Elimination: string;
Completion: string;
Exploration: string;
}
export interface IEventQuestData {
name: string;
season: SeasonalEventType;
startTimestamp: number;
endTimestamp: number;
yearly: boolean;
}
export interface IRepeatableQuestConfig {
id: string;
name: string;
side: string;
types: string[];
resetTime: number;
numQuests: number;
minPlayerLevel: number;
rewardScaling: IRewardScaling;
locations: Record<ELocationName, string[]>;
traderWhitelist: ITraderWhitelist[];
questConfig: IRepeatableQuestTypesConfig;
/** Item base types to block when generating rewards */
rewardBaseTypeBlacklist: string[];
/** Item tplIds to ignore when generating rewards */
rewardBlacklist: string[];
rewardAmmoStackMinSize: number;
freeChangesAvailable: number;
freeChanges: number;
}
export interface IRewardScaling {
levels: number[];
experience: number[];
roubles: number[];
gpCoins: number[];
items: number[];
reputation: number[];
rewardSpread: number;
skillRewardChance: number[];
skillPointReward: number[];
}
export interface ITraderWhitelist {
traderId: string;
questTypes: string[];
rewardBaseWhitelist: string[];
rewardCanBeWeapon: boolean;
weaponRewardChancePercent: number;
}
export interface IRepeatableQuestTypesConfig {
Exploration: IExploration;
Completion: ICompletion;
Pickup: IPickup;
Elimination: IEliminationConfig[];
}
export interface IExploration extends IBaseQuestConfig {
maxExtracts: number;
maxExtractsWithSpecificExit: number;
specificExits: ISpecificExits;
}
export interface ISpecificExits {
probability: number;
passageRequirementWhitelist: string[];
}
export interface ICompletion extends IBaseQuestConfig {
minRequestedAmount: number;
maxRequestedAmount: number;
uniqueItemCount: number;
minRequestedBulletAmount: number;
maxRequestedBulletAmount: number;
useWhitelist: boolean;
useBlacklist: boolean;
}
export interface IPickup extends IBaseQuestConfig {
ItemTypeToFetchWithMaxCount: IPickupTypeWithMaxCount[];
}
export interface IPickupTypeWithMaxCount {
itemType: string;
maxPickupCount: number;
minPickupCount: number;
}
export interface IEliminationConfig extends IBaseQuestConfig {
levelRange: MinMax;
targets: ITarget[];
bodyPartProb: number;
bodyParts: IBodyPart[];
specificLocationProb: number;
distLocationBlacklist: string[];
distProb: number;
maxDist: number;
minDist: number;
maxKills: number;
minKills: number;
minBossKills: number;
maxBossKills: number;
minPmcKills: number;
maxPmcKills: number;
weaponCategoryRequirementProb: number;
weaponCategoryRequirements: IWeaponRequirement[];
weaponRequirementProb: number;
weaponRequirements: IWeaponRequirement[];
}
export interface IBaseQuestConfig {
possibleSkillRewards: string[];
}
export interface ITarget extends IProbabilityObject {
data: IBossInfo;
}
export interface IBossInfo {
isBoss: boolean;
isPmc: boolean;
}
export interface IBodyPart extends IProbabilityObject {
data: string[];
}
export interface IWeaponRequirement extends IProbabilityObject {
data: string[];
}
export interface IProbabilityObject {
key: string;
relativeProbability: number;
data?: any;
}

158
types/models/spt/config/IRagfairConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,158 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig, IRunIntervalValues } from "@spt/models/spt/config/IBaseConfig";
export interface IRagfairConfig extends IBaseConfig {
kind: "spt-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 */
traders: Record<string, boolean>;
dynamic: Dynamic;
}
export interface Sell {
/** Should a fee be deducted from player when liting an item for sale */
fees: boolean;
/** Settings to control chances of offer being sold */
chance: Chance;
/** Settings to control how long it takes for a player offer to sell */
time: MinMax;
/** Seconds from clicking remove to remove offer from market */
expireSeconds: number;
}
export interface Chance {
/** Base chance percent to sell an item */
base: number;
/** Value to multiply the sell chance by */
sellMultiplier: number;
/** Max possible sell chance % for a player listed offer */
maxSellChancePercent: number;
/** Min possible sell chance % for a player listed offer */
minSellChancePercent: number;
}
export interface Dynamic {
purchasesAreFoundInRaid: boolean;
/** Use the highest trader price for an offer if its greater than the price in templates/prices.json */
useTraderPriceForOffersIfHigher: boolean;
/** Barter offer specific settings */
barter: IBarterDetails;
pack: IPackDetails;
/** Dynamic offer price below handbook adjustment values */
offerAdjustment: OfferAdjustment;
/** How many offers should expire before an offer regeneration occurs */
expiredOfferThreshold: number;
/** How many offers should be listed */
offerItemCount: MinMax;
/** How much should the price of an offer vary by (percent 0.8 = 80%, 1.2 = 120%) */
priceRanges: IPriceRanges;
/** Should default presets to listed only or should non-standard presets found in globals.json be listed too */
showDefaultPresetsOnly: boolean;
endTimeSeconds: MinMax;
/** Settings to control the durability range of item items listed on flea */
condition: Condition;
/** Size stackable items should be listed for in percent of max stack size */
stackablePercent: MinMax;
/** Items that cannot be stacked can have multiples sold in one offer, what range of values can be listed */
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 */
currencies: Record<string, number>;
/** Item tpls that should be forced to sell as a single item */
showAsSingleStack: string[];
/** Should christmas/halloween items be removed from flea when not within the seasonal bounds */
removeSeasonalItemsWhenNotInEvent: boolean;
/** Flea blacklist settings */
blacklist: Blacklist;
/** Dict of price limits keyed by item type */
unreasonableModPrices: Record<string, IUnreasonableModPrices>;
}
export interface IPriceRanges {
default: MinMax;
preset: MinMax;
pack: MinMax;
}
export interface IBarterDetails {
/** Percentage change an offer is listed as a barter */
chancePercent: number;
/** Min number of required items for a barter requirement */
itemCountMin: number;
/** Max number of required items for a barter requirement */
itemCountMax: number;
/** How much can the total price of requested items vary from the item offered */
priceRangeVariancePercent: number;
/** Min rouble price for an offer to be considered for turning into a barter */
minRoubleCostToBecomeBarter: number;
/** Item Tpls to never be turned into a barter */
itemTypeBlacklist: string[];
}
export interface IPackDetails {
/** Percentage change an offer is listed as a pack */
chancePercent: number;
/** Min number of required items for a pack */
itemCountMin: number;
/** Max number of required items for a pack */
itemCountMax: number;
/** item types to allow being a pack */
itemTypeWhitelist: string[];
}
export interface OfferAdjustment {
/** Shuld offer price be adjusted when below handbook price */
adjustPriceWhenBelowHandbookPrice: boolean;
/** How big a percentage difference does price need to vary from handbook to be considered for adjustment */
maxPriceDifferenceBelowHandbookPercent: number;
/** How much to multiply the handbook price to get the new price */
handbookPriceMultipier: number;
/** What is the minimum rouble price to consider adjusting price of item */
priceThreshholdRub: number;
}
export interface Condition {
/** Percentage change durability is altered */
conditionChance: number;
current: MinMax;
max: MinMax;
}
export interface Blacklist {
/** Damaged ammo packs */
damagedAmmoPacks: boolean;
/** Custom blacklist for item Tpls */
custom: string[];
/** BSG blacklist a large number of items from flea, true = use blacklist */
enableBsgList: boolean;
/** Should quest items be blacklisted from flea */
enableQuestList: boolean;
/** Should trader items that are blacklisted by bsg be listed on flea */
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 */
maxProtectionLevel: number;
/** Item slots to NOT remove from items on flea */
ignoreSlots: string[];
}
export interface IUnreasonableModPrices {
/** Enable a system that adjusts very high ragfair prices to be below a max multiple of items the handbook values */
enabled: boolean;
/** Multipler to start adjusting item values from, e.g. a value of 10 means any value over 10x the handbook price gets adjusted */
handbookPriceOverMultiplier: number;
/** 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[];
}

47
types/models/spt/config/IRepairConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,47 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IRepairConfig extends IBaseConfig {
kind: "spt-repair";
priceMultiplier: number;
applyRandomizeDurabilityLoss: boolean;
weaponSkillRepairGain: number;
armorKitSkillPointGainPerRepairPointMultiplier: number;
/** INT gain multiplier per repaired item type */
repairKitIntellectGainMultiplier: IIntellectGainValues;
maxIntellectGainPerRepair: IMaxIntellectGainValues;
weaponTreatment: IWeaponTreatmentRepairValues;
repairKit: RepairKit;
}
export interface IIntellectGainValues {
weapon: number;
armor: number;
}
export interface IMaxIntellectGainValues {
kit: number;
trader: number;
}
export interface IWeaponTreatmentRepairValues {
/** The chance to gain more weapon maintenance skill */
critSuccessChance: number;
critSuccessAmount: number;
/** The chance to gain less weapon maintenance skill */
critFailureChance: number;
critFailureAmount: number;
/** The multiplier used for calculating weapon maintenance XP */
pointGainMultiplier: number;
}
export interface RepairKit {
armor: BonusSettings;
weapon: BonusSettings;
}
export interface BonusSettings {
rarityWeight: Record<string, number>;
bonusTypeWeight: Record<string, number>;
common: Record<string, BonusValues>;
rare: Record<string, BonusValues>;
}
export interface BonusValues {
valuesMinMax: MinMax;
/** What dura is buff active between (min max of current max) */
activeDurabilityPercentMinMax: MinMax;
}

31
types/models/spt/config/IScavCaseConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,31 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IScavCaseConfig extends IBaseConfig {
kind: "spt-scavcase";
rewardItemValueRangeRub: Record<string, MinMax>;
moneyRewards: MoneyRewards;
ammoRewards: AmmoRewards;
rewardItemParentBlacklist: string[];
rewardItemBlacklist: string[];
allowMultipleMoneyRewardsPerRarity: boolean;
allowMultipleAmmoRewardsPerRarity: boolean;
allowBossItemsAsRewards: boolean;
}
export interface MoneyRewards {
moneyRewardChancePercent: number;
rubCount: MoneyLevels;
usdCount: MoneyLevels;
eurCount: MoneyLevels;
gpCount: MoneyLevels;
}
export interface MoneyLevels {
common: MinMax;
rare: MinMax;
superrare: MinMax;
}
export interface AmmoRewards {
ammoRewardChancePercent: number;
ammoRewardBlacklist: Record<string, string[]>;
ammoRewardValueRangeRub: Record<string, MinMax>;
minStackSize: number;
}

26
types/models/spt/config/ISeasonalEventConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,26 @@
import { BossLocationSpawn } from "@spt/models/eft/common/ILocationBase";
import { SeasonalEventType } from "@spt/models/enums/SeasonalEventType";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface ISeasonalEventConfig extends IBaseConfig {
kind: "spt-seasonalevents";
enableSeasonalEventDetection: boolean;
/** event / botType / equipSlot / itemid */
eventGear: Record<string, Record<string, Record<string, Record<string, number>>>>;
events: ISeasonalEvent[];
eventBotMapping: Record<string, string>;
eventBossSpawns: Record<string, Record<string, BossLocationSpawn[]>>;
gifterSettings: GifterSetting[];
}
export interface ISeasonalEvent {
name: string;
type: SeasonalEventType;
startDay: number;
startMonth: number;
endDay: number;
endMonth: number;
}
export interface GifterSetting {
map: string;
zones: string;
spawnChance: number;
}

65
types/models/spt/config/ITraderConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,65 @@
import { MinMax } from "@spt/models/common/MinMax";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
import { LootRequest } from "@spt/models/spt/services/LootRequest";
export interface ITraderConfig extends IBaseConfig {
kind: "spt-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;
fence: FenceConfig;
}
export interface UpdateTime {
traderId: string;
/** Seconds between trader resets */
seconds: MinMax;
}
export interface FenceConfig {
discountOptions: DiscountOptions;
partialRefreshTimeSeconds: number;
partialRefreshChangePercent: number;
assortSize: number;
weaponPresetMinMax: MinMax;
equipmentPresetMinMax: MinMax;
itemPriceMult: number;
presetPriceMult: number;
armorMaxDurabilityPercentMinMax: IItemDurabilityCurrentMax;
weaponDurabilityPercentMinMax: IItemDurabilityCurrentMax;
/** Keyed to plate protection level */
chancePlateExistsInArmorPercent: Record<string, 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>;
/** Each slotid with % to be removed prior to listing on fence */
presetSlotsToRemoveChancePercent: Record<string, number>;
/** Block seasonal items from appearing when season is inactive */
blacklistSeasonalItems: boolean;
/** Max pen value allowed to be listed on flea - affects ammo + ammo boxes */
ammoMaxPenLimit: number;
blacklist: string[];
coopExtractGift: CoopExtractReward;
btrDeliveryExpireHours: number;
}
export interface IItemDurabilityCurrentMax {
current: MinMax;
max: MinMax;
}
export interface CoopExtractReward extends LootRequest {
sendGift: boolean;
messageLocaleIds: string[];
giftExpiryHours: number;
}
export interface DiscountOptions {
assortSize: number;
itemPriceMult: number;
presetPriceMult: number;
weaponPresetMinMax: MinMax;
equipmentPresetMinMax: MinMax;
}

34
types/models/spt/config/IWeatherConfig.d.ts vendored Normal file
View File

@@ -0,0 +1,34 @@
import { MinMax } from "@spt/models/common/MinMax";
import { Season } from "@spt/models/enums/Season";
import { WindDirection } from "@spt/models/enums/WindDirection";
import { IBaseConfig } from "@spt/models/spt/config/IBaseConfig";
export interface IWeatherConfig extends IBaseConfig {
kind: "spt-weather";
acceleration: number;
weather: Weather;
seasonDates: ISeasonDateTimes[];
overrideSeason?: Season;
}
export interface ISeasonDateTimes {
seasonType: Season;
name: string;
startDay: number;
startMonth: number;
endDay: number;
endMonth: number;
}
export interface Weather {
clouds: WeatherSettings<string>;
windSpeed: WeatherSettings<number>;
windDirection: WeatherSettings<WindDirection>;
windGustiness: MinMax;
rain: WeatherSettings<number>;
rainIntensity: MinMax;
fog: WeatherSettings<string>;
temp: MinMax;
pressure: MinMax;
}
export interface WeatherSettings<T> {
values: T[];
weights: number[];
}

13
types/models/spt/controllers/IBotController.d.ts vendored Normal file
View File

@@ -0,0 +1,13 @@
import { IGenerateBotsRequestData } from "@spt/models/eft/bot/IGenerateBotsRequestData";
import { IBotBase } from "@spt/models/eft/common/tables/IBotBase";
import { IBotCore } from "@spt/models/eft/common/tables/IBotCore";
import { Difficulty } from "@spt/models/eft/common/tables/IBotType";
export interface IBotController {
getBotLimit(type: string): number;
getBotDifficulty(type: string, difficulty: string): IBotCore | Difficulty;
isBotPmc(botRole: string): boolean;
isBotBoss(botRole: string): boolean;
isBotFollower(botRole: string): boolean;
generate(info: IGenerateBotsRequestData, playerScav: boolean): IBotBase[];
getBotCap(): number;
}

46
types/models/spt/dialog/ISendMessageDetails.d.ts vendored Normal file
View File

@@ -0,0 +1,46 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
import { ISystemData, IUserDialogInfo, MessageContentRagfair } from "@spt/models/eft/profile/ISptProfile";
import { MessageType } from "@spt/models/enums/MessageType";
import { Traders } from "@spt/models/enums/Traders";
export interface ISendMessageDetails {
/** Player id */
recipientId: string;
/** Who is sending this message */
sender: MessageType;
/** Optional - leave blank to use sender value */
dialogType?: MessageType;
/** Optional - if sender is USER these details are used */
senderDetails?: IUserDialogInfo;
/** Optional - the trader sending the message */
trader?: Traders;
/** Optional - used in player/system messages, otherwise templateId is used */
messageText?: string;
/** Optinal - Items to send to player */
items?: Item[];
/** Optional - How long items will be stored in mail before expiry */
itemsMaxStorageLifetimeSeconds?: number;
/** Optional - Used when sending messages from traders who send text from locale json */
templateId?: string;
/** Optional - ragfair related */
systemData?: ISystemData;
/** Optional - Used by ragfair messages */
ragfairDetails?: MessageContentRagfair;
/** OPTIONAL - allows modification of profile settings via mail */
profileChangeEvents?: IProfileChangeEvent[];
}
export interface IProfileChangeEvent {
_id: string;
Type: ProfileChangeEventType;
value: number;
entity?: string;
}
export declare enum ProfileChangeEventType {
TRADER_SALES_SUM = "TraderSalesSum",
TRADER_STANDING = "TraderStanding",
PROFILE_LEVEL = "ProfileLevel",
SKILL_POINTS = "SkillPoints",
EXAMINE_ALL_ITEMS = "ExamineAllItems",
UNLOCK_TRADER = "UnlockTrader",
ASSORT_UNLOCK_RULE = "AssortmentUnlockRule",
HIDEOUT_AREA_LEVEL = "HideoutAreaLevel"
}

7
types/models/spt/fence/ICreateFenceAssortsResult.d.ts vendored Normal file
View File

@@ -0,0 +1,7 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
import { IBarterScheme } from "@spt/models/eft/common/tables/ITrader";
export interface ICreateFenceAssortsResult {
sptItems: Item[][];
barter_scheme: Record<string, IBarterScheme[][]>;
loyal_level_items: Record<string, number>;
}

9
types/models/spt/fence/IFenceAssortGenerationValues.d.ts vendored Normal file
View File

@@ -0,0 +1,9 @@
export interface IFenceAssortGenerationValues {
normal: IGenerationAssortValues;
discount: IGenerationAssortValues;
}
export interface IGenerationAssortValues {
item: number;
weaponPreset: number;
equipmentPreset: number;
}

5
types/models/spt/generators/IBotGenerator.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
import { Inventory as PmcInventory } from "@spt/models/eft/common/tables/IBotBase";
import { Chances, Generation, Inventory } from "@spt/models/eft/common/tables/IBotType";
export interface IBotGenerator {
generateInventory(templateInventory: Inventory, equipmentChances: Chances, generation: Generation, botRole: string, isPmc: boolean): PmcInventory;
}

6
types/models/spt/generators/ILocationGenerator.d.ts vendored Normal file
View File

@@ -0,0 +1,6 @@
import { IStaticAmmoDetails, IStaticContainerProps, IStaticForcedProps, IStaticLootDetails } from "@spt/models/eft/common/ILocation";
import { ILooseLoot, SpawnpointTemplate } from "@spt/models/eft/common/ILooseLoot";
export interface ILocationGenerator {
generateContainerLoot(containerIn: IStaticContainerProps, staticForced: IStaticForcedProps[], staticLootDist: Record<string, IStaticLootDetails>, staticAmmoDist: Record<string, IStaticAmmoDetails[]>, locationName: string): IStaticContainerProps;
generateDynamicLoot(dynamicLootDist: ILooseLoot, staticAmmoDist: Record<string, IStaticAmmoDetails[]>, locationName: string): SpawnpointTemplate[];
}

4
types/models/spt/generators/IPMCLootGenerator.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
export interface IPMCLootGenerator {
generatePMCPocketLootPool(): string[];
generatePMCBackpackLootPool(): string[];
}

4
types/models/spt/generators/IRagfairAssortGenerator.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
export interface IRagfairAssortGenerator {
getAssortItems(): Item[];
}

6
types/models/spt/generators/IRagfairOfferGenerator.d.ts vendored Normal file
View File

@@ -0,0 +1,6 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
import { IBarterScheme } from "@spt/models/eft/common/tables/ITrader";
import { IRagfairOffer } from "@spt/models/eft/ragfair/IRagfairOffer";
export interface IRagfairOfferGenerator {
createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, price: number, sellInOnePiece: boolean): IRagfairOffer;
}

12
types/models/spt/hideout/IHideout.d.ts vendored Normal file
View File

@@ -0,0 +1,12 @@
import { IHideoutArea } from "@spt/models/eft/hideout/IHideoutArea";
import { IHideoutProduction } from "@spt/models/eft/hideout/IHideoutProduction";
import { IHideoutScavCase } from "@spt/models/eft/hideout/IHideoutScavCase";
import { IHideoutSettingsBase } from "@spt/models/eft/hideout/IHideoutSettingsBase";
import { IQteData } from "@spt/models/eft/hideout/IQteData";
export interface IHideout {
areas: IHideoutArea[];
production: IHideoutProduction[];
scavcase: IHideoutScavCase[];
settings: IHideoutSettingsBase;
qte: IQteData[];
}

11
types/models/spt/hideout/ScavCaseRewardCountsAndPrices.d.ts vendored Normal file
View File

@@ -0,0 +1,11 @@
export interface ScavCaseRewardCountsAndPrices {
Common: RewardCountAndPriceDetails;
Rare: RewardCountAndPriceDetails;
Superrare: RewardCountAndPriceDetails;
}
export interface RewardCountAndPriceDetails {
minCount: number;
maxCount: number;
minPriceRub: number;
maxPriceRub: number;
}

9
types/models/spt/inventory/IOwnerInventoryItems.d.ts vendored Normal file
View File

@@ -0,0 +1,9 @@
import { Item } from "@spt/models/eft/common/tables/IItem";
export interface IOwnerInventoryItems {
/** Inventory items from source */
from: Item[];
/** Inventory items at destination */
to: Item[];
sameInventory: boolean;
isMail: boolean;
}

8
types/models/spt/location/IRaidChanges.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
export interface IRaidChanges {
/** What percentage of dynamic loot should the map contain */
dynamicLootPercent: number;
/** What percentage of static loot should the map contain */
staticLootPercent: number;
/** How many seconds into the raid is the player simulated to spawn in at */
simulatedRaidStartSeconds: number;
}

8
types/models/spt/logging/IClientLogRequest.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
import { LogLevel } from "@spt/models/spt/logging/LogLevel";
export interface IClientLogRequest {
Source: string;
Level: LogLevel | string;
Message: string;
Color?: string;
BackgroundColor?: string;
}

11
types/models/spt/logging/LogBackgroundColor.d.ts vendored Normal file
View File

@@ -0,0 +1,11 @@
export declare enum LogBackgroundColor {
DEFAULT = "",
BLACK = "blackBG",
RED = "redBG",
GREEN = "greenBG",
YELLOW = "yellowBG",
BLUE = "blueBG",
MAGENTA = "magentaBG",
CYAN = "cyanBG",
WHITE = "whiteBG"
}

8
types/models/spt/logging/LogLevel.d.ts vendored Normal file
View File

@@ -0,0 +1,8 @@
export declare enum LogLevel {
ERROR = 0,
WARN = 1,
SUCCESS = 2,
INFO = 3,
CUSTOM = 4,
DEBUG = 5
}

11
types/models/spt/logging/LogTextColor.d.ts vendored Normal file
View File

@@ -0,0 +1,11 @@
export declare enum LogTextColor {
BLACK = "black",
RED = "red",
GREEN = "green",
YELLOW = "yellow",
BLUE = "blue",
MAGENTA = "magenta",
CYAN = "cyan",
WHITE = "white",
GRAY = "gray"
}

7
types/models/spt/logging/SptLogger.d.ts vendored Normal file
View File

@@ -0,0 +1,7 @@
export interface SptLogger {
error: (msg: string | Record<string, unknown>) => void;
warn: (msg: string | Record<string, unknown>) => void;
succ?: (msg: string | Record<string, unknown>) => void;
info: (msg: string | Record<string, unknown>) => void;
debug: (msg: string | Record<string, unknown>) => void;
}

5
types/models/spt/mod/IModLoader.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
import { DependencyContainer } from "tsyringe";
export interface IModLoader {
load(container: DependencyContainer): void;
getModPath(mod: string): string;
}

19
types/models/spt/mod/IPackageJsonData.d.ts vendored Normal file
View File

@@ -0,0 +1,19 @@
export interface IPackageJsonData {
incompatibilities?: string[];
loadBefore?: string[];
loadAfter?: string[];
dependencies?: Record<string, string>;
modDependencies?: Record<string, string>;
name: string;
url: string;
author: string;
version: string;
sptVersion: string;
/** We deliberately purge this data */
scripts: Record<string, string>;
devDependencies: Record<string, string>;
licence: string;
main: string;
isBundleMod: boolean;
contributors: string[];
}

41
types/models/spt/mod/NewItemDetails.d.ts vendored Normal file
View File

@@ -0,0 +1,41 @@
import { ITemplateItem, Props } from "@spt/models/eft/common/tables/ITemplateItem";
export declare abstract class NewItemDetailsBase {
/** Price of the item on flea market */
fleaPriceRoubles: number;
/** Price of the item in the handbook */
handbookPriceRoubles: number;
/** Handbook ParentId for the new item */
handbookParentId: string;
/**
* A dictionary for locale settings, key = langauge (e.g. en,cn,es-mx,jp,fr)
* If a language is not included, the first item in the array will be used in its place
*/
locales: Record<string, LocaleDetails>;
}
export declare class NewItemFromCloneDetails extends NewItemDetailsBase {
/** Id of the item to copy and use as a base */
itemTplToClone: string;
/** Item properties that should be applied over the top of the cloned base */
overrideProperties: Props;
/** ParentId for the new item (item type) */
parentId: string;
/**
* the id the new item should have, leave blank to have one generated for you
* This is often known as the TplId, or TemplateId
*/
newId: string;
}
export declare class NewItemDetails extends NewItemDetailsBase {
newItem: ITemplateItem;
}
export declare class LocaleDetails {
name: string;
shortName: string;
description: string;
}
export declare class CreateItemResult {
constructor();
success: boolean;
itemId: string;
errors: string[];
}

5
types/models/spt/quests/IGetRepeatableByIdResult.d.ts vendored Normal file
View File

@@ -0,0 +1,5 @@
import { IPmcDataRepeatableQuest, IRepeatableQuest } from "@spt/models/eft/common/tables/IRepeatableQuests";
export interface IGetRepeatableByIdResult {
quest: IRepeatableQuest;
repeatableType: IPmcDataRepeatableQuest;
}

4
types/models/spt/ragfair/IRagfairServerPrices.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
export interface IRagfairServerPrices {
static: Record<string, number>;
dynamic: Record<string, number>;
}

9
types/models/spt/repeatable/IQuestRewardValues.d.ts vendored Normal file
View File

@@ -0,0 +1,9 @@
export interface IQuestRewardValues {
skillPointReward: number;
skillRewardChance: number;
rewardReputation: number;
rewardNumItems: number;
rewardRoubles: number;
gpCoinRewardCount: number;
rewardXP: number;
}

32
types/models/spt/repeatable/IQuestTypePool.d.ts vendored Normal file
View File

@@ -0,0 +1,32 @@
import { ELocationName } from "@spt/models/enums/ELocationName";
export interface IQuestTypePool {
types: string[];
pool: IQuestPool;
}
export interface IQuestPool {
Exploration: IExplorationPool;
Elimination: IEliminationPool;
Pickup: IExplorationPool;
}
export interface IExplorationPool {
locations: Partial<Record<ELocationName, string[]>>;
}
export interface IEliminationPool {
targets: IEliminationTargetPool;
}
export interface IEliminationTargetPool {
Savage?: ITargetLocation;
AnyPmc?: ITargetLocation;
bossBully?: ITargetLocation;
bossGluhar?: ITargetLocation;
bossKilla?: ITargetLocation;
bossSanitar?: ITargetLocation;
bossTagilla?: ITargetLocation;
bossKnight?: ITargetLocation;
bossZryachiy?: ITargetLocation;
bossBoar?: ITargetLocation;
bossBoarSniper?: ITargetLocation;
}
export interface ITargetLocation {
locations: string[];
}

17
types/models/spt/server/ExhaustableArray.d.ts vendored Normal file
View File

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

22
types/models/spt/server/IDatabaseTables.d.ts vendored Normal file
View File

@@ -0,0 +1,22 @@
import { IGlobals } from "@spt/models/eft/common/IGlobals";
import { IMatch } from "@spt/models/eft/common/tables/IMatch";
import { ITrader } from "@spt/models/eft/common/tables/ITrader";
import { IBots } from "@spt/models/spt/bots/IBots";
import { IHideout } from "@spt/models/spt/hideout/IHideout";
import { ILocaleBase } from "@spt/models/spt/server/ILocaleBase";
import { ILocations } from "@spt/models/spt/server/ILocations";
import { IServerBase } from "@spt/models/spt/server/IServerBase";
import { ISettingsBase } from "@spt/models/spt/server/ISettingsBase";
import { ITemplates } from "@spt/models/spt/templates/ITemplates";
export interface IDatabaseTables {
bots?: IBots;
hideout?: IHideout;
locales?: ILocaleBase;
locations?: ILocations;
match?: IMatch;
templates?: ITemplates;
traders?: Record<string, ITrader>;
globals?: IGlobals;
server?: IServerBase;
settings?: ISettingsBase;
}

6
types/models/spt/server/ILocaleBase.d.ts vendored Normal file
View File

@@ -0,0 +1,6 @@
export interface ILocaleBase {
global: Record<string, Record<string, string>>;
menu: Record<string, string>;
languages: Record<string, string>;
server: Record<string, Record<string, string>>;
}

24
types/models/spt/server/ILocations.d.ts vendored Normal file
View File

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

4
types/models/spt/server/IServerBase.d.ts vendored Normal file
View File

@@ -0,0 +1,4 @@
export interface IServerBase {
ip: string;
port: number;
}

Some files were not shown because too many files have changed in this diff Show More