Initial release for SPT 3.9

types/models/eft/bot/IGenerateBotsRequestData.d.ts

@@ -0,0 +1,9 @@
+export interface IGenerateBotsRequestData {
+    conditions: Condition[];
+}
+export interface Condition {
+    /** e.g. assault/pmcBot/bossKilla */
+    Role: string;
+    Limit: number;
+    Difficulty: string;
+}

types/models/eft/bot/IRandomisedBotLevelResult.d.ts

@@ -0,0 +1,4 @@
+export interface IRandomisedBotLevelResult {
+    level: number;
+    exp: number;
+}

types/models/eft/builds/ISetMagazineRequest.d.ts

@@ -0,0 +1,9 @@
+import { IMagazineTemplateAmmoItem } from "@spt/models/eft/profile/ISptProfile";
+export interface ISetMagazineRequest {
+    Id: string;
+    Name: string;
+    Caliber: string;
+    Items: IMagazineTemplateAmmoItem[];
+    TopCount: number;
+    BottomCount: number;
+}

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

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

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

@@ -0,0 +1,84 @@
+import { Exit, ILocationBase } from "@spt/models/eft/common/ILocationBase";
+import { ILooseLoot } from "@spt/models/eft/common/ILooseLoot";
+import { Ixyz } from "@spt/models/eft/common/Ixyz";
+import { Item } from "@spt/models/eft/common/tables/IItem";
+export interface ILocation {
+    /** Map meta-data */
+    base: ILocationBase;
+    /** Loose loot postions and item weights */
+    looseLoot: ILooseLoot;
+    /** Static loot item weights */
+    staticLoot: Record<string, IStaticLootDetails>;
+    /** Static container postions and item weights */
+    staticContainers: IStaticContainerDetails;
+    staticAmmo: Record<string, IStaticAmmoDetails[]>;
+    /** All possible static containers on map + their assign groupings */
+    statics: IStaticContainer;
+    /** All possible map extracts */
+    allExtracts: Exit[];
+}
+export interface IStaticContainer {
+    containersGroups: Record<string, IContainerMinMax>;
+    containers: Record<string, IContainerData>;
+}
+export interface IContainerMinMax {
+    minContainers: number;
+    maxContainers: number;
+    current?: number;
+    chosenCount?: number;
+}
+export interface IContainerData {
+    groupId: string;
+}
+export interface IStaticLootDetails {
+    itemcountDistribution: ItemCountDistribution[];
+    itemDistribution: ItemDistribution[];
+}
+export interface ItemCountDistribution {
+    count: number;
+    relativeProbability: number;
+}
+export interface ItemDistribution {
+    tpl: string;
+    relativeProbability: number;
+}
+export interface IStaticPropsBase {
+    Id: string;
+    IsContainer: boolean;
+    useGravity: boolean;
+    randomRotation: boolean;
+    Position: Ixyz;
+    Rotation: Ixyz;
+    IsGroupPosition: boolean;
+    IsAlwaysSpawn: boolean;
+    GroupPositions: any[];
+    Root: string;
+    Items: any[];
+}
+export interface IStaticWeaponProps extends IStaticPropsBase {
+    Items: Item[];
+}
+export interface IStaticContainerDetails {
+    staticWeapons: IStaticWeaponProps[];
+    staticContainers: IStaticContainerData[];
+    staticForced: IStaticForcedProps[];
+}
+export interface IStaticContainerData {
+    probability: number;
+    template: IStaticContainerProps;
+}
+export interface IStaticAmmoDetails {
+    tpl: string;
+    relativeProbability: number;
+}
+export interface IStaticForcedProps {
+    containerId: string;
+    itemTpl: string;
+}
+export interface IStaticContainerProps extends IStaticPropsBase {
+    Items: StaticItem[];
+}
+export interface StaticItem {
+    _id: string;
+    _tpl: string;
+}

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

@@ -0,0 +1,242 @@
+import { MinMax } from "@spt/models/common/MinMax";
+import { Ixyz } from "@spt/models/eft/common/Ixyz";
+export interface ILocationBase {
+    AccessKeys: string[];
+    AirdropParameters: AirdropParameter[];
+    Area: number;
+    AveragePlayTime: number;
+    AveragePlayerLevel: number;
+    Banners: Banner[];
+    BossLocationSpawn: BossLocationSpawn[];
+    BotAssault: number;
+    BotEasy: number;
+    BotHard: number;
+    BotImpossible: number;
+    BotLocationModifier: BotLocationModifier;
+    BotMarksman: number;
+    BotMax: number;
+    BotMaxPlayer: number;
+    BotMaxTimePlayer: number;
+    BotMaxPvE: number;
+    BotNormal: number;
+    BotSpawnCountStep: number;
+    BotSpawnPeriodCheck: number;
+    BotSpawnTimeOffMax: number;
+    BotSpawnTimeOffMin: number;
+    BotSpawnTimeOnMax: number;
+    BotSpawnTimeOnMin: number;
+    BotStart: number;
+    BotStop: number;
+    Description: string;
+    DisabledForScav: boolean;
+    DisabledScavExits: string;
+    Enabled: boolean;
+    EnableCoop: boolean;
+    GlobalLootChanceModifier: number;
+    GlobalLootChanceModifierPvE: number;
+    GlobalContainerChanceModifier: number;
+    IconX: number;
+    IconY: number;
+    Id: string;
+    Insurance: boolean;
+    IsSecret: boolean;
+    Locked: boolean;
+    Loot: any[];
+    MatchMakerMinPlayersByWaitTime: MinPlayerWaitTime[];
+    MaxBotPerZone: number;
+    MaxDistToFreePoint: number;
+    MaxPlayers: number;
+    MinDistToExitPoint: number;
+    MinDistToFreePoint: number;
+    MinMaxBots: MinMaxBot[];
+    MinPlayers: number;
+    MaxCoopGroup: number;
+    Name: string;
+    NonWaveGroupScenario: INonWaveGroupScenario;
+    NewSpawn: boolean;
+    OcculsionCullingEnabled: boolean;
+    OldSpawn: boolean;
+    OpenZones: string;
+    Preview: Preview;
+    PlayersRequestCount: number;
+    RequiredPlayerLevel?: number;
+    RequiredPlayerLevelMin?: number;
+    RequiredPlayerLevelMax?: number;
+    MinPlayerLvlAccessKeys: number;
+    PmcMaxPlayersInGroup: number;
+    ScavMaxPlayersInGroup: number;
+    Rules: string;
+    SafeLocation: boolean;
+    Scene: Scene;
+    SpawnPointParams: SpawnPointParam[];
+    UnixDateTime: number;
+    _Id: string;
+    doors: any[];
+    EscapeTimeLimit: number;
+    EscapeTimeLimitCoop: number;
+    EscapeTimeLimitPVE: number;
+    exit_access_time: number;
+    exit_count: number;
+    exit_time: number;
+    exits: Exit[];
+    filter_ex: string[];
+    limits: ILimit[];
+    matching_min_seconds: number;
+    GenerateLocalLootCache: boolean;
+    maxItemCountInLocation: MaxItemCountInLocation[];
+    sav_summon_seconds: number;
+    tmp_location_field_remove_me: number;
+    users_gather_seconds: number;
+    users_spawn_seconds_n: number;
+    users_spawn_seconds_n2: number;
+    users_summon_seconds: number;
+    waves: Wave[];
+}
+export interface INonWaveGroupScenario {
+    Chance: number;
+    Enabled: boolean;
+    MaxToBeGroup: number;
+    MinToBeGroup: number;
+}
+export interface ILimit extends MinMax {
+    items: any[];
+}
+export interface AirdropParameter {
+    AirdropPointDeactivateDistance: number;
+    MinPlayersCountToSpawnAirdrop: number;
+    PlaneAirdropChance: number;
+    PlaneAirdropCooldownMax: number;
+    PlaneAirdropCooldownMin: number;
+    PlaneAirdropEnd: number;
+    PlaneAirdropMax: number;
+    PlaneAirdropStartMax: number;
+    PlaneAirdropStartMin: number;
+    UnsuccessfulTryPenalty: number;
+}
+export interface Banner {
+    id: string;
+    pic: Pic;
+}
+export interface Pic {
+    path: string;
+    rcid: string;
+}
+export interface BossLocationSpawn {
+    BossChance: number;
+    BossDifficult: string;
+    BossEscortAmount: string;
+    BossEscortDifficult: string;
+    BossEscortType: string;
+    BossName: string;
+    BossPlayer: boolean;
+    BossZone: string;
+    RandomTimeSpawn: boolean;
+    Time: number;
+    TriggerId: string;
+    TriggerName: string;
+    Delay?: number;
+    ForceSpawn?: boolean;
+    IgnoreMaxBots?: boolean;
+    Supports?: BossSupport[];
+    sptId?: string;
+    spawnMode: string[];
+}
+export interface BossSupport {
+    BossEscortAmount: string;
+    BossEscortDifficult: string[];
+    BossEscortType: string;
+}
+export interface BotLocationModifier {
+    AccuracySpeed: number;
+    DistToActivate: number;
+    DistToPersueAxemanCoef: number;
+    DistToSleep: number;
+    GainSight: number;
+    KhorovodChance: number;
+    MagnetPower: number;
+    MarksmanAccuratyCoef: number;
+    Scattering: number;
+    VisibleDistance: number;
+}
+export interface MinMaxBot extends MinMax {
+    WildSpawnType: WildSpawnType | string;
+}
+export interface MinPlayerWaitTime {
+    minPlayers: number;
+    time: number;
+}
+export interface Preview {
+    path: string;
+    rcid: string;
+}
+export interface Scene {
+    path: string;
+    rcid: string;
+}
+export interface SpawnPointParam {
+    BotZoneName: string;
+    Categories: string[];
+    ColliderParams: ColliderParams;
+    CorePointId: number;
+    DelayToCanSpawnSec: number;
+    Id: string;
+    Infiltration: string;
+    Position: Ixyz;
+    Rotation: number;
+    Sides: string[];
+}
+export interface ColliderParams {
+    _parent: string;
+    _props: Props;
+}
+export interface Props {
+    Center: Ixyz;
+    Radius: number;
+}
+export interface Exit {
+    /** % Chance out of 100 exit will appear in raid */
+    Chance: number;
+    ChancePVE: number;
+    Count: number;
+    CountPVE: number;
+    EntryPoints: string;
+    EventAvailable: boolean;
+    ExfiltrationTime: number;
+    ExfiltrationTimePVE: number;
+    ExfiltrationType: string;
+    RequiredSlot?: string;
+    Id: string;
+    MaxTime: number;
+    MaxTimePVE: number;
+    MinTime: number;
+    MinTimePVE: number;
+    Name: string;
+    PassageRequirement: string;
+    PlayersCount: number;
+    PlayersCountPVE: number;
+    RequirementTip: string;
+    Side?: string;
+}
+export interface MaxItemCountInLocation {
+    TemplateId: string;
+    Value: number;
+}
+export interface Wave {
+    BotPreset: string;
+    BotSide: string;
+    SpawnPoints: string;
+    WildSpawnType: WildSpawnType;
+    isPlayers: boolean;
+    number: number;
+    slots_max: number;
+    slots_min: number;
+    time_max: number;
+    time_min: number;
+    sptId?: string;
+    ChanceGroup?: number;
+}
+export declare enum WildSpawnType {
+    ASSAULT = "assault",
+    MARKSMAN = "marksman",
+    PMCBOT = "pmcbot"
+}

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

@@ -0,0 +1,9 @@
+import { ILocations } from "@spt/models/spt/server/ILocations";
+export interface ILocationsGenerateAllResponse {
+    locations: ILocations;
+    paths: Path[];
+}
+export interface Path {
+    Source: string;
+    Destination: string;
+}

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

@@ -0,0 +1,42 @@
+import { Ixyz } from "@spt/models/eft/common/Ixyz";
+import { Item } from "@spt/models/eft/common/tables/IItem";
+export interface ILooseLoot {
+    spawnpointCount: SpawnpointCount;
+    spawnpointsForced: SpawnpointsForced[];
+    spawnpoints: Spawnpoint[];
+}
+export interface SpawnpointCount {
+    mean: number;
+    std: number;
+}
+export interface SpawnpointsForced {
+    locationId: string;
+    probability: number;
+    template: SpawnpointTemplate;
+}
+export interface SpawnpointTemplate {
+    Id: string;
+    IsContainer: boolean;
+    useGravity: boolean;
+    randomRotation: boolean;
+    Position: Ixyz;
+    Rotation: Ixyz;
+    IsAlwaysSpawn: boolean;
+    IsGroupPosition: boolean;
+    GroupPositions: any[];
+    Root: string;
+    Items: Item[];
+}
+export interface Spawnpoint {
+    locationId: string;
+    probability: number;
+    template: SpawnpointTemplate;
+    itemDistribution: ItemDistribution[];
+}
+export interface ItemDistribution {
+    composedKey: ComposedKey;
+    relativeProbability: number;
+}
+export interface ComposedKey {
+    key: string;
+}

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

@@ -0,0 +1,7 @@
+export interface IMetricsTableData {
+    Keys: number[];
+    NetProcessingBins: number[];
+    RenderBins: number[];
+    GameUpdateBins: number[];
+    MemoryMeasureInterval: number;
+}

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

@@ -0,0 +1,11 @@
+import { IBotBase, IEftStats } from "@spt/models/eft/common/tables/IBotBase";
+export interface IPmcData extends IBotBase {
+}
+export interface IPostRaidPmcData extends IBotBase {
+    Stats: IPostRaidStats;
+}
+export interface IPostRaidStats {
+    Eft: IEftStats;
+    /** Only found in profile we get from client post raid */
+    Arena: IEftStats;
+}

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

@@ -0,0 +1,5 @@
+export interface Ixyz {
+    x: number;
+    y: number;
+    z: number;
+}

types/models/eft/common/request/IBaseInteractionRequestData.d.ts

@@ -0,0 +1,9 @@
+export interface IBaseInteractionRequestData {
+    Action: string;
+    fromOwner?: OwnerInfo;
+    toOwner?: OwnerInfo;
+}
+export interface OwnerInfo {
+    id: string;
+    type: string;
+}

types/models/eft/common/request/IUIDRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IUIDRequestData {
+    uid: string;
+}

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

@@ -0,0 +1,18 @@
+import { IQuestConditionTypes, IQuestRewards } from "@spt/models/eft/common/tables/IQuest";
+export interface IAchievement {
+    id: string;
+    imageUrl: string;
+    assetPath: string;
+    rewards: IQuestRewards;
+    conditions: IQuestConditionTypes;
+    instantComplete: boolean;
+    showNotificationsInGame: boolean;
+    showProgress: boolean;
+    prefab: string;
+    rarity: string;
+    hidden: boolean;
+    showConditions: boolean;
+    progressBarEnabled: boolean;
+    side: string;
+    index: number;
+}

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

@@ -0,0 +1,422 @@
+import { Item, Upd } from "@spt/models/eft/common/tables/IItem";
+import { IPmcDataRepeatableQuest } from "@spt/models/eft/common/tables/IRepeatableQuests";
+import { IRagfairOffer } from "@spt/models/eft/ragfair/IRagfairOffer";
+import { BonusSkillType } from "@spt/models/enums/BonusSkillType";
+import { BonusType } from "@spt/models/enums/BonusType";
+import { HideoutAreas } from "@spt/models/enums/HideoutAreas";
+import { MemberCategory } from "@spt/models/enums/MemberCategory";
+import { QuestStatus } from "@spt/models/enums/QuestStatus";
+export interface IBotBase {
+    _id: string;
+    aid: number;
+    /** SPT property - use to store player id - TODO - move to AID ( account id as guid of choice) */
+    sessionId: string;
+    savage?: string;
+    Info: Info;
+    Customization: Customization;
+    Health: Health;
+    Inventory: Inventory;
+    Skills: Skills;
+    Stats: Stats;
+    Encyclopedia: Record<string, boolean>;
+    TaskConditionCounters: Record<string, ITaskConditionCounter>;
+    InsuredItems: InsuredItem[];
+    Hideout: Hideout;
+    Quests: IQuestStatus[];
+    TradersInfo: Record<string, TraderInfo>;
+    UnlockedInfo: IUnlockedInfo;
+    RagfairInfo: RagfairInfo;
+    /** Achievement id and timestamp */
+    Achievements: Record<string, number>;
+    RepeatableQuests: IPmcDataRepeatableQuest[];
+    Bonuses: Bonus[];
+    Notes: Notes;
+    CarExtractCounts: Record<string, number>;
+    CoopExtractCounts: Record<string, number>;
+    SurvivorClass: SurvivorClass;
+    WishList: string[];
+    moneyTransferLimitData: IMoneyTransferLimits;
+    /** SPT specific property used during bot generation in raid */
+    sptIsPmc?: boolean;
+}
+export interface IMoneyTransferLimits {
+    /** TODO: Implement */
+    nextResetTime: number;
+    remainingLimit: number;
+    totalLimit: number;
+    resetInterval: number;
+}
+export interface ITaskConditionCounter {
+    id: string;
+    type: string;
+    value: number;
+    /** Quest id */
+    sourceId: string;
+}
+export interface IUnlockedInfo {
+    unlockedProductionRecipe: string[];
+}
+export interface Info {
+    EntryPoint: string;
+    Nickname: string;
+    LowerNickname: string;
+    Side: string;
+    SquadInviteRestriction: boolean;
+    HasCoopExtension: boolean;
+    Voice: string;
+    Level: number;
+    Experience: number;
+    RegistrationDate: number;
+    GameVersion: string;
+    AccountType: number;
+    MemberCategory: MemberCategory;
+    lockedMoveCommands: boolean;
+    SavageLockTime: number;
+    LastTimePlayedAsSavage: number;
+    Settings: Settings;
+    NicknameChangeDate: number;
+    NeedWipeOptions: any[];
+    lastCompletedWipe: LastCompleted;
+    Bans: IBan[];
+    BannedState: boolean;
+    BannedUntil: number;
+    IsStreamerModeAvailable: boolean;
+    lastCompletedEvent?: LastCompleted;
+    SelectedMemberCategory: number;
+    isMigratedSkills: boolean;
+}
+export interface Settings {
+    Role: string;
+    BotDifficulty: string;
+    Experience: number;
+    StandingForKill: number;
+    AggressorBonus: number;
+}
+export interface IBan {
+    banType: BanType;
+    dateTime: number;
+}
+export declare enum BanType {
+    CHAT = 0,
+    RAGFAIR = 1,
+    VOIP = 2,
+    TRADING = 3,
+    ONLINE = 4,
+    FRIENDS = 5,
+    CHANGE_NICKNAME = 6
+}
+export interface Customization {
+    Head: string;
+    Body: string;
+    Feet: string;
+    Hands: string;
+}
+export interface Health {
+    Hydration: CurrentMax;
+    Energy: CurrentMax;
+    Temperature: CurrentMax;
+    BodyParts: BodyPartsHealth;
+    UpdateTime: number;
+    Immortal?: boolean;
+}
+export interface BodyPartsHealth {
+    Head: BodyPartHealth;
+    Chest: BodyPartHealth;
+    Stomach: BodyPartHealth;
+    LeftArm: BodyPartHealth;
+    RightArm: BodyPartHealth;
+    LeftLeg: BodyPartHealth;
+    RightLeg: BodyPartHealth;
+}
+export interface BodyPartHealth {
+    Health: CurrentMax;
+    Effects?: Record<string, BodyPartEffectProperties>;
+}
+export interface BodyPartEffectProperties {
+    Time: number;
+}
+export interface CurrentMax {
+    Current: number;
+    Maximum: number;
+}
+export interface Inventory {
+    items: Item[];
+    equipment: string;
+    stash: string;
+    sortingTable: string;
+    questRaidItems: string;
+    questStashItems: string;
+    /** Key is hideout area enum numeric as string e.g. "24", value is area _id  */
+    hideoutAreaStashes: Record<string, string>;
+    fastPanel: Record<string, string>;
+    favoriteItems: string[];
+}
+export interface IBaseJsonSkills {
+    Common: Record<string, Common>;
+    Mastering: Record<string, Mastering>;
+    Points: number;
+}
+export interface Skills {
+    Common: Common[];
+    Mastering: Mastering[];
+    Points: number;
+}
+export interface IBaseSkill {
+    Id: string;
+    Progress: number;
+    max?: number;
+    min?: number;
+}
+export interface Common extends IBaseSkill {
+    PointsEarnedDuringSession?: number;
+    LastAccess?: number;
+}
+export interface Mastering extends IBaseSkill {
+}
+export interface Stats {
+    Eft?: IEftStats;
+}
+export interface IEftStats {
+    CarriedQuestItems: string[];
+    Victims: Victim[];
+    TotalSessionExperience: number;
+    LastSessionDate: number;
+    SessionCounters: SessionCounters;
+    OverallCounters: OverallCounters;
+    SessionExperienceMult?: number;
+    ExperienceBonusMult?: number;
+    Aggressor?: Aggressor;
+    DroppedItems?: IDroppedItem[];
+    FoundInRaidItems?: FoundInRaidItem[];
+    DamageHistory?: DamageHistory;
+    DeathCause?: DeathCause;
+    LastPlayerState?: LastPlayerState;
+    TotalInGameTime: number;
+    SurvivorClass?: string;
+    sptLastRaidFenceRepChange?: number;
+}
+export interface IDroppedItem {
+    QuestId: string;
+    ItemId: string;
+    ZoneId: string;
+}
+export interface FoundInRaidItem {
+    QuestId: string;
+    ItemId: string;
+}
+export interface Victim {
+    AccountId: string;
+    ProfileId: string;
+    Name: string;
+    Side: string;
+    BodyPart: string;
+    Time: string;
+    Distance: number;
+    Level: number;
+    Weapon: string;
+    Role: string;
+}
+export interface SessionCounters {
+    Items: CounterKeyValue[];
+}
+export interface OverallCounters {
+    Items: CounterKeyValue[];
+}
+export interface CounterKeyValue {
+    Key: string[];
+    Value: number;
+}
+export interface Aggressor {
+    AccountId: string;
+    ProfileId: string;
+    MainProfileNickname: string;
+    Name: string;
+    Side: string;
+    BodyPart: string;
+    HeadSegment: string;
+    WeaponName: string;
+    Category: string;
+}
+export interface DamageHistory {
+    LethalDamagePart: string;
+    LethalDamage: LethalDamage;
+    BodyParts: BodyPartsDamageHistory;
+}
+export interface LethalDamage {
+    Amount: number;
+    Type: string;
+    SourceId: string;
+    OverDamageFrom: string;
+    Blunt: boolean;
+    ImpactsCount: number;
+}
+export interface BodyPartsDamageHistory {
+    Head: DamageStats[];
+    Chest: DamageStats[];
+    Stomach: DamageStats[];
+    LeftArm: DamageStats[];
+    RightArm: DamageStats[];
+    LeftLeg: DamageStats[];
+    RightLeg: DamageStats[];
+    Common: DamageStats[];
+}
+export interface DamageStats {
+    Amount: number;
+    Type: string;
+    SourceId: string;
+    OverDamageFrom: string;
+    Blunt: boolean;
+    ImpactsCount: number;
+}
+export interface DeathCause {
+    DamageType: string;
+    Side: string;
+    Role: string;
+    WeaponId: string;
+}
+export interface LastPlayerState {
+    Info: LastPlayerStateInfo;
+    Customization: Record<string, string>;
+    Equipment: any;
+}
+export interface LastPlayerStateInfo {
+    Nickname: string;
+    Side: string;
+    Level: number;
+    MemberCategory: MemberCategory;
+}
+export interface BackendCounter {
+    id: string;
+    qid?: string;
+    value: number;
+}
+export interface InsuredItem {
+    /** Trader Id item was insured by */
+    tid: string;
+    itemId: string;
+}
+export interface Hideout {
+    Production: Record<string, Productive>;
+    Areas: HideoutArea[];
+    Improvement: Record<string, IHideoutImprovement>;
+    Seed: number;
+    sptUpdateLastRunTimestamp: number;
+}
+export interface IHideoutImprovement {
+    completed: boolean;
+    improveCompleteTimestamp: number;
+}
+export interface Productive {
+    Products: Product[];
+    /** Seconds passed of production */
+    Progress?: number;
+    /** Is craft in some state of being worked on by client (crafting/ready to pick up) */
+    inProgress?: boolean;
+    StartTimestamp?: number;
+    SkipTime?: number;
+    /** Seconds needed to fully craft */
+    ProductionTime?: number;
+    GivenItemsInStart?: string[];
+    Interrupted?: boolean;
+    Code?: string;
+    Decoded?: boolean;
+    AvailableForFinish?: boolean;
+    /** Used in hideout production.json */
+    needFuelForAllProductionTime?: boolean;
+    /** Used when sending data to client */
+    NeedFuelForAllProductionTime?: boolean;
+    sptIsScavCase?: boolean;
+    /** Some crafts are always inProgress, but need to be reset, e.g. water collector */
+    sptIsComplete?: boolean;
+    /** Is the craft a Continuous, e.g bitcoins/water collector */
+    sptIsContinuous?: boolean;
+    /** Stores a list of tools used in this craft and whether they're FiR, to give back once the craft is done */
+    sptRequiredTools?: Item[];
+}
+export interface Production extends Productive {
+    RecipeId: string;
+    SkipTime: number;
+    ProductionTime: number;
+}
+export interface ScavCase extends Productive {
+    RecipeId: string;
+}
+export interface Product {
+    _id: string;
+    _tpl: string;
+    upd?: Upd;
+}
+export interface HideoutArea {
+    type: HideoutAreas;
+    level: number;
+    active: boolean;
+    passiveBonusesEnabled: boolean;
+    /** Must be integer */
+    completeTime: number;
+    constructing: boolean;
+    slots: HideoutSlot[];
+    lastRecipe: string;
+}
+export interface HideoutSlot {
+    /** SPT specific value to keep track of what index this slot is (0,1,2,3 etc) */
+    locationIndex: number;
+    item?: HideoutItem[];
+}
+export interface HideoutItem {
+    _id: string;
+    _tpl: string;
+    upd?: Upd;
+}
+export interface LastCompleted {
+    $oid: string;
+}
+export interface Notes {
+    Notes: Note[];
+}
+export interface CarExtractCounts {
+}
+export declare enum SurvivorClass {
+    UNKNOWN = 0,
+    NEUTRALIZER = 1,
+    MARAUDER = 2,
+    PARAMEDIC = 3,
+    SURVIVOR = 4
+}
+export interface IQuestStatus {
+    qid: string;
+    startTime: number;
+    status: QuestStatus;
+    statusTimers?: Record<string, number>;
+    /** Property does not exist in live profile data, but is used by ProfileChanges.questsStatus when sent to client */
+    completedConditions?: string[];
+    availableAfter?: number;
+}
+export interface TraderInfo {
+    loyaltyLevel: number;
+    salesSum: number;
+    standing: number;
+    nextResupply: number;
+    unlocked: boolean;
+    disabled: boolean;
+}
+export interface RagfairInfo {
+    rating: number;
+    isRatingGrowing: boolean;
+    offers: IRagfairOffer[];
+}
+export interface Bonus {
+    id?: string;
+    type: BonusType;
+    templateId?: string;
+    passive?: boolean;
+    production?: boolean;
+    visible?: boolean;
+    value?: number;
+    icon?: string;
+    filter?: string[];
+    skillType?: BonusSkillType;
+}
+export interface Note {
+    Time: number;
+    Text: string;
+}

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

@@ -0,0 +1,133 @@
+export interface IBotCore {
+    SAVAGE_KILL_DIST: number;
+    SOUND_DOOR_BREACH_METERS: number;
+    SOUND_DOOR_OPEN_METERS: number;
+    STEP_NOISE_DELTA: number;
+    JUMP_NOISE_DELTA: number;
+    GUNSHOT_SPREAD: number;
+    GUNSHOT_SPREAD_SILENCE: number;
+    BASE_WALK_SPEREAD2: number;
+    MOVE_SPEED_COEF_MAX: number;
+    SPEED_SERV_SOUND_COEF_A: number;
+    SPEED_SERV_SOUND_COEF_B: number;
+    G: number;
+    STAY_COEF: number;
+    SIT_COEF: number;
+    LAY_COEF: number;
+    MAX_ITERATIONS: number;
+    START_DIST_TO_COV: number;
+    MAX_DIST_TO_COV: number;
+    STAY_HEIGHT: number;
+    CLOSE_POINTS: number;
+    COUNT_TURNS: number;
+    SIMPLE_POINT_LIFE_TIME_SEC: number;
+    DANGER_POINT_LIFE_TIME_SEC: number;
+    DANGER_POWER: number;
+    COVER_DIST_CLOSE: number;
+    GOOD_DIST_TO_POINT: number;
+    COVER_TOOFAR_FROM_BOSS: number;
+    COVER_TOOFAR_FROM_BOSS_SQRT: number;
+    MAX_Y_DIFF_TO_PROTECT: number;
+    FLARE_POWER: number;
+    MOVE_COEF: number;
+    PRONE_POSE: number;
+    LOWER_POSE: number;
+    MAX_POSE: number;
+    FLARE_TIME: number;
+    MAX_REQUESTS__PER_GROUP: number;
+    UPDATE_GOAL_TIMER_SEC: number;
+    DIST_NOT_TO_GROUP: number;
+    DIST_NOT_TO_GROUP_SQR: number;
+    LAST_SEEN_POS_LIFETIME: number;
+    DELTA_GRENADE_START_TIME: number;
+    DELTA_GRENADE_END_TIME: number;
+    DELTA_GRENADE_RUN_DIST: number;
+    DELTA_GRENADE_RUN_DIST_SQRT: number;
+    PATROL_MIN_LIGHT_DIST: number;
+    HOLD_MIN_LIGHT_DIST: number;
+    STANDART_BOT_PAUSE_DOOR: number;
+    ARMOR_CLASS_COEF: number;
+    SHOTGUN_POWER: number;
+    RIFLE_POWER: number;
+    PISTOL_POWER: number;
+    SMG_POWER: number;
+    SNIPE_POWER: number;
+    GESTUS_PERIOD_SEC: number;
+    GESTUS_AIMING_DELAY: number;
+    GESTUS_REQUEST_LIFETIME: number;
+    GESTUS_FIRST_STAGE_MAX_TIME: number;
+    GESTUS_SECOND_STAGE_MAX_TIME: number;
+    GESTUS_MAX_ANSWERS: number;
+    GESTUS_FUCK_TO_SHOOT: number;
+    GESTUS_DIST_ANSWERS: number;
+    GESTUS_DIST_ANSWERS_SQRT: number;
+    GESTUS_ANYWAY_CHANCE: number;
+    TALK_DELAY: number;
+    CAN_SHOOT_TO_HEAD: boolean;
+    CAN_TILT: boolean;
+    TILT_CHANCE: number;
+    MIN_BLOCK_DIST: number;
+    MIN_BLOCK_TIME: number;
+    COVER_SECONDS_AFTER_LOSE_VISION: number;
+    MIN_ARG_COEF: number;
+    MAX_ARG_COEF: number;
+    DEAD_AGR_DIST: number;
+    MAX_DANGER_CARE_DIST_SQRT: number;
+    MAX_DANGER_CARE_DIST: number;
+    MIN_MAX_PERSON_SEARCH: number;
+    PERCENT_PERSON_SEARCH: number;
+    LOOK_ANYSIDE_BY_WALL_SEC_OF_ENEMY: number;
+    CLOSE_TO_WALL_ROTATE_BY_WALL_SQRT: number;
+    SHOOT_TO_CHANGE_RND_PART_MIN: number;
+    SHOOT_TO_CHANGE_RND_PART_MAX: number;
+    SHOOT_TO_CHANGE_RND_PART_DELTA: number;
+    FORMUL_COEF_DELTA_DIST: number;
+    FORMUL_COEF_DELTA_SHOOT: number;
+    FORMUL_COEF_DELTA_FRIEND_COVER: number;
+    SUSPETION_POINT_DIST_CHECK: number;
+    MAX_BASE_REQUESTS_PER_PLAYER: number;
+    MAX_HOLD_REQUESTS_PER_PLAYER: number;
+    MAX_GO_TO_REQUESTS_PER_PLAYER: number;
+    MAX_COME_WITH_ME_REQUESTS_PER_PLAYER: number;
+    CORE_POINT_MAX_VALUE: number;
+    CORE_POINTS_MAX: number;
+    CORE_POINTS_MIN: number;
+    BORN_POISTS_FREE_ONLY_FAREST_BOT: boolean;
+    BORN_POINSTS_FREE_ONLY_FAREST_PLAYER: boolean;
+    SCAV_GROUPS_TOGETHER: boolean;
+    LAY_DOWN_ANG_SHOOT: number;
+    HOLD_REQUEST_TIME_SEC: number;
+    TRIGGERS_DOWN_TO_RUN_WHEN_MOVE: number;
+    MIN_DIST_TO_RUN_WHILE_ATTACK_MOVING: number;
+    MIN_DIST_TO_RUN_WHILE_ATTACK_MOVING_OTHER_ENEMIS: number;
+    MIN_DIST_TO_STOP_RUN: number;
+    JUMP_SPREAD_DIST: number;
+    LOOK_TIMES_TO_KILL: number;
+    COME_INSIDE_TIMES: number;
+    TOTAL_TIME_KILL: number;
+    TOTAL_TIME_KILL_AFTER_WARN: number;
+    MOVING_AIM_COEF: number;
+    VERTICAL_DIST_TO_IGNORE_SOUND: number;
+    DEFENCE_LEVEL_SHIFT: number;
+    MIN_DIST_CLOSE_DEF: number;
+    USE_ID_PRIOR_WHO_GO: boolean;
+    SMOKE_GRENADE_RADIUS_COEF: number;
+    GRENADE_PRECISION: number;
+    MAX_WARNS_BEFORE_KILL: number;
+    CARE_ENEMY_ONLY_TIME: number;
+    MIDDLE_POINT_COEF: number;
+    MAIN_TACTIC_ONLY_ATTACK: boolean;
+    LAST_DAMAGE_ACTIVE: number;
+    SHALL_DIE_IF_NOT_INITED: boolean;
+    CHECK_BOT_INIT_TIME_SEC: number;
+    WEAPON_ROOT_Y_OFFSET: number;
+    DELTA_SUPRESS_DISTANCE_SQRT: number;
+    DELTA_SUPRESS_DISTANCE: number;
+    WAVE_COEF_LOW: number;
+    WAVE_COEF_MID: number;
+    WAVE_COEF_HIGH: number;
+    WAVE_COEF_HORDE: number;
+    WAVE_ONLY_AS_ONLINE: boolean;
+    LOCAL_BOTS_COUNT: number;
+    AXE_MAN_KILLS_END: number;
+}

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

@@ -0,0 +1,172 @@
+import { MinMax } from "@spt/models/common/MinMax";
+import { Skills } from "@spt/models/eft/common/tables/IBotBase";
+export interface IBotType {
+    appearance: Appearance;
+    chances: Chances;
+    difficulty: Difficulties;
+    experience: Experience;
+    firstName: string[];
+    generation: Generation;
+    health: Health;
+    inventory: Inventory;
+    lastName: string[];
+    skills: Skills;
+}
+export interface Appearance {
+    body: Record<string, number>;
+    feet: Record<string, number>;
+    hands: Record<string, number>;
+    head: Record<string, number>;
+    voice: Record<string, number>;
+}
+export interface Chances {
+    equipment: EquipmentChances;
+    weaponMods: ModsChances;
+    equipmentMods: ModsChances;
+}
+export interface EquipmentChances {
+    ArmBand: number;
+    ArmorVest: number;
+    Backpack: number;
+    Earpiece: number;
+    Eyewear: number;
+    FaceCover: number;
+    FirstPrimaryWeapon: number;
+    Headwear: number;
+    Holster: number;
+    Pockets: number;
+    Scabbard: number;
+    SecondPrimaryWeapon: number;
+    SecuredContainer: number;
+    TacticalVest: number;
+}
+export interface ModsChances {
+    mod_charge: number;
+    mod_equipment: number;
+    mod_equipment_000: number;
+    mod_equipment_001: number;
+    mod_equipment_002: number;
+    mod_flashlight: number;
+    mod_foregrip: number;
+    mod_launcher: number;
+    mod_magazine: number;
+    mod_mount: number;
+    mod_mount_000: number;
+    mod_mount_001: number;
+    mod_muzzle: number;
+    mod_nvg: number;
+    mod_pistol_grip: number;
+    mod_reciever: number;
+    mod_scope: number;
+    mod_scope_000: number;
+    mod_scope_001: number;
+    mod_scope_002: number;
+    mod_scope_003: number;
+    mod_sight_front: number;
+    mod_sight_rear: number;
+    mod_stock: number;
+    mod_stock_000: number;
+    mod_stock_akms: number;
+    mod_tactical: number;
+    mod_tactical_000: number;
+    mod_tactical_001: number;
+    mod_tactical_002: number;
+    mod_tactical_003: number;
+    mod_handguard: number;
+}
+export interface Difficulties {
+    easy: Difficulty;
+    normal: Difficulty;
+    hard: Difficulty;
+    impossible: Difficulty;
+}
+export interface Difficulty {
+    Aiming: Record<string, string | number | boolean>;
+    Boss: Record<string, string | number | boolean>;
+    Change: Record<string, string | number | boolean>;
+    Core: Record<string, string | number | boolean>;
+    Cover: Record<string, string | number | boolean>;
+    Grenade: Record<string, string | number | boolean>;
+    Hearing: Record<string, string | number | boolean>;
+    Lay: Record<string, string | number | boolean>;
+    Look: Record<string, string | number | boolean>;
+    Mind: Record<string, string | number | boolean | string[]>;
+    Move: Record<string, string | number | boolean>;
+    Patrol: Record<string, string | number | boolean>;
+    Scattering: Record<string, string | number | boolean>;
+    Shoot: Record<string, string | number | boolean>;
+}
+export interface Experience {
+    aggressorBonus: number;
+    level: MinMax;
+    reward: MinMax;
+    standingForKill: number;
+}
+export interface Generation {
+    items: GenerationWeightingItems;
+}
+export interface GenerationWeightingItems {
+    grenades: GenerationData;
+    healing: GenerationData;
+    drugs: GenerationData;
+    food: GenerationData;
+    drink: GenerationData;
+    currency: GenerationData;
+    stims: GenerationData;
+    backpackLoot: GenerationData;
+    pocketLoot: GenerationData;
+    vestLoot: GenerationData;
+    magazines: GenerationData;
+    specialItems: GenerationData;
+}
+export interface GenerationData {
+    /** key: number of items, value: weighting */
+    weights: Record<string, number>;
+    /** Array of item tpls */
+    whitelist: Record<string, number>;
+}
+export interface Health {
+    BodyParts: BodyPart[];
+    Energy: MinMax;
+    Hydration: MinMax;
+    Temperature: MinMax;
+}
+export interface BodyPart {
+    Chest: MinMax;
+    Head: MinMax;
+    LeftArm: MinMax;
+    LeftLeg: MinMax;
+    RightArm: MinMax;
+    RightLeg: MinMax;
+    Stomach: MinMax;
+}
+export interface Inventory {
+    equipment: Equipment;
+    Ammo: Record<string, Record<string, number>>;
+    items: Items;
+    mods: Mods;
+}
+export interface Equipment {
+    ArmBand: Record<string, number>;
+    ArmorVest: Record<string, number>;
+    Backpack: Record<string, number>;
+    Earpiece: Record<string, number>;
+    Eyewear: Record<string, number>;
+    FaceCover: Record<string, number>;
+    FirstPrimaryWeapon: Record<string, number>;
+    Headwear: Record<string, number>;
+    Holster: Record<string, number>;
+    Pockets: Record<string, number>;
+    Scabbard: Record<string, number>;
+    SecondPrimaryWeapon: Record<string, number>;
+    SecuredContainer: Record<string, number>;
+    TacticalVest: Record<string, number>;
+}
+export interface Items {
+    Backpack: Record<string, number>;
+    Pockets: Record<string, number>;
+    SecuredContainer: Record<string, number>;
+    SpecialLoot: Record<string, number>;
+    TacticalVest: Record<string, number>;
+}
+export type Mods = Record<string, Record<string, string[]>>;

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

@@ -0,0 +1,29 @@
+import { Ixyz } from "@spt/models/eft/common/Ixyz";
+export interface ICustomizationItem {
+    _id: string;
+    _name: string;
+    _parent: string;
+    _type: string;
+    _props: Props;
+    _proto: string;
+}
+export interface Props {
+    Name: string;
+    ShortName: string;
+    Description: string;
+    Side: string[];
+    BodyPart: string;
+    AvailableAsDefault?: boolean;
+    Body: string;
+    Hands: string;
+    Feet: string;
+    Prefab: Prefab;
+    WatchPrefab: Prefab;
+    IntegratedArmorVest: boolean;
+    WatchPosition: Ixyz;
+    WatchRotation: Ixyz;
+}
+export interface Prefab {
+    path: string;
+    rcid: string;
+}

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

@@ -0,0 +1,16 @@
+export interface IHandbookBase {
+    Categories: Category[];
+    Items: HandbookItem[];
+}
+export interface Category {
+    Id: string;
+    ParentId?: string;
+    Icon: string;
+    Color: string;
+    Order: string;
+}
+export interface HandbookItem {
+    Id: string;
+    ParentId: string;
+    Price: number;
+}

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

@@ -0,0 +1,125 @@
+export interface Item {
+    _id: string;
+    _tpl: string;
+    parentId?: string;
+    slotId?: string;
+    location?: Location | number;
+    upd?: Upd;
+}
+export interface Upd {
+    Buff?: Buff;
+    OriginalStackObjectsCount?: number;
+    Togglable?: Togglable;
+    Map?: Map;
+    Tag?: Tag;
+    /** SPT specific property, not made by BSG */
+    sptPresetId?: string;
+    FaceShield?: FaceShield;
+    StackObjectsCount?: number;
+    UnlimitedCount?: boolean;
+    Repairable?: Repairable;
+    RecodableComponent?: RecodableComponent;
+    FireMode?: FireMode;
+    SpawnedInSession?: boolean;
+    Light?: Light;
+    Key?: Key;
+    Resource?: Resource;
+    Sight?: Sight;
+    MedKit?: MedKit;
+    FoodDrink?: FoodDrink;
+    Dogtag?: Dogtag;
+    BuyRestrictionMax?: number;
+    BuyRestrictionCurrent?: number;
+    Foldable?: Foldable;
+    SideEffect?: SideEffect;
+    RepairKit?: RepairKit;
+    CultistAmulet?: ICultistAmulet;
+}
+export interface Buff {
+    rarity: string;
+    buffType: string;
+    value: number;
+    thresholdDurability?: number;
+}
+export interface Togglable {
+    On: boolean;
+}
+export interface Map {
+    Markers: MapMarker[];
+}
+export interface MapMarker {
+    X: number;
+    Y: number;
+}
+export interface Tag {
+    Color: number;
+    Name: string;
+}
+export interface FaceShield {
+    Hits: number;
+}
+export interface Repairable {
+    Durability: number;
+    MaxDurability: number;
+}
+export interface RecodableComponent {
+    IsEncoded: boolean;
+}
+export interface MedKit {
+    HpResource: number;
+}
+export interface Sight {
+    ScopesCurrentCalibPointIndexes: number[];
+    ScopesSelectedModes: number[];
+    SelectedScope: number;
+}
+export interface Foldable {
+    Folded: boolean;
+}
+export interface FireMode {
+    FireMode: string;
+}
+export interface FoodDrink {
+    HpPercent: number;
+}
+export interface Key {
+    NumberOfUsages: number;
+}
+export interface Resource {
+    Value: number;
+    UnitsConsumed: number;
+}
+export interface Light {
+    IsActive: boolean;
+    SelectedMode: number;
+}
+export interface Dogtag {
+    AccountId: string;
+    ProfileId: string;
+    Nickname: string;
+    Side: string;
+    Level: number;
+    Time: string;
+    Status: string;
+    KillerAccountId: string;
+    KillerProfileId: string;
+    KillerName: string;
+    WeaponName: string;
+}
+export interface Location {
+    x: number;
+    y: number;
+    r: string | number;
+    isSearched?: boolean;
+    /** SPT property? */
+    rotation?: string | boolean;
+}
+export interface SideEffect {
+    Value: number;
+}
+export interface RepairKit {
+    Resource: number;
+}
+export interface ICultistAmulet {
+    NumberOfUsages: number;
+}

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

@@ -0,0 +1,10 @@
+export interface ILocationsBase {
+    locations: Locations;
+    paths: Path[];
+}
+export interface Locations {
+}
+export interface Path {
+    Source: string;
+    Destination: string;
+}

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

@@ -0,0 +1,11 @@
+export interface IMatch {
+    metrics: Metrics;
+}
+export interface Metrics {
+    Keys: number[];
+    NetProcessingBins: number[];
+    RenderBins: number[];
+    GameUpdateBins: number[];
+    MemoryMeasureInterval: number;
+    PauseReasons: number[];
+}

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

@@ -0,0 +1,39 @@
+import { IPmcData } from "@spt/models/eft/common/IPmcData";
+import { Dialogue, IUserBuilds } from "@spt/models/eft/profile/ISptProfile";
+export interface IProfileTemplates {
+    "Standard": IProfileSides;
+    "Left Behind": IProfileSides;
+    "Prepare To Escape": IProfileSides;
+    "Edge Of Darkness": IProfileSides;
+    "Unheard": IProfileSides;
+    "Tournament": IProfileSides;
+    "SPT Developer": IProfileSides;
+    "SPT Easy start": IProfileSides;
+    "SPT Zero to hero": IProfileSides;
+}
+export interface IProfileSides {
+    descriptionLocaleKey: string;
+    usec: ITemplateSide;
+    bear: ITemplateSide;
+}
+export interface ITemplateSide {
+    character: IPmcData;
+    suits: string[];
+    dialogues: Record<string, Dialogue>;
+    userbuilds: IUserBuilds;
+    trader: ProfileTraderTemplate;
+}
+export interface ProfileTraderTemplate {
+    initialLoyaltyLevel: Record<string, number>;
+    initialStanding: Record<string, number>;
+    setQuestsAvailableForStart?: boolean;
+    setQuestsAvailableForFinish?: boolean;
+    initialSalesSum: number;
+    jaegerUnlocked: boolean;
+    /** How many days is usage of the flea blocked for upon profile creation */
+    fleaBlockedDays?: number;
+    /** What traders default to being locked on profile creation */
+    lockedByDefaultOverride?: string[];
+    /** What traders should have their clothing unlocked/purchased on creation */
+    purchaseAllClothingByDefaultForTrader?: string[];
+}

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

@@ -0,0 +1,152 @@
+import { Item } from "@spt/models/eft/common/tables/IItem";
+import { QuestRewardType } from "@spt/models/enums/QuestRewardType";
+import { QuestStatus } from "@spt/models/enums/QuestStatus";
+import { QuestTypeEnum } from "@spt/models/enums/QuestTypeEnum";
+export interface IQuest {
+    /** SPT addition - human readable quest name */
+    QuestName?: string;
+    _id: string;
+    canShowNotificationsInGame: boolean;
+    conditions: IQuestConditionTypes;
+    description: string;
+    failMessageText: string;
+    name: string;
+    note: string;
+    traderId: string;
+    location: string;
+    image: string;
+    type: QuestTypeEnum;
+    isKey: boolean;
+    /** @deprecated - Likely not used, use 'status' instead */
+    questStatus: QuestStatus;
+    restartable: boolean;
+    instantComplete: boolean;
+    secretQuest: boolean;
+    startedMessageText: string;
+    successMessageText: string;
+    acceptPlayerMessage: string;
+    declinePlayerMessage: string;
+    completePlayerMessage: string;
+    templateId: string;
+    rewards: IQuestRewards;
+    /** Becomes 'AppearStatus' inside client */
+    status: string | number;
+    KeyQuest: boolean;
+    changeQuestMessageText: string;
+    /** "Pmc" or "Scav" */
+    side: string;
+    /** Status of quest to player */
+    sptStatus?: QuestStatus;
+}
+export interface IQuestConditionTypes {
+    Started: IQuestCondition[];
+    AvailableForFinish: IQuestCondition[];
+    AvailableForStart: IQuestCondition[];
+    Success: IQuestCondition[];
+    Fail: IQuestCondition[];
+}
+export interface IQuestCondition {
+    id: string;
+    index?: number;
+    compareMethod?: string;
+    dynamicLocale: boolean;
+    visibilityConditions?: VisibilityCondition[];
+    globalQuestCounterId?: string;
+    parentId?: string;
+    target: string[] | string;
+    value?: string | number;
+    type?: boolean;
+    status?: QuestStatus[];
+    availableAfter?: number;
+    dispersion?: number;
+    onlyFoundInRaid?: boolean;
+    oneSessionOnly?: boolean;
+    doNotResetIfCounterCompleted?: boolean;
+    dogtagLevel?: number;
+    maxDurability?: number;
+    minDurability?: number;
+    counter?: IQuestConditionCounter;
+    plantTime?: number;
+    zoneId?: string;
+    countInRaid?: boolean;
+    completeInSeconds?: number;
+    isEncoded?: boolean;
+    conditionType?: string;
+}
+export interface IQuestConditionCounter {
+    id: string;
+    conditions: IQuestConditionCounterCondition[];
+}
+export interface IQuestConditionCounterCondition {
+    id: string;
+    dynamicLocale: boolean;
+    target?: string[] | string;
+    completeInSeconds?: number;
+    energy?: IValueCompare;
+    exitName?: string;
+    hydration?: IValueCompare;
+    time?: IValueCompare;
+    compareMethod?: string;
+    value?: number;
+    weapon?: string[];
+    distance?: ICounterConditionDistance;
+    equipmentInclusive?: string[][];
+    weaponModsInclusive?: string[][];
+    weaponModsExclusive?: string[][];
+    enemyEquipmentInclusive?: string[][];
+    enemyEquipmentExclusive?: string[][];
+    weaponCaliber?: string[];
+    savageRole?: string[];
+    status?: string[];
+    bodyPart?: string[];
+    daytime?: IDaytimeCounter;
+    conditionType?: string;
+    enemyHealthEffects?: IEnemyHealthEffect[];
+    resetOnSessionEnd?: boolean;
+}
+export interface IEnemyHealthEffect {
+    bodyParts: string[];
+    effects: string[];
+}
+export interface IValueCompare {
+    compareMethod: string;
+    value: number;
+}
+export interface ICounterConditionDistance {
+    value: number;
+    compareMethod: string;
+}
+export interface IDaytimeCounter {
+    from: number;
+    to: number;
+}
+export interface VisibilityCondition {
+    id: string;
+    target: string;
+    value?: number;
+    dynamicLocale?: boolean;
+    oneSessionOnly: boolean;
+    conditionType: string;
+}
+export interface IQuestRewards {
+    AvailableForStart?: IQuestReward[];
+    AvailableForFinish?: IQuestReward[];
+    Started?: IQuestReward[];
+    Success?: IQuestReward[];
+    Fail?: IQuestReward[];
+    FailRestartable?: IQuestReward[];
+    Expired?: IQuestReward[];
+}
+export interface IQuestReward {
+    value?: string | number;
+    id?: string;
+    type: QuestRewardType;
+    index: number;
+    target?: string;
+    items?: Item[];
+    loyaltyLevel?: number;
+    /** Hideout area id */
+    traderId?: string;
+    unknown?: boolean;
+    findInRaid?: boolean;
+}

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

@@ -0,0 +1,75 @@
+import { IQuest, IQuestConditionTypes, IQuestRewards } from "@spt/models/eft/common/tables/IQuest";
+export interface IRepeatableQuest extends IQuest {
+    changeCost: IChangeCost[];
+    changeStandingCost: number;
+    sptRepatableGroupName: string;
+}
+export interface IRepeatableQuestDatabase {
+    templates: IRepeatableTemplates;
+    rewards: IRewardOptions;
+    data: IOptions;
+    samples: ISampleQuests[];
+}
+export interface IRepeatableTemplates {
+    Elimination: IQuest;
+    Completion: IQuest;
+    Exploration: IQuest;
+}
+export interface IPmcDataRepeatableQuest {
+    id?: string;
+    name: string;
+    unavailableTime?: string;
+    activeQuests: IRepeatableQuest[];
+    inactiveQuests: IRepeatableQuest[];
+    endTime: number;
+    changeRequirement: Record<string, IChangeRequirement>;
+    freeChanges: number;
+    freeChangesAvailable: number;
+}
+export interface IChangeRequirement {
+    changeCost: IChangeCost[];
+    changeStandingCost: number;
+}
+export interface IChangeCost {
+    templateId: string;
+    count: number;
+}
+export interface IRewardOptions {
+    itemsBlacklist: string[];
+}
+export interface IOptions {
+    Completion: ICompletionFilter;
+}
+export interface ICompletionFilter {
+    itemsBlacklist: ItemsBlacklist[];
+    itemsWhitelist: ItemsWhitelist[];
+}
+export interface ItemsBlacklist {
+    minPlayerLevel: number;
+    itemIds: string[];
+}
+export interface ItemsWhitelist {
+    minPlayerLevel: number;
+    itemIds: string[];
+}
+export interface ISampleQuests {
+    _id: string;
+    traderId: string;
+    location: string;
+    image: string;
+    type: string;
+    isKey: boolean;
+    restartable: boolean;
+    instantComplete: boolean;
+    secretQuest: boolean;
+    canShowNotificationsInGame: boolean;
+    rewards: IQuestRewards;
+    conditions: IQuestConditionTypes;
+    name: string;
+    note: string;
+    description: string;
+    successMessageText: string;
+    failMessageText: string;
+    startedMessageText: string;
+    templateId: string;
+}

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

@@ -0,0 +1,543 @@
+import { Ixyz } from "@spt/models/eft/common/Ixyz";
+export interface ITemplateItem {
+    _id: string;
+    _name: string;
+    _parent: string;
+    _type: ItemType;
+    _props: Props;
+    _proto?: string;
+}
+export interface Props {
+    AllowSpawnOnLocations?: any[];
+    BeltMagazineRefreshCount?: number;
+    ChangePriceCoef?: number;
+    FixedPrice?: boolean;
+    SendToClient?: boolean;
+    Name?: string;
+    ShortName?: string;
+    Description?: string;
+    Weight?: number;
+    BackgroundColor?: string;
+    Width?: number;
+    Height?: number;
+    StackMaxSize?: number;
+    Rarity?: string;
+    SpawnChance?: number;
+    CreditsPrice?: number;
+    ItemSound?: string;
+    Prefab?: Prefab;
+    UsePrefab?: Prefab;
+    StackObjectsCount?: number;
+    NotShownInSlot?: boolean;
+    ExaminedByDefault?: boolean;
+    ExamineTime?: number;
+    IsUndiscardable?: boolean;
+    IsUnsaleable?: boolean;
+    IsUnbuyable?: boolean;
+    IsUngivable?: boolean;
+    IsUnremovable?: boolean;
+    IsLockedafterEquip?: boolean;
+    IsRagfairCurrency?: boolean;
+    IsSpecialSlotOnly?: boolean;
+    IsStationaryWeapon?: boolean;
+    QuestItem?: boolean;
+    QuestStashMaxCount?: number;
+    LootExperience?: number;
+    ExamineExperience?: number;
+    HideEntrails?: boolean;
+    InsuranceDisabled?: boolean;
+    RepairCost?: number;
+    RepairSpeed?: number;
+    ExtraSizeLeft?: number;
+    ExtraSizeRight?: number;
+    ExtraSizeUp?: number;
+    ExtraSizeDown?: number;
+    ExtraSizeForceAdd?: boolean;
+    MergesWithChildren?: boolean;
+    CanSellOnRagfair?: boolean;
+    CanRequireOnRagfair?: boolean;
+    ConflictingItems?: string[];
+    Unlootable?: boolean;
+    UnlootableFromSlot?: string;
+    UnlootableFromSide?: string[];
+    AnimationVariantsNumber?: number;
+    DiscardingBlock?: boolean;
+    DropSoundType?: string;
+    RagFairCommissionModifier?: number;
+    RarityPvE?: string;
+    IsAlwaysAvailableForInsurance?: boolean;
+    DiscardLimit?: number;
+    MaxResource?: number;
+    Resource?: number;
+    DogTagQualities?: boolean;
+    Grids?: Grid[];
+    Slots?: Slot[];
+    CanPutIntoDuringTheRaid?: boolean;
+    CantRemoveFromSlotsDuringRaid?: string[];
+    KeyIds?: string[];
+    TagColor?: number;
+    TagName?: string;
+    Durability?: number;
+    Accuracy?: number;
+    Recoil?: number;
+    Loudness?: number;
+    EffectiveDistance?: number;
+    Ergonomics?: number;
+    Velocity?: number;
+    WithAnimatorAiming?: boolean;
+    RaidModdable?: boolean;
+    ToolModdable?: boolean;
+    UniqueAnimationModID?: number;
+    BlocksFolding?: boolean;
+    BlocksCollapsible?: boolean;
+    IsAnimated?: boolean;
+    HasShoulderContact?: boolean;
+    SightingRange?: number;
+    DoubleActionAccuracyPenaltyMult?: number;
+    ModesCount?: any;
+    DurabilityBurnModificator?: number;
+    HeatFactor?: number;
+    CoolFactor?: number;
+    muzzleModType?: string;
+    CustomAimPlane?: string;
+    sightModType?: string;
+    aimingSensitivity?: number;
+    SightModesCount?: number;
+    OpticCalibrationDistances?: number[];
+    ScopesCount?: number;
+    AimSensitivity?: number | number[][];
+    Zooms?: number[][];
+    CalibrationDistances?: number[][];
+    Intensity?: number;
+    Mask?: string;
+    MaskSize?: number;
+    IsMagazineForStationaryWeapon?: boolean;
+    NoiseIntensity?: number;
+    NoiseScale?: number;
+    Color?: IColor;
+    DiffuseIntensity?: number;
+    MagazineWithBelt?: boolean;
+    HasHinge?: boolean;
+    RampPalette?: string;
+    DepthFade?: number;
+    RoughnessCoef?: number;
+    SpecularCoef?: number;
+    MainTexColorCoef?: number;
+    MinimumTemperatureValue?: number;
+    RampShift?: number;
+    HeatMin?: number;
+    ColdMax?: number;
+    IsNoisy?: boolean;
+    IsFpsStuck?: boolean;
+    IsGlitch?: boolean;
+    IsMotionBlurred?: boolean;
+    IsPixelated?: boolean;
+    PixelationBlockCount?: number;
+    ShiftsAimCamera?: number;
+    magAnimationIndex?: number;
+    Cartridges?: Slot[];
+    CanFast?: boolean;
+    CanHit?: boolean;
+    CanAdmin?: boolean;
+    LoadUnloadModifier?: number;
+    CheckTimeModifier?: number;
+    CheckOverride?: number;
+    ReloadMagType?: string;
+    VisibleAmmoRangesString?: string;
+    MalfunctionChance?: number;
+    IsShoulderContact?: boolean;
+    Foldable?: boolean;
+    Retractable?: boolean;
+    SizeReduceRight?: number;
+    CenterOfImpact?: number;
+    ShotgunDispersion?: number;
+    IsSilencer?: boolean;
+    DeviationCurve?: number;
+    DeviationMax?: number;
+    SearchSound?: string;
+    BlocksArmorVest?: boolean;
+    speedPenaltyPercent?: number;
+    GridLayoutName?: string;
+    ContainerSpawnChanceModifier?: number;
+    SpawnExcludedFilter?: string[];
+    SpawnFilter?: any[];
+    containType?: any[];
+    sizeWidth?: number;
+    sizeHeight?: number;
+    isSecured?: boolean;
+    spawnTypes?: string;
+    lootFilter?: any[];
+    spawnRarity?: string;
+    minCountSpawn?: number;
+    maxCountSpawn?: number;
+    openedByKeyID?: any[];
+    RigLayoutName?: string;
+    MaxDurability?: number;
+    armorZone?: string[];
+    armorClass?: string | number;
+    armorColliders?: string[];
+    armorPlateColliders?: string[];
+    bluntDamageReduceFromSoftArmor?: boolean;
+    mousePenalty?: number;
+    weaponErgonomicPenalty?: number;
+    BluntThroughput?: number;
+    ArmorMaterial?: string;
+    ArmorType?: string;
+    weapClass?: string;
+    weapUseType?: string;
+    ammoCaliber?: string;
+    OperatingResource?: number;
+    PostRecoilHorizontalRangeHandRotation?: Ixyz;
+    PostRecoilVerticalRangeHandRotation?: Ixyz;
+    ProgressRecoilAngleOnStable?: Ixyz;
+    RepairComplexity?: number;
+    durabSpawnMin?: number;
+    durabSpawnMax?: number;
+    isFastReload?: boolean;
+    RecoilForceUp?: number;
+    RecoilForceBack?: number;
+    RecoilAngle?: number;
+    RecoilCamera?: number;
+    weapFireType?: string[];
+    RecolDispersion?: number;
+    SingleFireRate?: number;
+    CanQueueSecondShot?: boolean;
+    bFirerate?: number;
+    bEffDist?: number;
+    bHearDist?: number;
+    blockLeftStance?: boolean;
+    isChamberLoad?: boolean;
+    chamberAmmoCount?: number;
+    isBoltCatch?: boolean;
+    defMagType?: string;
+    defAmmo?: string;
+    AdjustCollimatorsToTrajectory?: boolean;
+    shotgunDispersion?: number;
+    Chambers?: Slot[];
+    CameraSnap?: number;
+    CameraToWeaponAngleSpeedRange?: Ixyz;
+    CameraToWeaponAngleStep?: number;
+    ReloadMode?: string;
+    AimPlane?: number;
+    TacticalReloadStiffnes?: Ixyz;
+    TacticalReloadFixation?: number;
+    RecoilCenter?: Ixyz;
+    RotationCenter?: Ixyz;
+    RotationCenterNoStock?: Ixyz;
+    ShotsGroupSettings?: IShotsGroupSettings[];
+    FoldedSlot?: string;
+    CompactHandling?: boolean;
+    MinRepairDegradation?: number;
+    MaxRepairDegradation?: number;
+    IronSightRange?: number;
+    IsBeltMachineGun?: boolean;
+    IsFlareGun?: boolean;
+    IsGrenadeLauncher?: boolean;
+    IsOneoff?: boolean;
+    MustBoltBeOpennedForExternalReload?: boolean;
+    MustBoltBeOpennedForInternalReload?: boolean;
+    NoFiremodeOnBoltcatch?: boolean;
+    BoltAction?: boolean;
+    HipAccuracyRestorationDelay?: number;
+    HipAccuracyRestorationSpeed?: number;
+    HipInnaccuracyGain?: number;
+    ManualBoltCatch?: boolean;
+    BurstShotsCount?: number;
+    BaseMalfunctionChance?: number;
+    AllowJam?: boolean;
+    AllowFeed?: boolean;
+    AllowMisfire?: boolean;
+    AllowSlide?: boolean;
+    DurabilityBurnRatio?: number;
+    HeatFactorGun?: number;
+    CoolFactorGun?: number;
+    CoolFactorGunMods?: number;
+    HeatFactorByShot?: number;
+    AllowOverheat?: boolean;
+    DoubleActionAccuracyPenalty?: number;
+    RecoilPosZMult?: number;
+    RecoilReturnPathDampingHandRotation?: number;
+    RecoilReturnPathOffsetHandRotation?: number;
+    RecoilReturnSpeedHandRotation?: number;
+    RecoilStableAngleIncreaseStep?: number;
+    RecoilStableIndexShot?: number;
+    MinRepairKitDegradation?: number;
+    MaxRepairKitDegradation?: number;
+    BlocksEarpiece?: boolean;
+    BlocksEyewear?: boolean;
+    BlocksHeadwear?: boolean;
+    BlocksFaceCover?: boolean;
+    Indestructibility?: number;
+    headSegments?: string[];
+    FaceShieldComponent?: boolean;
+    FaceShieldMask?: string;
+    MaterialType?: string;
+    RicochetParams?: Ixyz;
+    DeafStrength?: string;
+    BlindnessProtection?: number;
+    Distortion?: number;
+    CompressorTreshold?: number;
+    CompressorAttack?: number;
+    CompressorRelease?: number;
+    CompressorGain?: number;
+    CutoffFreq?: number;
+    Resonance?: number;
+    RolloffMultiplier?: number;
+    ReverbVolume?: number;
+    CompressorVolume?: number;
+    AmbientVolume?: number;
+    DryVolume?: number;
+    HighFrequenciesGain?: number;
+    foodUseTime?: number;
+    foodEffectType?: string;
+    StimulatorBuffs?: string;
+    effects_health?: IHealthEffect[] | Record<string, Record<string, number>>;
+    effects_damage?: Record<string, IEffectDamageProps>;
+    MaximumNumberOfUsage?: number;
+    knifeHitDelay?: number;
+    knifeHitSlashRate?: number;
+    knifeHitStabRate?: number;
+    knifeHitRadius?: number;
+    knifeHitSlashDam?: number;
+    knifeHitStabDam?: number;
+    knifeDurab?: number;
+    PrimaryDistance?: number;
+    SecondryDistance?: number;
+    SlashPenetration?: number;
+    StabPenetration?: number;
+    PrimaryConsumption?: number;
+    SecondryConsumption?: number;
+    DeflectionConsumption?: number;
+    AppliedTrunkRotation?: Ixyz;
+    AppliedHeadRotation?: Ixyz;
+    DisplayOnModel?: boolean;
+    AdditionalAnimationLayer?: number;
+    StaminaBurnRate?: number;
+    ColliderScaleMultiplier?: Ixyz;
+    ConfigPathStr?: string;
+    MaxMarkersCount?: number;
+    scaleMin?: number;
+    scaleMax?: number;
+    medUseTime?: number;
+    medEffectType?: string;
+    MaxHpResource?: number;
+    hpResourceRate?: number;
+    apResource?: number;
+    krResource?: number;
+    MaxOpticZoom?: number;
+    MaxRepairResource?: number;
+    TargetItemFilter?: string[];
+    RepairQuality?: number;
+    RepairType?: string;
+    StackMinRandom?: number;
+    StackMaxRandom?: number;
+    ammoType?: string;
+    InitialSpeed?: number;
+    BallisticCoeficient?: number;
+    BulletMassGram?: number;
+    BulletDiameterMilimeters?: number;
+    Damage?: number;
+    ammoAccr?: number;
+    ammoRec?: number;
+    ammoDist?: number;
+    buckshotBullets?: number;
+    PenetrationPower?: number;
+    PenetrationPowerDiviation?: number;
+    ammoHear?: number;
+    ammoSfx?: string;
+    MisfireChance?: number;
+    MinFragmentsCount?: number;
+    MaxFragmentsCount?: number;
+    ammoShiftChance?: number;
+    casingName?: string;
+    casingEjectPower?: number;
+    casingMass?: number;
+    casingSounds?: string;
+    ProjectileCount?: number;
+    PenetrationChanceObstacle?: number;
+    PenetrationDamageMod?: number;
+    RicochetChance?: number;
+    FragmentationChance?: number;
+    Deterioration?: number;
+    SpeedRetardation?: number;
+    Tracer?: boolean;
+    TracerColor?: string;
+    TracerDistance?: number;
+    ArmorDamage?: number;
+    Caliber?: string;
+    StaminaBurnPerDamage?: number;
+    HeavyBleedingDelta?: number;
+    LightBleedingDelta?: number;
+    ShowBullet?: boolean;
+    HasGrenaderComponent?: boolean;
+    FuzeArmTimeSec?: number;
+    ExplosionStrength?: number;
+    MinExplosionDistance?: number;
+    MaxExplosionDistance?: number;
+    FragmentsCount?: number;
+    FragmentType?: string;
+    ShowHitEffectOnExplode?: boolean;
+    ExplosionType?: string;
+    AmmoLifeTimeSec?: number;
+    Contusion?: Ixyz;
+    ArmorDistanceDistanceDamage?: Ixyz;
+    Blindness?: Ixyz;
+    IsLightAndSoundShot?: boolean;
+    LightAndSoundShotAngle?: number;
+    LightAndSoundShotSelfContusionTime?: number;
+    LightAndSoundShotSelfContusionStrength?: number;
+    MalfMisfireChance?: number;
+    MalfFeedChance?: number;
+    StackSlots?: StackSlot[];
+    type?: string;
+    eqMin?: number;
+    eqMax?: number;
+    rate?: number;
+    ThrowType?: string;
+    ExplDelay?: number;
+    Strength?: number;
+    ContusionDistance?: number;
+    throwDamMax?: number;
+    explDelay?: number;
+    EmitTime?: number;
+    CanBeHiddenDuringThrow?: boolean;
+    MinTimeToContactExplode?: number;
+    ExplosionEffectType?: string;
+    LinkedWeapon?: string;
+    UseAmmoWithoutShell?: boolean;
+    RandomLootSettings?: IRandomLootSettings;
+    RecoilCategoryMultiplierHandRotation?: number;
+    RecoilDampingHandRotation?: number;
+    LeanWeaponAgainstBody?: boolean;
+    RemoveShellAfterFire?: boolean;
+    RepairStrategyTypes?: string[];
+    IsEncoded?: boolean;
+    LayoutName?: string;
+    Lower75Prefab?: Prefab;
+    MaxUsages?: number;
+    ScavKillExpPenalty?: number;
+    ScavKillExpPenaltyPVE?: number;
+    ScavKillStandingPenalty?: number;
+    ScavKillStandingPenaltyPVE?: number;
+    TradersDiscount?: number;
+    TradersDiscountPVE?: number;
+}
+export interface IHealthEffect {
+    type: string;
+    value: number;
+}
+export interface Prefab {
+    path: string;
+    rcid: string;
+}
+export interface Grid {
+    _name: string;
+    _id: string;
+    _parent: string;
+    _props: GridProps;
+    _proto: string;
+}
+export interface GridProps {
+    filters: GridFilter[];
+    cellsH: number;
+    cellsV: number;
+    minCount: number;
+    maxCount: number;
+    maxWeight: number;
+    isSortingTable: boolean;
+}
+export interface GridFilter {
+    Filter: string[];
+    ExcludedFilter: string[];
+}
+export interface Slot {
+    _name: string;
+    _id: string;
+    _parent: string;
+    _props: SlotProps;
+    _max_count?: number;
+    _required?: boolean;
+    _mergeSlotWithChildren?: boolean;
+    _proto: string;
+}
+export interface SlotProps {
+    filters: SlotFilter[];
+    MaxStackCount?: number;
+}
+export interface SlotFilter {
+    Shift?: number;
+    locked?: boolean;
+    Plate?: string;
+    armorColliders?: string[];
+    armorPlateColliders?: string[];
+    Filter: string[];
+    AnimationIndex?: number;
+}
+export interface StackSlot {
+    _name?: string;
+    _id: string;
+    _parent: string;
+    _max_count: number;
+    _props: StackSlotProps;
+    _proto: string;
+    upd?: any;
+}
+export interface StackSlotProps {
+    filters: SlotFilter[];
+}
+export interface IRandomLootSettings {
+    allowToSpawnIdenticalItems: boolean;
+    allowToSpawnQuestItems: boolean;
+    countByRarity: any[];
+    excluded: IRandomLootExcluded;
+    filters: any[];
+    findInRaid: boolean;
+    maxCount: number;
+    minCount: number;
+}
+export interface IRandomLootExcluded {
+    categoryTemplates: any[];
+    rarity: string[];
+    templates: any[];
+}
+export interface EffectsHealth {
+    Energy: EffectsHealthProps;
+    Hydration: EffectsHealthProps;
+}
+export interface EffectsHealthProps {
+    value: number;
+}
+export interface EffectsDamage {
+    Pain: IEffectDamageProps;
+    LightBleeding: IEffectDamageProps;
+    HeavyBleeding: IEffectDamageProps;
+    Contusion: IEffectDamageProps;
+    RadExposure: IEffectDamageProps;
+    Fracture: IEffectDamageProps;
+    DestroyedPart: IEffectDamageProps;
+}
+export interface IEffectDamageProps {
+    delay: number;
+    duration: number;
+    fadeOut: number;
+    cost?: number;
+    healthPenaltyMin?: number;
+    healthPenaltyMax?: number;
+}
+export interface IColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface IShotsGroupSettings {
+    EndShotIndex: number;
+    ShotRecoilPositionStrength: Ixyz;
+    ShotRecoilRadianRange: Ixyz;
+    ShotRecoilRotationStrength: Ixyz;
+    StartShotIndex: number;
+}
+export declare enum ItemType {
+    NODE = "Node",
+    ITEM = "Item"
+}

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

@@ -0,0 +1,101 @@
+import { Item } from "@spt/models/eft/common/tables/IItem";
+import { ITraderServiceModel } from "@spt/models/spt/services/ITraderServiceModel";
+export interface ITrader {
+    assort?: ITraderAssort;
+    base: ITraderBase;
+    dialogue?: Record<string, string[]>;
+    questassort?: Record<string, Record<string, string>>;
+    suits?: ISuit[];
+    services?: ITraderServiceModel[];
+}
+export interface ITraderBase {
+    refreshTraderRagfairOffers: boolean;
+    _id: string;
+    availableInRaid: boolean;
+    avatar: string;
+    balance_dol: number;
+    balance_eur: number;
+    balance_rub: number;
+    buyer_up: boolean;
+    currency: string;
+    customization_seller: boolean;
+    discount: number;
+    discount_end: number;
+    gridHeight: number;
+    insurance: Insurance;
+    items_buy: IItemBuyData;
+    items_buy_prohibited: IItemBuyData;
+    location: string;
+    loyaltyLevels: LoyaltyLevel[];
+    medic: boolean;
+    name: string;
+    nextResupply: number;
+    nickname: string;
+    repair: Repair;
+    sell_category: string[];
+    surname: string;
+    unlockedByDefault: boolean;
+}
+export interface IItemBuyData {
+    category: string[];
+    id_list: string[];
+}
+export interface Insurance {
+    availability: boolean;
+    excluded_category: string[];
+    max_return_hour: number;
+    max_storage_time: number;
+    min_payment: number;
+    min_return_hour: number;
+}
+export interface LoyaltyLevel {
+    buy_price_coef: number;
+    exchange_price_coef: number;
+    heal_price_coef: number;
+    insurance_price_coef: number;
+    minLevel: number;
+    minSalesSum: number;
+    minStanding: number;
+    repair_price_coef: number;
+}
+export interface Repair {
+    availability: boolean;
+    currency: string;
+    currency_coefficient: number;
+    excluded_category: string[];
+    /** Doesn't exist in client object */
+    excluded_id_list: any[];
+    quality: number;
+}
+export interface ITraderAssort {
+    nextResupply: number;
+    items: Item[];
+    barter_scheme: Record<string, IBarterScheme[][]>;
+    loyal_level_items: Record<string, number>;
+}
+export interface IBarterScheme {
+    count: number;
+    _tpl: string;
+    onlyFunctional?: boolean;
+    sptQuestLocked?: boolean;
+}
+export interface ISuit {
+    _id: string;
+    tid: string;
+    suiteId: string;
+    isActive: boolean;
+    requirements: ISuitRequirements;
+}
+export interface ISuitRequirements {
+    loyaltyLevel: number;
+    profileLevel: number;
+    standing: number;
+    skillRequirements: string[];
+    questRequirements: string[];
+    itemRequirements: ItemRequirement[];
+}
+export interface ItemRequirement {
+    count: number;
+    _tpl: string;
+    onlyFunctional: boolean;
+}

types/models/eft/customization/IBuyClothingRequestData.d.ts

@@ -0,0 +1,10 @@
+export interface IBuyClothingRequestData {
+    Action: "CustomizationBuy";
+    offer: string;
+    items: ClothingItem[];
+}
+export interface ClothingItem {
+    del: boolean;
+    id: string;
+    count: number;
+}

types/models/eft/customization/IGetSuitsResponse.d.ts

@@ -0,0 +1,4 @@
+export interface IGetSuitsResponse {
+    _id: string;
+    suites: string[];
+}

types/models/eft/customization/IWearClothingRequestData.d.ts

@@ -0,0 +1,4 @@
+export interface IWearClothingRequestData {
+    Action: "CustomizationWear";
+    suites: string[];
+}

types/models/eft/dialog/IAcceptFriendRequestData.d.ts

@@ -0,0 +1,9 @@
+export interface IAcceptFriendRequestData extends IBaseFriendRequest {
+}
+export interface ICancelFriendRequestData extends IBaseFriendRequest {
+}
+export interface IDeclineFriendRequestData extends IBaseFriendRequest {
+}
+export interface IBaseFriendRequest {
+    profileId: string;
+}

types/models/eft/dialog/IAddUserGroupMailRequest.d.ts

@@ -0,0 +1,4 @@
+export interface IAddUserGroupMailRequest {
+    dialogId: string;
+    uid: string;
+}

types/models/eft/dialog/IChangeGroupMailOwnerRequest.d.ts

@@ -0,0 +1,4 @@
+export interface IChangeGroupMailOwnerRequest {
+    dialogId: string;
+    uid: string;
+}

types/models/eft/dialog/IChatServer.d.ts

@@ -0,0 +1,16 @@
+export interface IChatServer {
+    _id: string;
+    RegistrationId: number;
+    VersionId: string;
+    Ip: string;
+    Port: number;
+    DateTime: number;
+    Chats: IChat[];
+    Regions: string[];
+    /** Possibly removed */
+    IsDeveloper?: boolean;
+}
+export interface IChat {
+    _id: string;
+    Members: number;
+}

types/models/eft/dialog/IClearMailMessageRequest.d.ts

@@ -0,0 +1,3 @@
+export interface IClearMailMessageRequest {
+    dialogId: string;
+}

types/models/eft/dialog/ICreateGroupMailRequest.d.ts

@@ -0,0 +1,4 @@
+export interface ICreateGroupMailRequest {
+    Name: string;
+    Users: string[];
+}

types/models/eft/dialog/IDeleteFriendRequest.d.ts

@@ -0,0 +1,3 @@
+export interface IDeleteFriendRequest {
+    friend_id: string;
+}

types/models/eft/dialog/IFriendRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IFriendRequestData {
+    to: string;
+}

types/models/eft/dialog/IFriendRequestSendResponse.d.ts

@@ -0,0 +1,5 @@
+export interface IFriendRequestSendResponse {
+    status: number;
+    requestId: string;
+    retryAfter: number;
+}

types/models/eft/dialog/IGetAllAttachmentsRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IGetAllAttachmentsRequestData {
+    dialogId: string;
+}

types/models/eft/dialog/IGetAllAttachmentsResponse.d.ts

@@ -0,0 +1,6 @@
+import { Message } from "@spt/models/eft/profile/ISptProfile";
+export interface IGetAllAttachmentsResponse {
+    messages: Message[];
+    profiles: any[];
+    hasMessagesWithRewards: boolean;
+}

types/models/eft/dialog/IGetChatServerListRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IGetChatServerListRequestData {
+    VersionId: string;
+}

types/models/eft/dialog/IGetFriendListDataResponse.d.ts

@@ -0,0 +1,6 @@
+import { IUserDialogInfo } from "@spt/models/eft/profile/ISptProfile";
+export interface IGetFriendListDataResponse {
+    Friends: IUserDialogInfo[];
+    Ignore: string[];
+    InIgnoreList: string[];
+}

types/models/eft/dialog/IGetMailDialogInfoRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IGetMailDialogInfoRequestData {
+    dialogId: string;
+}

types/models/eft/dialog/IGetMailDialogListRequestData.d.ts

@@ -0,0 +1,4 @@
+export interface IGetMailDialogListRequestData {
+    limit: number;
+    offset: number;
+}

types/models/eft/dialog/IGetMailDialogViewRequestData.d.ts

@@ -0,0 +1,7 @@
+import { MessageType } from "@spt/models/enums/MessageType";
+export interface IGetMailDialogViewRequestData {
+    type: MessageType;
+    dialogId: string;
+    limit: number;
+    time: number;
+}

types/models/eft/dialog/IGetMailDialogViewResponseData.d.ts

@@ -0,0 +1,6 @@
+import { IUserDialogInfo, Message } from "@spt/models/eft/profile/ISptProfile";
+export interface IGetMailDialogViewResponseData {
+    messages: Message[];
+    profiles: IUserDialogInfo[];
+    hasMessagesWithRewards: boolean;
+}

types/models/eft/dialog/IPinDialogRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IPinDialogRequestData {
+    dialogId: string;
+}

types/models/eft/dialog/IRemoveDialogRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IRemoveDialogRequestData {
+    dialogId: string;
+}

types/models/eft/dialog/IRemoveMailMessageRequest.d.ts

@@ -0,0 +1,3 @@
+export interface IRemoveMailMessageRequest {
+    dialogId: string;
+}

types/models/eft/dialog/IRemoveUserGroupMailRequest.d.ts

@@ -0,0 +1,4 @@
+export interface IRemoveUserGroupMailRequest {
+    dialogId: string;
+    uid: string;
+}

types/models/eft/dialog/ISendMessageRequest.d.ts

@@ -0,0 +1,7 @@
+import { MessageType } from "@spt/models/enums/MessageType";
+export interface ISendMessageRequest {
+    dialogId: string;
+    type: MessageType;
+    text: string;
+    replyTo: string;
+}

types/models/eft/dialog/ISetDialogReadRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface ISetDialogReadRequestData {
+    dialogs: string[];
+}

types/models/eft/game/ICheckVersionResponse.d.ts

@@ -0,0 +1,4 @@
+export interface ICheckVersionResponse {
+    isvalid: boolean;
+    latestVersion: string;
+}

types/models/eft/game/ICurrentGroupResponse.d.ts

@@ -0,0 +1,17 @@
+import { MemberCategory } from "@spt/models/enums/MemberCategory";
+export interface ICurrentGroupResponse {
+    squad: ICurrentGroupSquadMember[];
+}
+export interface ICurrentGroupSquadMember {
+    _id: string;
+    aid: string;
+    info: ICurrentGroupMemberInfo;
+    isLeader: boolean;
+    isReady: boolean;
+}
+export interface ICurrentGroupMemberInfo {
+    Nickname: string;
+    Side: string;
+    Level: string;
+    MemberCategory: MemberCategory;
+}

types/models/eft/game/IGameConfigResponse.d.ts

@@ -0,0 +1,22 @@
+export interface IGameConfigResponse {
+    aid: number;
+    lang: string;
+    languages: Record<string, string>;
+    ndaFree: boolean;
+    taxonomy: number;
+    activeProfileId: string;
+    backend: Backend;
+    useProtobuf: boolean;
+    utc_time: number;
+    /** Total in game time */
+    totalInGame: number;
+    reportAvailable: boolean;
+    twitchEventMember: boolean;
+}
+export interface Backend {
+    Lobby: string;
+    Trading: string;
+    Messaging: string;
+    Main: string;
+    RagFair: string;
+}

types/models/eft/game/IGameEmptyCrcRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IGameEmptyCrcRequestData {
+    crc: number;
+}

types/models/eft/game/IGameKeepAliveResponse.d.ts

@@ -0,0 +1,4 @@
+export interface IGameKeepAliveResponse {
+    msg: string;
+    utc_time: number;
+}

types/models/eft/game/IGameLogoutResponseData.d.ts

@@ -0,0 +1,3 @@
+export interface IGameLogoutResponseData {
+    status: string;
+}

types/models/eft/game/IGameModeRequestData.d.ts

@@ -0,0 +1,3 @@
+export interface IGameModeRequestData {
+    sessionMode: string | undefined;
+}

types/models/eft/game/IGameModeResponse.d.ts

@@ -0,0 +1,8 @@
+export declare enum ESessionMode {
+    REGULAR = "regular",
+    PVE = "pve"
+}
+export interface IGameModeResponse {
+    gameMode: ESessionMode;
+    backendUrl: string;
+}

types/models/eft/game/IGameStartResponse.d.ts

@@ -0,0 +1,3 @@
+export interface IGameStartResponse {
+    utc_time: number;
+}

types/models/eft/game/IGetItemPricesResponse.d.ts

@@ -0,0 +1,5 @@
+export interface IGetItemPricesResponse {
+    supplyNextTime: number;
+    prices: Record<string, number>;
+    currencyCourses: Record<string, number>;
+}

types/models/eft/game/IGetRaidTimeRequest.d.ts

@@ -0,0 +1,4 @@
+export interface IGetRaidTimeRequest {
+    Side: string;
+    Location: string;
+}

types/models/eft/game/IGetRaidTimeResponse.d.ts

@@ -0,0 +1,12 @@
+export interface IGetRaidTimeResponse {
+    RaidTimeMinutes: number;
+    NewSurviveTimeSeconds?: number;
+    OriginalSurvivalTimeSeconds: number;
+    ExitChanges: ExtractChange[];
+}
+export interface ExtractChange {
+    Name: string;
+    MinTime?: number;
+    MaxTime?: number;
+    Chance?: number;
+}

types/models/eft/game/ISendReportRequest.d.ts

@@ -0,0 +1,4 @@
+export interface ISendReportRequest {
+    type: string;
+    uid: string;
+}

types/models/eft/game/IServerDetails.d.ts

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

types/models/eft/game/IVersionValidateRequestData.d.ts

@@ -0,0 +1,11 @@
+export interface IVersionValidateRequestData {
+    version: Version;
+    develop: boolean;
+}
+export interface Version {
+    major: string;
+    minor: string;
+    game: string;
+    backend: string;
+    taxonomy: string;
+}

types/models/eft/health/Effect.d.ts

@@ -0,0 +1,7 @@
+export declare enum Effect {
+    FRACTURE = "Fracture",
+    LIGHT_BLEEDING = "LightBleeding",
+    HEAVY_BLEEDING = "HeavyBleeding",
+    MILD_MUSCLE_PAIN = "MildMusclePain",
+    SEVERE_MUSCLE_PAIN = "SevereMusclePain"
+}

types/models/eft/health/IHealthTreatmentRequestData.d.ts

@@ -0,0 +1,32 @@
+export interface IHealthTreatmentRequestData {
+    Action: "RestoreHealth";
+    trader: string;
+    items: Cost[];
+    difference: Difference;
+    timestamp: number;
+}
+export interface Cost {
+    /** Id of stack to take money from */
+    id: string;
+    /** Amount of money to take off player for treatment */
+    count: number;
+}
+export interface Difference {
+    BodyParts: BodyParts;
+    Energy: number;
+    Hydration: number;
+}
+export interface BodyParts {
+    Head: BodyPart;
+    Chest: BodyPart;
+    Stomach: BodyPart;
+    LeftArm: BodyPart;
+    RightArm: BodyPart;
+    LeftLeg: BodyPart;
+    RightLeg: BodyPart;
+}
+export interface BodyPart {
+    Health: number;
+    /** Effects in array are to be removed */
+    Effects: string[];
+}

types/models/eft/health/IOffraidEatRequestData.d.ts

@@ -0,0 +1,7 @@
+import { IBaseInteractionRequestData } from "@spt/models/eft/common/request/IBaseInteractionRequestData";
+export interface IOffraidEatRequestData extends IBaseInteractionRequestData {
+    Action: "Eat";
+    item: string;
+    count: number;
+    time: number;
+}

types/models/eft/health/IOffraidHealRequestData.d.ts

@@ -0,0 +1,18 @@
+import { IBaseInteractionRequestData } from "@spt/models/eft/common/request/IBaseInteractionRequestData";
+export interface IOffraidHealRequestData extends IBaseInteractionRequestData {
+    Action: "Heal";
+    item: string;
+    part: BodyPart;
+    count: number;
+    time: number;
+}
+export declare enum BodyPart {
+    HEAD = "Head",
+    CHEST = "Chest",
+    STOMACH = "Stomach",
+    LEFT_ARM = "LeftArm",
+    RIGHT_ARM = "RightArm",
+    LEFT_LEG = "LeftLeg",
+    RIGHT_LEG = "RightLeg",
+    COMMON = "Common"
+}

types/models/eft/health/ISyncHealthRequestData.d.ts

@@ -0,0 +1,21 @@
+export interface ISyncHealthRequestData {
+    Health: Health;
+    IsAlive: boolean;
+    Hydration?: number;
+    Energy?: number;
+    Temperature?: number;
+}
+export interface Health {
+    Head?: BodyPartHealth;
+    Chest?: BodyPartHealth;
+    Stomach?: BodyPartHealth;
+    LeftArm?: BodyPartHealth;
+    RightArm?: BodyPartHealth;
+    LeftLeg?: BodyPartHealth;
+    RightLeg?: BodyPartHealth;
+}
+export interface BodyPartHealth {
+    Maximum: number;
+    Current: number;
+    Effects: Record<string, number>;
+}

types/models/eft/health/IWorkoutData.d.ts

@@ -0,0 +1,4 @@
+export interface IWorkoutData extends Record<string, any> {
+    skills: any;
+    effects: any;
+}

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

@@ -0,0 +1,5 @@
+export interface HideoutUpgradeCompleteRequestData {
+    Action: string;
+    areaType: number;
+    timestamp: number;
+}

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

@@ -0,0 +1,8 @@
+export interface IHandleQTEEventRequestData {
+    Action: string;
+    /** true if QTE was successful, otherwise false */
+    results: boolean[];
+    /** Id of the QTE object used from db/hideout/qte.json */
+    id: string;
+    timestamp: number;
+}

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

@@ -0,0 +1,78 @@
+import { BonusSkillType } from "@spt/models/enums/BonusSkillType";
+import { BonusType } from "@spt/models/enums/BonusType";
+export interface IHideoutArea {
+    _id: string;
+    type: number;
+    enabled: boolean;
+    needsFuel: boolean;
+    requirements: IAreaRequirement[];
+    takeFromSlotLocked: boolean;
+    craftGivesExp: boolean;
+    displayLevel: boolean;
+    enableAreaRequirements: boolean;
+    parentArea?: string;
+    stages: Record<string, Stage>;
+}
+export interface IAreaRequirement {
+    areaType: number;
+    requiredlevel: number;
+    type: string;
+}
+export interface Stage {
+    autoUpgrade: boolean;
+    bonuses: StageBonus[];
+    constructionTime: number;
+    /** Containers inventory tpl */
+    container?: string;
+    description: string;
+    displayInterface: boolean;
+    improvements: IStageImprovement[];
+    requirements: IStageRequirement[];
+    slots: number;
+}
+export interface IStageImprovement {
+    id: string;
+    bonuses: IStageImprovementBonus[];
+    improvementTime: number;
+    requirements: IStageImprovementRequirement[];
+}
+export interface IStageImprovementBonus {
+    passive: boolean;
+    production: boolean;
+    type: string;
+    value: number;
+    visible: boolean;
+}
+export interface IStageImprovementRequirement {
+    count: number;
+    isEncoded: boolean;
+    isFunctional: boolean;
+    templateId: string;
+    type: string;
+}
+export interface IStageRequirement {
+    areaType?: number;
+    requiredLevel?: number;
+    type: string;
+    templateId?: string;
+    count?: number;
+    isEncoded: false;
+    isFunctional?: boolean;
+    traderId?: string;
+    loyaltyLevel?: number;
+    skillName?: string;
+    skillLevel?: number;
+}
+export interface StageBonus {
+    value: number;
+    passive: boolean;
+    production: boolean;
+    visible: boolean;
+    skillType?: BonusSkillType;
+    type: BonusType;
+    filter?: string[];
+    icon?: string;
+    /** CHANGES PER DUMP */
+    id?: string;
+    templateId?: string;
+}

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

@@ -0,0 +1,5 @@
+export interface IHideoutCancelProductionRequestData {
+    Action: "HideoutCancelProductionCommand";
+    recipeId: string;
+    timestamp: number;
+}

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

@@ -0,0 +1,5 @@
+export interface IHideoutContinuousProductionStartRequestData {
+    Action: "HideoutContinuousProductionStart";
+    recipeId: string;
+    timestamp: number;
+}

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

@@ -0,0 +1,13 @@
+export interface IHideoutImproveAreaRequestData {
+    Action: "HideoutImproveArea";
+    /** Hideout area id from areas.json */
+    id: string;
+    areaType: number;
+    items: HideoutItem[];
+    timestamp: number;
+}
+export interface HideoutItem {
+    /** Hideout inventory id that was used by improvement action */
+    id: string;
+    count: number;
+}

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

@@ -0,0 +1,25 @@
+export interface IHideoutProduction {
+    _id: string;
+    areaType: number;
+    requirements: Requirement[];
+    productionTime: number;
+    /** Tpl of item being crafted */
+    endProduct: string;
+    isEncoded: boolean;
+    locked: boolean;
+    needFuelForAllProductionTime: boolean;
+    continuous: boolean;
+    count: number;
+    productionLimitCount: number;
+}
+export interface Requirement {
+    templateId?: string;
+    count?: number;
+    isEncoded?: boolean;
+    isFunctional?: boolean;
+    type: string;
+    areaType?: number;
+    requiredLevel?: number;
+    resource?: number;
+    questId?: string;
+}

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

@@ -0,0 +1,10 @@
+export interface IHideoutPutItemInRequestData {
+    Action: "HideoutPutItemsInAreaSlots";
+    areaType: number;
+    items: Record<string, ItemDetails>;
+    timestamp: number;
+}
+export interface ItemDetails {
+    count: number;
+    id: string;
+}

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

@@ -0,0 +1,18 @@
+import { MinMax } from "@spt/models/common/MinMax";
+export interface IHideoutScavCase {
+    _id: string;
+    ProductionTime: number;
+    Requirements: Requirement[];
+    EndProducts: EndProducts;
+}
+export interface Requirement {
+    templateId: string;
+    count: number;
+    isFunctional: boolean;
+    type: string;
+}
+export interface EndProducts {
+    Common: MinMax;
+    Rare: MinMax;
+    Superrare: MinMax;
+}

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

@@ -0,0 +1,15 @@
+export interface IHideoutScavCaseStartRequestData {
+    Action: "HideoutScavCaseProductionStart";
+    recipeId: string;
+    items: HideoutItem[];
+    tools: Tool[];
+    timestamp: number;
+}
+export interface HideoutItem {
+    id: string;
+    count: number;
+}
+export interface Tool {
+    id: string;
+    count: number;
+}

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

@@ -0,0 +1,6 @@
+export interface IHideoutSettingsBase {
+    generatorSpeedWithoutFuel: number;
+    generatorFuelFlowRate: number;
+    airFilterUnitFlowRate: number;
+    gpuBoostRate: number;
+}

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

@@ -0,0 +1,11 @@
+export interface IHideoutSingleProductionStartRequestData {
+    Action: "HideoutSingleProductionStart";
+    recipeId: string;
+    items: Item[];
+    tools: Item[];
+    timestamp: number;
+}
+export interface Item {
+    id: string;
+    count: number;
+}

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

@@ -0,0 +1,6 @@
+export interface IHideoutTakeItemOutRequestData {
+    Action: "HideoutTakeItemsFromAreaSlots";
+    areaType: number;
+    slots: number[];
+    timestamp: number;
+}

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

@@ -0,0 +1,5 @@
+export interface IHideoutTakeProductionRequestData {
+    Action: "HideoutTakeProduction";
+    recipeId: string;
+    timestamp: number;
+}

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

@@ -0,0 +1,6 @@
+export interface IHideoutToggleAreaRequestData {
+    Action: "HideoutToggleArea";
+    areaType: number;
+    enabled: boolean;
+    timestamp: number;
+}

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

@@ -0,0 +1,5 @@
+export interface IHideoutUpgradeCompleteRequestData {
+    Action: "HideoutUpgradeComplete";
+    areaType: number;
+    timestamp: number;
+}

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

@@ -0,0 +1,10 @@
+export interface IHideoutUpgradeRequestData {
+    Action: "HideoutUpgrade";
+    areaType: number;
+    items: HideoutItem[];
+    timestamp: number;
+}
+export interface HideoutItem {
+    count: number;
+    id: string;
+}

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

@@ -0,0 +1,108 @@
+import { Effect } from "@spt/models/eft/health/Effect";
+import { BodyPart } from "@spt/models/eft/health/IOffraidHealRequestData";
+import { QteActivityType } from "@spt/models/enums/hideout/QteActivityType";
+import { QteEffectType } from "@spt/models/enums/hideout/QteEffectType";
+import { QteResultType } from "@spt/models/enums/hideout/QteResultType";
+import { QteRewardType } from "@spt/models/enums/hideout/QteRewardType";
+import { QteType } from "@spt/models/enums/hideout/QteType";
+import { RequirementType } from "@spt/models/enums/hideout/RequirementType";
+import { HideoutAreas } from "@spt/models/enums/HideoutAreas";
+import { SkillTypes } from "@spt/models/enums/SkillTypes";
+import { Traders } from "@spt/models/enums/Traders";
+export interface IQteData {
+    id: string;
+    type: QteActivityType;
+    area: HideoutAreas;
+    areaLevel: number;
+    quickTimeEvents: IQuickTimeEvent[];
+    requirements: (IAreaRequirement | IItemRequirement | ITraderUnlockRequirement | ITraderLoyaltyRequirement | ISkillRequirement | IResourceRequirement | IToolRequirement | IQuestRequirement | IHealthRequirement | IBodyPartBuffRequirement)[];
+    results: Record<QteEffectType, IQteResult>;
+}
+export interface IQuickTimeEvent {
+    type: QteType;
+    position: {
+        x: number;
+        y: number;
+    };
+    startDelay: number;
+    endDelay: number;
+    speed: number;
+    successRange: {
+        x: number;
+        y: number;
+    };
+    key: string;
+}
+export interface IQteRequirement {
+    type: RequirementType;
+}
+export interface IQteResult {
+    energy: number;
+    hydration: number;
+    rewardsRange: IQteEffect[];
+}
+export interface IQteEffect {
+    type: QteRewardType;
+    skillId: number;
+    levelMultipliers: ISkillLevelMultiplier[];
+    time: number;
+    weight: number;
+    result: QteResultType;
+}
+export interface ISkillLevelMultiplier {
+    level: number;
+    multiplier: number;
+}
+export interface IAreaRequirement extends IQteRequirement {
+    type: RequirementType.AREA;
+    areaType: HideoutAreas;
+    requiredLevel: number;
+}
+export interface ITraderUnlockRequirement extends IQteRequirement {
+    type: RequirementType.TRADER_UNLOCK;
+    traderId: Traders;
+}
+export interface ITraderLoyaltyRequirement extends IQteRequirement {
+    type: RequirementType.TRADER_LOYALTY;
+    traderId: Traders;
+    loyaltyLevel: number;
+}
+export interface ISkillRequirement extends IQteRequirement {
+    type: RequirementType.SKILL;
+    skillName: SkillTypes;
+    skillLevel: number;
+}
+export interface IResourceRequirement extends IQteRequirement {
+    type: RequirementType.RESOURCE;
+    templateId: string;
+    resource: number;
+}
+export interface IItemRequirement extends IQteRequirement {
+    type: RequirementType.ITEM;
+    templateId: string;
+    count: number;
+    isFunctional: boolean;
+    isEncoded: boolean;
+}
+export interface IToolRequirement extends IQteRequirement {
+    type: RequirementType.TOOL;
+    templateId: string;
+    count: number;
+    isFunctional: boolean;
+    isEncoded: boolean;
+}
+export interface IQuestRequirement extends IQteRequirement {
+    type: RequirementType.QUEST_COMPLETE;
+    questId: string;
+}
+export interface IHealthRequirement extends IQteRequirement {
+    type: RequirementType.HEALTH;
+    energy: number;
+    hydration: number;
+}
+export interface IBodyPartBuffRequirement extends IQteRequirement {
+    type: RequirementType.BODY_PART_BUFF;
+    effectName: Effect;
+    bodyPart: BodyPart;
+    excluded: boolean;
+}

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

@@ -0,0 +1,4 @@
+export interface IRecordShootingRangePoints {
+    Action: "RecordShootingRangePoints";
+    points: number;
+}

types/models/eft/httpResponse/IGetBodyResponseData.d.ts

@@ -0,0 +1,5 @@
+export interface IGetBodyResponseData<Type> {
+    err: number;
+    errmsg: any;
+    (data: Type): Type;
+}

types/models/eft/httpResponse/INullResponseData.d.ts

@@ -0,0 +1,5 @@
+export interface INullResponseData {
+    err: number;
+    errmsg: any;
+    data: undefined;
+}

types/models/eft/inRaid/IInsuredItemsData.d.ts

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

types/models/eft/inRaid/IItemDeliveryRequestData.d.ts

@@ -0,0 +1,5 @@
+import { Item } from "@spt/models/eft/common/tables/IItem";
+export interface IItemDeliveryRequestData {
+    items: Item[];
+    traderId: string;
+}

types/models/eft/inRaid/IRegisterPlayerRequestData.d.ts

@@ -0,0 +1,5 @@
+export interface IRegisterPlayerRequestData {
+    crc: number;
+    locationId: string;
+    variantId: number;
+}

types/models/eft/inRaid/ISaveProgressRequestData.d.ts

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