@falloutmp/types 0.1.0 → 0.2.1

package/generated/server-api.d.ts

@@ -1,4 +1,4 @@
-import type { EventHandler, MessageHandler, MessageReply, Quaternion, Unsubscribe, Vector3 } from "../shared.js";
+import type { EventHandler, MessageHandler, MessageReply, Unsubscribe } from "../shared.js";
 
 declare global {
   /**
@@ -30,6 +30,21 @@ declare global {
      */
     playerShoot: [player: Player];
 
+    /**
+     * Dispatched when a player's game launches a projectile: a missile, a grenade in flight, a flame, or one an NPC it simulates launched (`npc`). `projectile` is the BGSProjectile form ID. Return `false` to refuse: nobody else sees it. It still flies on the shooter's own screen.
+     */
+    playerProjectile: [player: Player, projectile: number, npc: Npc | null];
+
+    /**
+     * Dispatched when a player's game reports them in another worldspace or interior: through a door, a fast travel or `teleport`. `previous` is null for the first space they report after joining.
+     */
+    playerSpaceChange: [player: Player, space: PlayerSpace, previous: PlayerSpace | null];
+
+    /**
+     * Dispatched when a player's game reports a new look after the one they joined with: the look editor closed, or `setLook`, `randomizeLook` or `setAppearance` changed it. `getAppearance` reads it.
+     */
+    playerAppearanceChange: [player: Player];
+
     /**
      * Dispatched when a player's game lands a hit on another player, before the victim takes it. Return `false` to drop the hit. `damage` is the attacker's game's own. `kind` is a shot or a blow, an explosion's blast, or a hazard the attacker left (a radiation or gas cloud), which casts its spell and carries no damage figure.
      */
@@ -50,6 +65,16 @@ declare global {
      */
     playerPowerArmor: [player: Player, entered: boolean];
 
+    /**
+     * Dispatched when the charge of the fusion core in a player's power armor changes, in whole units: their game drains it (a jump, among others), a new core is loaded, or `setPowerArmorBattery` set it. Not on getting in.
+     */
+    playerPowerArmorBattery: [player: Player, charge: number, previous: number];
+
+    /**
+     * Dispatched when a player's game takes a fusion core into their power armor or launches it out. `consumed`: the suit's core ran out and their game loaded the next one they carry. `inserted`: a core went into the empty suit as it reached them. `ejected`: they launched the core out of the suit (Nuclear Physicist), `core` null. `condition` is the core's charge in percent. Return `false` to refuse a core taken in: it goes back to their inventory, the suit keeps the charge it had and takes no other core until `setPowerArmorBattery` gives it a charge or they get out. A launch cannot be refused.
+     */
+    playerFusionCore: [player: Player, kind: "consumed" | "inserted" | "ejected", core: number | null, condition: number];
+
     /**
      * Dispatched for a chat line, before anyone sees it. Return `false` to swallow it.
      */
@@ -60,6 +85,11 @@ declare global {
      */
     playerCommand: [player: Player, command: string, args: string[]];
 
+    /**
+     * Dispatched when the running clock reaches a new whole hour, 0 to 23. `World.setHour` does not raise it.
+     */
+    worldHourChange: [hour: number];
+
     /**
      * Dispatched when a player opens or closes a door. Return `false` to refuse: their door swings back.
      */
@@ -75,6 +105,16 @@ declare global {
      */
     containerOpen: [player: Player, ref: number];
 
+    /**
+     * Dispatched when the player holding a container closes its menu; anyone may open it again.
+     */
+    containerClose: [player: Player, ref: number];
+
+    /**
+     * Dispatched when a player's game reports what a container holds now, after they put something in or took something out. To refuse a transfer, refuse the player's `inventoryChange`, which reverts the container with it.
+     */
+    containerChange: [player: Player, ref: number, items: InventoryItem[]];
+
     /**
      * Dispatched when a player drops an item. Return `false` to refuse: the item leaves the world and goes back into their inventory.
      */
@@ -86,10 +126,45 @@ declare global {
     itemPickUp: [player: Player, item: Item | null, ref: number | null];
 
     /**
-     * Dispatched after the server accepted a change a player's game reported: looting, buying, crafting, using an item. Changes a script made itself do not raise it.
+     * Dispatched when a player's game reports a change the server would accept: looting, buying, crafting, using an item. Return `false` to refuse it: the server keeps its record and sends it back to their game, and any container involved keeps what it held. Changes a script made itself do not raise it.
      */
     inventoryChange: [player: Player, changes: InventoryDelta[]];
 
+    /**
+     * Dispatched once a player's character is established, shortly after they join: adopted from their game. Restore a kept character here with `setCharacter`. Character methods work from here.
+     */
+    playerCharacterLoad: [player: Player];
+
+    /**
+     * Dispatched when the player's game awards XP: a kill, a quest, a lock, a terminal, a workshop build. `amount` is the game's, Intelligence included. Return `false` to refuse it: their game takes it back.
+     */
+    playerXpGain: [player: Player, amount: number];
+
+    /**
+     * Dispatched when the character's level moves, by XP or by a script.
+     */
+    playerLevelChange: [player: Player, level: number, previous: number];
+
+    /**
+     * Dispatched when the player's game changes a perk rank: bought on the perk chart (after the server checked points, level, the rank below and SPECIAL), given by something in the game such as a magazine, or taken away. Return `false` to refuse it: their game undoes it.
+     */
+    playerPerkRequest: [player: Player, perk: number, kind: "buy" | "grant" | "remove"];
+
+    /**
+     * Dispatched when a perk rank was added to or taken from the character, by their game or by a script.
+     */
+    playerPerkChange: [player: Player, perk: number, added: boolean];
+
+    /**
+     * Dispatched when the player's game moves a SPECIAL base: the SPECIAL menu, a bobblehead, a book. `value` is its editor ID. Return `false` to refuse it: their game puts it back.
+     */
+    playerValueRequest: [player: Player, value: string, previous: number, base: number];
+
+    /**
+     * Dispatched when an actor value base on the character's record moved, by their game or by a script.
+     */
+    playerValueChange: [player: Player, value: string, base: number, previous: number];
+
     /**
      * Dispatched once a player's mine settles and is armed. Return `false` to refuse: it leaves the world unexploded.
      */
@@ -105,6 +180,51 @@ declare global {
      */
     mineRemove: [mine: Mine];
 
+    /**
+     * Dispatched when a player's game lands a hit on an NPC, before the NPC takes it. Return `false` to drop the hit. `damage` is the attacker's game's own; `kind` is a shot or a blow, or an explosion's blast.
+     */
+    npcHit: [attacker: Player, npc: Npc, damage: number, kind: "direct" | "blast"];
+
+    /**
+     * Dispatched when an NPC lands a hit on a player, before the victim takes it. Return `false` to drop the hit. `damage` is the game's own, from the client that runs the NPC.
+     */
+    npcAttack: [npc: Npc, victim: Player, damage: number, kind: "direct" | "blast"];
+
+    /**
+     * Dispatched once when an NPC dies. `killer` is the last player who hit it, or null. It comes back on its own a while later; `npcRespawn` follows.
+     */
+    npcDeath: [npc: Npc, killer: Player | null];
+
+    /**
+     * Dispatched when an NPC is back at its placement, whole: on its own after its death, or from `respawn`.
+     */
+    npcRespawn: [npc: Npc];
+
+    /**
+     * Dispatched when another player's game takes over running an NPC, or when nobody near does any more (`simulator` null) and the server walks it.
+     */
+    npcSimulatorChange: [npc: Npc, simulator: Player | null];
+
+    /**
+     * Dispatched when an NPC becomes a player's companion (`setLeader`), or follows nobody any more (`leader` null): let go, or its leader left.
+     */
+    npcLeaderChange: [npc: Npc, leader: Player | null];
+
+    /**
+     * Dispatched when a player builds an object in a settlement, before anyone else sees it. Return `false` to refuse: their game takes it back out. The recipe's components are theirs to have spent; the server cannot refund them.
+     */
+    workshopBuild: [player: Player, form: number, workbench: number, position: Vector3, angle: Vector3];
+
+    /**
+     * Dispatched when a player moves a built object, before anyone else sees it. Return `false` to refuse: the object is put back where it was for everyone, as a new `WorkshopItem`, and the old handle reads nothing.
+     */
+    workshopMove: [player: Player, item: WorkshopItem, position: Vector3, angle: Vector3];
+
+    /**
+     * Dispatched when a player scraps or stores a built object, before it goes for everyone. Return `false` to refuse: the object is put back for everyone, as a new `WorkshopItem`, and the old handle reads nothing. The player keeps what their game gave them for it.
+     */
+    workshopScrap: [player: Player, item: WorkshopItem];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -134,6 +254,27 @@ declare global {
   /** Names of native events available in this scripting environment. */
   type EventName = keyof EventMap;
 
+  /**
+   * The game this server runs, and the systems only some games have.
+   */
+  const Game: {
+    /**
+     * The game, as server.json's `mod.game` names it.
+     */
+    readonly id: "fo4" | "fo76";
+
+    /**
+     * The game's display name: "Fallout 4" or "Fallout 76".
+     */
+    readonly name: string;
+
+    /**
+     * Whether this game has the system. Settlements, companions, the perk chart and the SPECIAL creation menu are Fallout 4's; C.A.M.P., perk cards, teams and mutations are Fallout 76's. Every other binding exists on both.
+     * @param feature A system only some games have.
+     */
+    has(feature: "settlements" | "companions" | "perkChart" | "specialMenu" | "camp" | "perkCards" | "teams" | "mutations"): boolean;
+  };
+
   /**
    * Where a player is: the worldspace it stands in, or the interior cell, which has none.
    */
@@ -197,6 +338,16 @@ declare global {
      * The frame's TESFurniture form ID; null when the game created that record at runtime.
      */
     base: number | null;
+
+    /**
+     * The charge left in the inserted fusion core, in whole units rounded up; 0 when it is empty or there is none.
+     */
+    battery: number;
+
+    /**
+     * The inserted fusion core's capacity, 100 for the game's own; 0 while none was ever inserted.
+     */
+    batteryMax: number;
   }
 
   /**
@@ -212,6 +363,11 @@ declare global {
      * How many the player carries.
      */
     count: number;
+
+    /**
+     * The stack's condition in percent of full, 0 to 100: the charge a fusion core has left. 100 for an item that has none.
+     */
+    condition: number;
   }
 
   /**
@@ -230,9 +386,9 @@ declare global {
     readonly nickname: string;
 
     /**
-     * Current health, as the player's game last reported it.
+     * Current health, as the player's game last reported it. Assigning asks their game to move it there, as `setValue("Health", value)` does; it reads the new value once they report it.
      */
-    readonly health: number;
+    health: number;
 
     /**
      * Health at full.
@@ -310,7 +466,7 @@ declare global {
     readonly isInPowerArmor: boolean;
 
     /**
-     * Takes the player out of their power armor; the frame stays where they stand. `playerPowerArmor` follows.
+     * Takes the player out of their power armor; the frame stays where they stand. `playerPowerArmor` follows once their game is done, which it is not while they fly the fly camera (`NoClip`): the game leaves the player's own update alone until the camera comes back.
      * @returns True when sent; false when the player is gone or not in power armor.
      */
     exitPowerArmor(): boolean;
@@ -340,12 +496,13 @@ declare global {
     toString(): string;
 
     /**
-     * Moves the player within their current worldspace.
-     * @param position Where to, in the worldspace the player is in.
+     * Moves the player, within their space or into another one. Into an interior they land at a persistent reference inside it, as a quest script moves the player, and `position` is not used: wait for `playerSpaceChange`, then teleport them within it. `playerSpaceChange` follows any change of space.
+     * @param position Where to, in the space the player goes to.
      * @param heading Facing in radians; the current one when left out.
-     * @returns True when sent; false when the player is gone. Throws for a position that is not a finite Vector3.
+     * @param space Another worldspace or an interior cell, exactly one of the two; the one the player is in when left out.
+     * @returns True when sent; false when the player is gone, or the interior has no reference to land at. Throws for a position that is not a finite Vector3.
      */
-    teleport(position: Vector3, heading?: number): boolean;
+    teleport(position: Vector3, heading?: number, space?: { worldSpace?: number | string; interiorCell?: number | string }): boolean;
 
     /**
      * Brings a dead player back at full health. Nothing respawns a player on its own: call this from `playerDeath`, at once or later.
@@ -369,6 +526,13 @@ declare global {
      */
     enterPowerArmor(frame?: number | string): boolean;
 
+    /**
+     * Sets the charge of the fusion core in the player's power armor, through the value their game drains. At 0 their game does what it does with an empty core: it loads the next fusion core they carry, or leaves the suit unpowered. Above the core's capacity the capacity follows. It also lifts the hold a refused core left the suit in. `playerPowerArmorBattery` follows.
+     * @param charge The charge to leave in the core, 0 to 1000; a full fusion core holds 100.
+     * @returns True when sent; false when the player is gone or not in power armor.
+     */
+    setPowerArmorBattery(charge: number): boolean;
+
     /**
      * The power armor frame the player wears.
      * @returns The frame, or null when they wear none or are gone.
@@ -423,9 +587,29 @@ declare global {
      */
     randomizeLook(seed?: number, morphsOnly?: boolean): boolean;
 
+    /**
+     * The player's whole look as their game last reported it, as an opaque string to keep (a database column) and hand back to `setAppearance`.
+     * @returns Null before their first report or once they are gone.
+     */
+    getAppearance(): string | null;
+
+    /**
+     * Puts a whole look back on the player: their game rebuilds them and everyone sees it. Throws for a look from another server version.
+     * @param look As `getAppearance` returned it on this server version.
+     * @returns True when sent; false when the player is gone.
+     */
+    setAppearance(look: string): boolean;
+
+    /**
+     * Names the player's character in their own game, as the Vault 111 registration form does: what the game's menus show, and what the SPECIAL menu requires before it closes. Others see the nametag, not this.
+     * @param name 1 to 64 characters.
+     * @returns True when sent; false when the player is gone.
+     */
+    setGameName(name: string): boolean;
+
     /**
      * What the player carries, from the server's record.
-     * @returns One entry per stack; empty before the player's first report, shortly after they join, and once they are gone.
+     * @returns One entry per base object and condition; empty before the player's first report, shortly after they join, and once they are gone.
      */
     getInventory(): InventoryItem[];
 
@@ -440,20 +624,22 @@ declare global {
      * Puts items in the player's inventory. It does not equip them: see `equipItem`.
      * @param form The base object.
      * @param count How many, 1 to 1000000; one when left out.
+     * @param condition Their condition in percent of full, 0 to 100, as one stack: a fusion core's charge. Full when left out.
      * @returns True when the record changed; false before the player's first report or once they are gone.
      */
-    giveItem(form: number | string, count?: number): boolean;
+    giveItem(form: number | string, count?: number, condition?: number): boolean;
 
     /**
      * Takes items out of the player's inventory.
      * @param form The base object.
      * @param count How many, 1 to 1000000; one when left out. More than they carry takes them all.
+     * @param condition The condition to take first, 0 to 100; the rest come from the fullest stacks. Full when left out.
      * @returns True when the record changed; false before the player's first report or once they are gone.
      */
-    removeItem(form: number | string, count?: number): boolean;
+    removeItem(form: number | string, count?: number, condition?: number): boolean;
 
     /**
-     * Sets how many of an item the player carries.
+     * Sets how many of an item the player carries, over every condition: more are added at full condition, fewer are taken from full stacks first.
      * @param form The base object.
      * @param count How many the player should carry, 0 to 1000000.
      * @returns True when the record changed; false before the player's first report or once they are gone.
@@ -474,6 +660,205 @@ declare global {
      */
     playIdle(idle: string | number): boolean;
 
+    /**
+     * An actor value as it stands: Health, ActionPoints and Rads as the player's game last reported them, any other the base the record holds.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @returns The value; null before the character is established or for a value the record does not hold.
+     */
+    getValue(value: string | number): number | null;
+
+    /**
+     * The base the character's record holds for an actor value: SPECIAL, Experience, and any base a script set.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @returns The base; null for one the record does not hold.
+     */
+    getBaseValue(value: string | number): number | null;
+
+    /**
+     * Sets an actor value's base on the record and in the player's game, as `ObjectReference.SetValue` does: for Health or CarryWeight that is the maximum. It is saved with the character and set again whenever they join.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @param base The new base. SPECIAL is rounded and kept within 1 to 11.
+     * @returns True when the record changed; false before the character is established.
+     */
+    setBaseValue(value: string | number, base: number): boolean;
+
+    /**
+     * Lowers an actor value's current value in the player's game, as `ObjectReference.DamageValue` does. Health damaged to 0 kills.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @param amount How much, at least 0. Rads rise by it.
+     * @returns True when sent; false when the player is gone.
+     */
+    damageValue(value: string | number, amount: number): boolean;
+
+    /**
+     * Raises an actor value's current value in the player's game up to its maximum, as `ObjectReference.RestoreValue` does.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @param amount How much, at least 0. Rads fall by it.
+     * @returns True when sent; false when the player is gone.
+     */
+    restoreValue(value: string | number, amount: number): boolean;
+
+    /**
+     * Moves an actor value's current value in the player's game, keeping its base.
+     * @param value An actor value: its editor ID, such as `"Strength"` or `"Health"`, or its form ID.
+     * @param current The current value to reach; no higher than the maximum.
+     * @returns True when sent; false when the player is gone.
+     */
+    setValue(value: string | number, current: number): boolean;
+
+    /**
+     * The character's level.
+     * @returns The level; 0 when the player is gone.
+     */
+    getLevel(): number;
+
+    /**
+     * Sets the character's level and their XP to the start of it. No perk points come with it: see `setPerkPoints`.
+     * @param level 1 to 65535.
+     * @returns True when the record changed; false before the character is established.
+     */
+    setLevel(level: number): boolean;
+
+    /**
+     * The character's total experience.
+     * @returns The XP; 0 when the player is gone.
+     */
+    getXp(): number;
+
+    /**
+     * Sets the character's total experience, and their level to match. No perk points come with it.
+     * @param xp The total, at least 0.
+     * @returns True when the record changed; false before the character is established.
+     */
+    setXp(xp: number): boolean;
+
+    /**
+     * Awards experience as the game does: each level it reaches brings a perk point and the game's level-up.
+     * @param amount More than 0. Not scaled by Intelligence.
+     * @returns True when the record changed; false before the character is established.
+     */
+    addXp(amount: number): boolean;
+
+    /**
+     * The character's unspent perk points.
+     * @returns The points; 0 when the player is gone.
+     */
+    getPerkPoints(): number;
+
+    /**
+     * Sets the character's unspent perk points.
+     * @param points 0 to 255.
+     * @returns True when the record changed; false before the character is established.
+     */
+    setPerkPoints(points: number): boolean;
+
+    /**
+     * The perk ranks the character holds. Each rank of a perk is a BGSPerk of its own.
+     * @returns Their form IDs; empty when the player is gone.
+     */
+    getPerks(): number[];
+
+    /**
+     * Whether the character holds a perk rank.
+     * @param perk A BGSPerk rank.
+     * @returns True when they hold it. Throws for a form ID that is no perk.
+     */
+    hasPerk(perk: number | string): boolean;
+
+    /**
+     * Gives the character a perk rank without spending a point.
+     * @param perk A BGSPerk rank.
+     * @param withLowerRanks Also give the ranks below it; true when left out.
+     * @returns True when the record changed; false before the character is established. Throws for a form ID that is no perk.
+     */
+    addPerk(perk: number | string, withLowerRanks?: boolean): boolean;
+
+    /**
+     * Takes a perk rank from the character, and every rank above it. No point is refunded.
+     * @param perk A BGSPerk rank.
+     * @returns True when the record changed; false when they do not hold it.
+     */
+    removePerk(perk: number | string): boolean;
+
+    /**
+     * The bottle caps the player carries: the Caps001 item in the inventory record.
+     * @returns The count; 0 before the first inventory report or once they are gone.
+     */
+    getCaps(): number;
+
+    /**
+     * Sets the bottle caps the player carries.
+     * @param caps 0 to 1000000.
+     * @returns True when the record changed; false before the first inventory report.
+     */
+    setCaps(caps: number): boolean;
+
+    /**
+     * Opens the game's SPECIAL allocation menu on the player's screen, as the Vault 111 exit does. Each point they move comes back as `playerValueRequest`.
+     * @returns True when sent; false when the player is gone.
+     */
+    openSpecialMenu(): boolean;
+
+    /**
+     * Opens the game's perk chart on the player's screen. Each rank bought comes back as `playerPerkRequest`.
+     * @returns True when sent; false when the player is gone.
+     */
+    openPerkChart(): boolean;
+
+    /**
+     * The whole character: experience, level, perk points, bases, perks, current values and inventory. Keep it wherever the gamemode likes; `setCharacter` takes it back.
+     * @returns The document; null before the character is established.
+     */
+    getCharacter(): CharacterDocument | null;
+
+    /**
+     * Replaces the character with a document, and brings the player's game to it.
+     * @param character As `getCharacter` returns it. What it leaves out stays as it is.
+     * @returns True when applied; false before the character is established. Throws for a malformed document.
+     */
+    setCharacter(character: Partial<CharacterDocument>): boolean;
+
+    /**
+     * The total experience a level starts at, by the game's formula.
+     * @param level 1 to 65535.
+     * @returns The XP.
+     */
+    static xpForLevel(level: number): number;
+
+    /**
+     * The factions the server put the player in, each with its rank. The factions their character holds from the game's own data, such as PlayerFaction, are not listed.
+     * @returns One entry per faction, in the order they were joined; empty when the player is gone.
+     */
+    getFactions(): { faction: number; rank: number }[];
+
+    /**
+     * The player's rank in a faction the server put them in.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @returns The rank; null when the server did not put them in it.
+     */
+    getFactionRank(faction: number | string): number | null;
+
+    /**
+     * Puts the player in a faction at a rank, or re-ranks them, as `Actor.SetFactionRank` does: their own game and every other player's give their character the membership, so the game's hostility follows it. NPCs of the faction and its allies treat them as one of their own; its enemies attack them. Up to 16 factions per player; whether a player's hits on another land stays `playerHit`'s say.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @param rank 0 to 127; 0 when left out.
+     * @returns True when set; false when the player is gone or already in 16 factions.
+     */
+    setFactionRank(faction: number | string, rank?: number): boolean;
+
+    /**
+     * Takes the player out of a faction the server put them in, as `Actor.RemoveFromFaction` does.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @returns True when they were in it; false otherwise or when the player is gone.
+     */
+    removeFromFaction(faction: number | string): boolean;
+
+    /**
+     * Takes the player out of every faction the server put them in. The factions their character holds from the game's own data stay.
+     * @returns True when sent; false when the player is gone.
+     */
+    removeFromAllFactions(): boolean;
+
     /**
      * Every connected player.
      * @returns One handle per player, in no particular order.
@@ -661,12 +1046,99 @@ declare global {
      */
     delta: number;
 
+    /**
+     * The stack's condition in percent of full, 0 to 100: the charge a fusion core has left. 100 for an item that has none.
+     */
+    condition: number;
+
     /**
      * The reference on the other side, such as a container; null for none the game named.
      */
     from: number | null;
   }
 
+  /**
+   * A whole character, as getCharacter gives it and setCharacter takes it. Actor values are keyed by editor ID; forms are hex strings.
+   */
+  interface CharacterDocument {
+    /**
+     * The document's format, 1.
+     */
+    version: number;
+
+    /**
+     * The nickname of the player it was taken from.
+     */
+    nickname: string;
+
+    /**
+     * Total XP.
+     */
+    experience: number;
+
+    /**
+     * The level.
+     */
+    level: number;
+
+    /**
+     * Unspent perk points.
+     */
+    perkPoints: number;
+
+    /**
+     * Actor value bases: SPECIAL and any a script set.
+     */
+    values: Record<string, number>;
+
+    /**
+     * The BGSPerk ranks held.
+     */
+    perks: string[];
+
+    /**
+     * Health, ActionPoints and Rads as they stood.
+     */
+    current: Record<string, number>;
+
+    /**
+     * What the character carries.
+     */
+    inventory: { form: string; count: number }[];
+  }
+
+  /**
+   * How the game's factions react to each other, on every client. Combined with `Player.setFactionRank` it decides who the game treats as friend or foe: NPCs, turrets and companions alike.
+   */
+  const Faction: {
+    /**
+     * How one faction reacts to another, where the server overrides it.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @param other The faction it reacts to, as a number or hex string.
+     * @returns The reaction; null when the game's data files decide.
+     */
+    getReaction(faction: number | string, other: number | string): "neutral" | "enemy" | "ally" | "friend" | null;
+
+    /**
+     * Overrides how one faction reacts to another on every client, as `Faction.SetAlly` and `Faction.SetEnemy` do, until it is cleared or the server stops. A faction can be its own enemy. Up to 64 directions are overridden at once.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @param other The faction it reacts to, as a number or hex string.
+     * @param reaction Enemies fight on sight; allies and friends help each other, friends also in combat.
+     * @param mutual Both directions, as `Faction.SetAlly` and `Faction.SetEnemy` do; true when left out.
+     * @returns True when set; false when the table is full.
+     */
+    setReaction(faction: number | string, other: number | string, reaction: "neutral" | "enemy" | "ally" | "friend", mutual?: boolean): boolean;
+
+    /**
+     * Gives a reaction back to the game's data files on every client.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @param other The faction it reacts to, as a number or hex string.
+     * @param mutual Both directions, as `Faction.SetAlly` and `Faction.SetEnemy` do; true when left out.
+     * @returns True when one was overridden.
+     */
+    clearReaction(faction: number | string, other: number | string, mutual?: boolean): boolean;
+  };
+
   /**
    * An armed mine a player laid. Its owner's game holds the mine and sets it off; the server decides when. Once it goes off or is removed the handle reads nothing. Mines go with their owner when they leave.
    */
@@ -810,6 +1282,191 @@ declare global {
 
   interface RadioStation extends Entity {}
 
+  /**
+   * A non-player actor the server took over from the data files: the generic placed ones, not the unique, essential or quest actors, which stay each client's own. A client near it runs it with the game's own AI and reports its health; nobody near, the server walks it. It lives for the whole session and comes back on its own a while after it dies. Move it with `teleport`, not by setting `position`.
+   */
+  class Npc {
+    /**
+     * Wraps an existing NPC with this ID; it spawns nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * The form ID of the placed reference (ACHR) it stands for.
+     */
+    readonly ref: number;
+
+    /**
+     * The TESNPC every client builds it from; the server rolled any leveled list.
+     */
+    readonly form: number;
+
+    /**
+     * Current health, as its simulator last measured it. 0 until a client has run it: the server cannot work it out from the records.
+     */
+    readonly health: number;
+
+    /**
+     * Health at full; 0 until a client has run it.
+     */
+    readonly maxHealth: number;
+
+    /**
+     * Whether it is dead.
+     */
+    readonly isDead: boolean;
+
+    /**
+     * Facing, in radians around Z.
+     */
+    readonly heading: number;
+
+    /**
+     * Kills it through the path a hit takes; `npcDeath` follows with a null killer. One no client has run yet dies when the next one takes it on.
+     * @returns True when sent; false when it is already dead.
+     */
+    kill(): boolean;
+
+    /**
+     * Puts it back at its placement, whole, dead or alive; `npcRespawn` follows.
+     * @returns True when done.
+     */
+    respawn(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The NPC's network ID, reference and form.
+     */
+    toString(): string;
+
+    /**
+     * Where the NPC is.
+     * @returns The worldspace or interior cell.
+     */
+    getSpace(): PlayerSpace | null;
+
+    /**
+     * The player whose game runs the NPC.
+     * @returns Null while nobody near does and the server walks it.
+     */
+    getSimulator(): Player | null;
+
+    /**
+     * The player the NPC follows as a companion.
+     * @returns Null when it follows nobody.
+     */
+    getLeader(): Player | null;
+
+    /**
+     * Makes the NPC a player's companion, as the game's own Followers quest makes one: the leader's game runs it with the follow packages, command mode and trading of a vanilla companion, and every other player sees it follow. It is taken along when its leader goes to another space or far off, and let go when the leader leaves; `npcLeaderChange` follows.
+     * @param player Who it follows; null lets it go.
+     * @returns True when done; false for a dead NPC or a player who is gone. Throws for anything but a Player or null.
+     */
+    setLeader(player: Player | null): boolean;
+
+    /**
+     * Hits the NPC from nobody, as a shot would; `npcHit` is not raised.
+     * @param amount Health to take, above 0.
+     * @returns True when sent; false when it is dead.
+     */
+    damage(amount: number): boolean;
+
+    /**
+     * Moves the NPC within its space. Left alone, it wanders back toward its placement over time.
+     * @param position Where to, in the NPC's own space.
+     * @param heading Facing in radians; the current one when left out.
+     * @returns True when done. Throws for a position that is not a finite Vector3.
+     */
+    teleport(position: Vector3, heading?: number): boolean;
+
+    /**
+     * Every NPC the server took over.
+     * @returns One handle per NPC; empty when the server could not read the game's data files.
+     */
+    static all(): Npc[];
+
+    /**
+     * Looks an NPC up by network ID.
+     * @param id Network entity identifier.
+     * @returns The handle, or null when no NPC has that ID.
+     */
+    static getById(id: number): Npc | null;
+
+    /**
+     * Looks an NPC up by the placed reference it stands for.
+     * @param ref The placed reference's form ID.
+     * @returns The handle, or null when the server did not take that reference over.
+     */
+    static getByRef(ref: number | string): Npc | null;
+  }
+
+  interface Npc extends Entity {}
+
+  /**
+   * An object built in a settlement, by a player or a script, linked to a workbench the data files place. It lasts the whole session, whoever built it, until a player scraps or stores it or a script destroys it. Setting `position` or `angle` moves it for everyone.
+   */
+  class WorkshopItem {
+    /**
+     * Wraps an existing built object with this ID; it builds nothing. See `WorkshopItem.place`.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * The base object's form ID; 0 once it is gone.
+     */
+    readonly form: number;
+
+    /**
+     * The workbench reference it belongs to; 0 once it is gone.
+     */
+    readonly workbench: number;
+
+    /**
+     * Its rotation, radians, as the game stores it. Assigning turns it for everyone.
+     */
+    angle: Vector3;
+
+    /**
+     * Takes the object out of the settlement for everyone; nobody gets its components back.
+     * @returns True when it was there to take.
+     */
+    destroy(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The object's network ID, form and workbench.
+     */
+    toString(): string;
+
+    /**
+     * Where the object stands.
+     * @returns The worldspace or interior cell, or null once it is gone.
+     */
+    getSpace(): PlayerSpace | null;
+
+    /**
+     * Builds an object for everyone, as if a player had at that workbench. Nothing is checked: not the recipe, its cost nor the buildable area.
+     * @param form The base object to build.
+     * @param workbench The workbench reference it belongs to, placed by the data files.
+     * @param position Where it stands.
+     * @param space The worldspace, or the interior cell: exactly one of the two.
+     * @param angle Its rotation, radians.
+     * @returns The object, or null when it could not be created.
+     */
+    static place(form: number | string, workbench: number | string, position: Vector3, space: { worldSpace?: number | string; interiorCell?: number | string }, angle?: Vector3): WorkshopItem | null;
+
+    /**
+     * Every object built this session.
+     * @param workbench Only the objects of this workbench.
+     * @returns One handle per object.
+     */
+    static all(workbench?: number | string): WorkshopItem[];
+  }
+
+  interface WorkshopItem extends Entity {}
+
   /**
    * Node.js timer handle returned by setTimeout and setInterval.
    */