@falloutmp/types 0.2.5 → 0.3.2

package/generated/server-api.d.ts

@@ -46,15 +46,25 @@ declare global {
     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.
+     * 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, a hazard the attacker left (a radiation or gas cloud), which casts its spell and carries no damage figure, or a shot of a VATS attack, whose hit the attacker's game rolled against the chance it showed: refusing one decides VATS hits on the server (their chances are the game's fVATS* settings, `setGameSetting`). `vatsChance` is the chance the attacker's VATS showed for the shot, 0 to 1, and 0 for any other kind; with `setVatsRolledByServer` every such shot strikes on the attacker's screen, and the handler rolls it, as `Math.random() < vatsChance`.
      */
-    playerHit: [attacker: Player, victim: Player, damage: number, kind: "direct" | "blast" | "hazard"];
+    playerHit: [attacker: Player, victim: Player, damage: number, kind: "direct" | "blast" | "hazard" | "vats", vatsChance: number];
+
+    /**
+     * Dispatched when a player activates another player's body, the Activate button on them: where a trade, a search, a handover or any player-to-player interaction starts. The two stand within reach in the same space.
+     */
+    playerActivatePlayer: [player: Player, target: Player];
 
     /**
      * Dispatched when a player starts a reload, before it is shown to the players around them. `event` is the animation event their game played.
      */
     playerReload: [player: Player, event: string];
 
+    /**
+     * Dispatched when a player swings a melee weapon or their fists, before it is shown to the players around them. `event` is the animation event their game took, `meleeattackStart` among others.
+     */
+    playerAttack: [player: Player, event: string];
+
     /**
      * Dispatched when a player's game sets off an explosion: a grenade, a mine, a missile, an explosive round, or one an NPC it simulates set off (`npc`, its network ID). `explosion` is the BGSExplosion form ID. Return `false` to refuse it: nobody else sees it and its blast lands on no one.
      */
@@ -90,6 +100,21 @@ declare global {
      */
     worldHourChange: [hour: number];
 
+    /**
+     * Dispatched when the server strikes lightning on its own, for a thundery weather a sky is held to: the World's, or one a player was given. `World.strikeLightning` does not raise it.
+     */
+    worldLightning: [weather: number];
+
+    /**
+     * Dispatched when a player's game finds them under another weather region, as they change cell: `region` is the TESRegion form ID, 0 for none. Its weathers come from `World.getRegionWeathers`.
+     */
+    playerWeatherRegionChange: [player: Player, region: number, previous: number];
+
+    /**
+     * Dispatched when the running clock passes midnight into a new day, with the new date and day count. `World.setDate` and `World.setDaysPassed` do not raise it.
+     */
+    worldDayChange: [date: WorldDate, daysPassed: number];
+
     /**
      * Dispatched when a player opens or closes a door. Return `false` to refuse: their door swings back.
      */
@@ -165,6 +190,166 @@ declare global {
      */
     playerValueChange: [player: Player, value: string, base: number, previous: number];
 
+    /**
+     * Dispatched when a player comes into a zone `Zone.create` made, or is in it when it is made.
+     */
+    zoneEnter: [player: Player, zone: number, name: string];
+
+    /**
+     * Dispatched when a player goes out of a zone, or the zone is removed around them. A player who leaves the server is not told.
+     */
+    zoneLeave: [player: Player, zone: number, name: string];
+
+    /**
+     * Dispatched when a player's game is about to fast travel: a marker picked on the Pip-Boy map, or the game's own scripts. `destination` is the reference they would arrive at, a map marker's form ID. Their game waits for the answer. Return `false` to refuse it: they stay where they are. Otherwise they travel.
+     */
+    playerFastTravel: [player: Player, destination: number];
+
+    /**
+     * Dispatched when a player's game moves them into another named location (a BGSLocation form ID), or out into the open (null). `previous` is null for the first one they report after joining.
+     */
+    playerLocationChange: [player: Player, location: number | null, previous: number | null];
+
+    /**
+     * Dispatched when a player drops their own marker on the Pip-Boy map, or removes it (`position` null). Return `false` to refuse it: their game puts back what they had.
+     */
+    playerMapWaypoint: [player: Player, position: Vector3 | null];
+
+    /**
+     * Dispatched when a player hacks a terminal: the password was found. `terminal` is the terminal reference's form ID. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerTerminalHack: [player: Player, terminal: number | null];
+
+    /**
+     * Dispatched when a player picks a lock in the lockpicking minigame. `lockChange` follows with the reference. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerLockPick: [player: Player];
+
+    /**
+     * Dispatched when a player makes something at a workbench: cooking, chemistry, or a weapon or armor mod. `workbench` is the bench's base furniture, `recipe` the constructible object used, `item` what it makes and `count` how many, as the recipe says. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerCraft: [player: Player, workbench: number | null, recipe: number | null, item: number | null, count: number];
+
+    /**
+     * Dispatched when a player takes something from a container. `container` is the container reference's form ID. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerContainerLoot: [player: Player, container: number | null];
+
+    /**
+     * Dispatched when a player reads a book or magazine, the TESObjectBOOK form ID. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerBookRead: [player: Player, book: number | null];
+
+    /**
+     * Dispatched when a player takes an item by pickpocketing. `victim` is the actor robbed. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerPickpocket: [player: Player, victim: number | null, success: boolean];
+
+    /**
+     * Dispatched when a player disarms a mine. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerMineDisarm: [player: Player];
+
+    /**
+     * Dispatched when a player passes a speech challenge in a dialogue. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerSpeechChallenge: [player: Player];
+
+    /**
+     * Dispatched when a player's game counts a theft: items taken that belong to someone else. `count` is how many. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerSteal: [player: Player, count: number];
+
+    /**
+     * Dispatched when a player becomes addicted. `item` is the chem or drink that did it. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerAddicted: [player: Player, item: number | null];
+
+    /**
+     * Dispatched when a player is caught trespassing by the game's own crime system. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerTrespass: [player: Player];
+
+    /**
+     * Dispatched when the game's crime system records an assault by a player on one of its NPCs. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerAssault: [player: Player];
+
+    /**
+     * Dispatched when the game's crime system records a murder by a player. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerMurder: [player: Player];
+
+    /**
+     * Dispatched when the game marks the location a player is in as cleared; `Player.getLocation` names it. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerLocationCleared: [player: Player];
+
+    /**
+     * Dispatched when a player lands a sneak attack (`critical` false) or a critical hit (true) on an actor, as their HUD says it. `weapon` is the weapon's form ID, null for bare hands. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerCriticalHit: [player: Player, weapon: number | null, critical: boolean];
+
+    /**
+     * Dispatched when a player discovers a location by coming up to it. `marker` is the map marker reference, the one `Player.discoverLocations` takes; what a script reveals that way is not reported. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerLocationDiscover: [player: Player, marker: number | null];
+
+    /**
+     * Dispatched when a fusion core runs out in a player's game: their power armor's, or the last shot of one they fired. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerFusionCoreConsume: [player: Player];
+
+    /**
+     * Dispatched when a fusion core is ejected from power armor in a player's game. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerFusionCoreEject: [player: Player];
+
+    /**
+     * Dispatched when junk enters a player's inventory, picked up or given, with the count their game adds to its junk collected stat. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerJunkFound: [player: Player, count: number];
+
+    /**
+     * Dispatched when a player's holotape starts, pauses, resumes or stops: `holotape` is the tape's form ID and `playing` whether it runs now. A tape that plays a recording; one that opens a terminal or a game is not reported. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerHolotape: [player: Player, holotape: number | null, playing: boolean];
+
+    /**
+     * Dispatched when a player kills a sleeping actor with the Mister Sandman kill. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerSandmanKill: [player: Player];
+
+    /**
+     * Dispatched when a player feeds on a corpse, as the Cannibal perk lets them. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerCorpseEat: [player: Player];
+
+    /**
+     * Dispatched when a player invests caps in one of the game's vendors. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerInvest: [player: Player];
+
+    /**
+     * Dispatched when a shot at a player bounces back and kills the shooter, the Ricochet perk's doing. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerRicochet: [player: Player];
+
+    /**
+     * Dispatched when the Mysterious Stranger turns up for a player in VATS. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerMysteriousStranger: [player: Player];
+
+    /**
+     * Dispatched when a player knocks the weapon out of an actor's hands. `target` is the actor disarmed. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerDisarm: [player: Player, target: number | null];
+
+    /**
+     * Dispatched when a player collects a bobblehead. Reported by the player's game after the fact: it cannot be refused, and the form IDs are the client's word.
+     */
+    playerBobblehead: [player: Player];
+
     /**
      * Dispatched once a player's mine settles and is armed. Return `false` to refuse: it leaves the world unexploded.
      */
@@ -181,9 +366,9 @@ 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.
+     * Dispatched when a player's game lands a hit on an NPC, before the NPC takes it. Return `false` to drop the hit, except on an NPC the attacker's own game runs (`getSimulator`), which took it already: that one is told so scripts learn who hit it, and the attacker is still the killer `npcDeath` names. `damage` is the attacker's game's own; `kind` is a shot or a blow, an explosion's blast, or a shot of a VATS attack, whose hit the attacker's game rolled against the chance it showed: refusing one decides VATS hits on the server. `vatsChance` is the chance the attacker's VATS showed, 0 to 1, and 0 for any other kind, as for `playerHit`.
      */
-    npcHit: [attacker: Player, npc: Npc, damage: number, kind: "direct" | "blast"];
+    npcHit: [attacker: Player, npc: Npc, damage: number, kind: "direct" | "blast" | "vats", vatsChance: number];
 
     /**
      * 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.
@@ -195,6 +380,21 @@ declare global {
      */
     npcDeath: [npc: Npc, killer: Player | null];
 
+    /**
+     * Dispatched when a player activates an NPC, the Activate button on its body: what a shopkeeper, a quest giver or any interaction starts from. Raised whether or not `setActivationBlocked` stops the game's own greeting and dialogue.
+     */
+    npcActivate: [player: Player, npc: Npc];
+
+    /**
+     * Dispatched when the player or NPC an NPC fights changes, as the game that runs it decides: it noticed an enemy, switched to another, or stopped fighting (`target` null, also on its death). Where aggro, bounties and wanted levels start.
+     */
+    npcTarget: [npc: Npc, target: Player | Npc | null];
+
+    /**
+     * Dispatched once when an NPC reaches where `goTo` sent it; it then stands there until `stopGoing` or the next `goTo`. Sent after a body, it is raised again each time it catches up after the body walked off.
+     */
+    npcArrive: [npc: Npc];
+
     /**
      * Dispatched when an NPC is back at its placement, whole: on its own after its death, or from `respawn`.
      */
@@ -220,6 +420,16 @@ declare global {
      */
     workshopMove: [player: Player, item: WorkshopItem, position: Vector3, angle: Vector3];
 
+    /**
+     * Dispatched when a player enters workshop mode at a workbench, the workbench reference's form ID.
+     */
+    workshopEnter: [player: Player, workbench: number];
+
+    /**
+     * Dispatched when a player leaves workshop mode, or enters it at another workbench.
+     */
+    workshopLeave: [player: Player, workbench: number];
+
     /**
      * 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.
      */
@@ -246,34 +456,28 @@ declare global {
     consoleCommand: [command: string, args: string[]];
 
     /**
-     * Dispatched when a player asks to join, before the connection exists: they hold no player slot, are not counted as online, and are sent nothing -- no resource list, no download, no body. The request waits until every handler has returned and every Promise a handler returned has settled, then it is let in if a player slot is free (otherwise it is refused as full). `connection.reject()` turns it away instead, and so does a handler that throws or rejects, or handlers that have not settled within the server's admission timeout (30 seconds by default, restarted by every `connection.update()`). With no handler at all, every request is let in at once.
+     * Dispatched when a player starts speaking, as isPlayerTalking turns true.
      */
-    playerConnecting: [connection: PendingConnection];
-  }
-
-  /** Names of native events available in this scripting environment. */
-  type EventName = keyof EventMap;
+    playerVoiceStart: [player: Player];
 
-  /**
-   * The game this server runs, and the systems only some games have.
-   */
-  const Game: {
     /**
-     * The game, as server.json's `mod.game` names it.
+     * Dispatched shortly after a player's last voice frame, as isPlayerTalking turns false. A player who disconnects while talking gets no stop, so clear them on disconnect too.
      */
-    readonly id: "fo4" | "fo76";
+    playerVoiceStop: [player: Player];
 
     /**
-     * The game's display name: "Fallout 4" or "Fallout 76".
+     * Dispatched when a player switches voice tier themselves: 0 whisper, 1 normal, 2 shout. setPlayerTier does not raise it.
      */
-    readonly name: string;
+    playerVoiceTierChange: [player: Player, tier: number];
 
     /**
-     * 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.
+     * Dispatched when a player asks to join, before the connection exists: they hold no player slot, are not counted as online, and are sent nothing -- no resource list, no download, no body. The request waits until every handler has returned and every Promise a handler returned has settled, then it is let in if a player slot is free (otherwise it is refused as full). `connection.reject()` turns it away instead, and so does a handler that throws or rejects, or handlers that have not settled within the server's admission timeout (30 seconds by default, restarted by every `connection.update()`). With no handler at all, every request is let in at once.
      */
-    has(feature: "settlements" | "companions" | "perkChart" | "specialMenu" | "camp" | "perkCards" | "teams" | "mutations"): boolean;
-  };
+    playerConnecting: [connection: PendingConnection];
+  }
+
+  /** Names of native events available in this scripting environment. */
+  type EventName = keyof EventMap;
 
   /**
    * Where a player is: the worldspace it stands in, or the interior cell, which has none.
@@ -400,6 +604,21 @@ declare global {
      */
     readonly armor: number;
 
+    /**
+     * Whether `setInvulnerable` made the player unhurtable.
+     */
+    readonly isInvulnerable: boolean;
+
+    /**
+     * Whether the player is knocked down, alive: in their ragdoll or getting up, after a blast or a client script's `LocalPlayer.knockDown`.
+     */
+    readonly isKnockedDown: boolean;
+
+    /**
+     * Whether the player is in the game's bleedout: down on the ground and alive, where a client script put them with `LocalPlayer.setBleedingOut`.
+     */
+    readonly isBleedingOut: boolean;
+
     /**
      * Whether the player is dead. A dead player stays down until `respawn`.
      */
@@ -520,6 +739,34 @@ declare global {
      */
     fire(shots?: number): boolean;
 
+    /**
+     * Holds the player's weapon out or away, as FiveM's SetCurrentPedWeapon forces a ped's: their game draws or holsters it at once and keeps it so against their own ready-weapon key and the game's. Away for a safe zone, out for a scripted scene. With no weapon in hand, out raises their fists. To stop attacks too, a client script turns off `Controls` "fighting".
+     * @param drawn True to hold their weapon out, false to keep it away, null to hand it back to them.
+     * @returns True when sent; false when the player is gone.
+     */
+    setWeaponDrawn(drawn: boolean | null): boolean;
+
+    /**
+     * Loads rounds into the player's weapon, as FiveM's SetAmmoInClip does a ped's. The rounds come from those they carry, as a reload takes them: never more than they have, so `giveItem` the ammo first. Their game ignores it without a weapon that loads ammo in hand.
+     * @param rounds The rounds to load, 0 to 100000; more than the weapon's clip loads a full clip.
+     * @returns True when sent; false when the player is gone.
+     */
+    setClipAmmo(rounds: number): boolean;
+
+    /**
+     * Takes the player's collision away or gives it back, as FiveM's SetEntityCollision does a ped and the console's tcl the player: without it they move along where they look, through walls and floors, without gravity. An admin's noclip on foot; everyone else sees their body pass through. It ends with their session.
+     * @param enabled False to take their collision away, true to give it back.
+     * @returns True when sent; false when the player is gone.
+     */
+    setCollision(enabled: boolean): boolean;
+
+    /**
+     * Rebuilds the player on another race, as the console's setrace and Actor.SetRace do: a ghoul. Their skin and body become the race's, their head parts stay their own, and every other player sees their puppet rebuilt the same way. Only human and ghoul are supported; any other race is refused. The race they had comes back with null, and when their session ends.
+     * @param race 0x13746 (HumanRace) or 0xEAFB6 (GhoulRace); null for the race they had.
+     * @returns True when sent; false when the player is gone.
+     */
+    setRace(race: number | string | null): boolean;
+
     /**
      * Places a power armor frame where the player stands and puts them into it at once, as `Actor.SwitchToPowerArmor` does. `playerPowerArmor` follows. The suit's pieces are the frame's; dress them with `setOutfit`.
      * @param frame The TESFurniture of the frame to place; the game's empty frame when left out.
@@ -654,6 +901,63 @@ declare global {
      */
     equipItem(form: number | string): boolean;
 
+    /**
+     * How long the player has neither moved nor turned their view, in seconds, as the server measures it from what their game reports: what an AFK check reads.
+     * @returns 0 for one who is moving or looking around, or who is gone.
+     */
+    getIdleTime(): number;
+
+    /**
+     * Has the player put a weapon away for good or take an armor piece off: they keep carrying it.
+     * @param form A weapon or armor piece the player carries.
+     * @returns True when sent; false when the server's record has none of it or the player is gone.
+     */
+    unequipItem(form: number | string): boolean;
+
+    /**
+     * Makes the player unhurtable, as FiveM's SetPlayerInvincible does: their game makes them a ghost, which shots, blows and explosions pass over, and turns on the game's immortal mode, so a fall or radiation never takes their last point of health; the server drops every hit still reported on them, from players and NPCs, before `playerHit` or `npcAttack`. It lasts until undone or they leave.
+     * @param invulnerable True to make them unhurtable, false to make them hurtable again.
+     * @returns True when sent; false when the player is gone.
+     */
+    setInvulnerable(invulnerable: boolean): boolean;
+
+    /**
+     * Has the player's character speak, voice and subtitle, as FiveM's PlayAmbientSpeechNative does a player's ped: their own game says it, picking a topic's line among those whose conditions pass, and every other player's game hears their puppet say the same line in the player voice of their sex. Lines the character says on its own, in dialogue or in a fight, are heard the same way.
+     * @param line A dialogue topic (DIAL) by form ID or editor ID, such as `0x1B40FA`, the player's combat lines, or one of its lines (INFO) by form ID.
+     * @returns True when sent; false when the player is gone. Throws for a form no DIAL or INFO record has.
+     */
+    say(line: number | string): boolean;
+
+    /**
+     * Knocks the player off their feet into their ragdoll from the server, as FiveM's SetPedToRagdoll does a player's ped: their game pushes them, as `LocalPlayer.knockDown` does, they lie a moment and get up by themselves, and every other player sees them fall. A player who is down, dead, held in place or in furniture is left as they are.
+     * @param force How hard they are thrown, as ObjectReference.PushActorAway takes it: small numbers, 1 to 50 (600 threw an NPC 8,700 units); 0, the default, drops them where they stand.
+     * @param from The point they are thrown away from; where they stand by default.
+     * @returns True when sent; false when the player is gone.
+     */
+    knockDown(force?: number, from?: Vector3): boolean;
+
+    /**
+     * Scales the player in every game, as ObjectReference.SetScale does: their own game scales their character, and every other game their body. It lasts until set again or they leave.
+     * @param scale 1 for their normal size, from 0.01 to 10.
+     * @returns True when sent; false when the player is gone.
+     */
+    setScale(scale: number): boolean;
+
+    /**
+     * Draws the player more or less see-through for everyone, as FiveM's SetEntityAlpha and SetEntityVisible do a player's ped: their own game sets it, as `LocalPlayer.setAlpha` does, and every other game draws their body the same. At 0 no game shows their nametag either. An admin's invisibility, a spectator, a spawn's protection.
+     * @param alpha 0, invisible, to 1, solid.
+     * @param fade Fade there rather than cut (default false).
+     * @returns True when sent; false when the player is gone.
+     */
+    setAlpha(alpha: number, fade?: boolean): boolean;
+
+    /**
+     * Holds the player in place from the server, as FiveM's FreezeEntityPosition does a player's ped and Actor.SetRestrained an actor: their game keeps them standing where they are, neither moving nor acting, until let go. Cuffs, an arrest, an admin freeze, a cutscene. A player who is down or dead is left as they are.
+     * @param restrained True to hold them where they stand, false to let them go.
+     * @returns True when sent; false when the player is gone.
+     */
+    setRestrained(restrained: boolean): boolean;
+
     /**
      * Plays an idle animation on the player, as `Actor.PlayIdle` does; everyone around them sees it. The idle's own conditions apply, so one meant for another skeleton, a piece of furniture or a state the player is not in does nothing. Moving ends most idles; `stopIdle` ends any.
      * @param idle An idle animation from the game's data (an IDLE record): its editor ID, such as `"Salute"`, or its form ID.
@@ -861,96 +1165,481 @@ declare global {
     removeFromAllFactions(): boolean;
 
     /**
-     * Every connected player.
-     * @returns One handle per player, in no particular order.
+     * Has the player's game fast travel to a reference, through the game's own fast travel, as `Game.FastTravel` does. `playerFastTravel` is not raised: the script decided already.
+     * @param destination The reference to arrive at: a map marker, or any other placed reference.
+     * @returns True when sent; false when the player is gone.
      */
-    static all(): Player[];
+    fastTravel(destination: number | string): boolean;
 
     /**
-     * Looks a player up by network ID.
-     * @param id Network entity identifier.
-     * @returns The handle, or null when no connected player has that ID.
+     * The named location the player is in, a BGSLocation form ID, as their game last reported it.
+     * @returns Null in the open, before their first report, or when the player is gone.
      */
-    static getById(id: number): Player | null;
-  }
-
-  interface Player extends BasePlayer {}
+    getLocation(): number | null;
 
-  /**
-   * The server's clock and weather, which every client follows.
-   */
-  const World: {
     /**
-     * The hour of the day, from 0 up to but not including 24, with the minutes as the fraction: 13.5 is half past one.
+     * Where the player's own map marker is: the waypoint they dropped on the Pip-Boy map, or the one a script set.
+     * @returns The position, in the space they stood in; null while they have none or when the player is gone.
      */
-    readonly hour: number;
+    getMapWaypoint(): Vector3 | null;
 
     /**
-     * Game minutes per real minute. 20 is the game's own pace; 0 holds the clock.
+     * Places the player's own map marker, which their compass and Pip-Boy map show, or takes it off. `playerMapWaypoint` is not raised: the script decided already.
+     * @param position Where to, in the space the player stands in; null takes it off.
+     * @returns True when sent; false when the player is gone.
      */
-    readonly timeScale: number;
+    setMapWaypoint(position: Vector3 | null): boolean;
 
     /**
-     * The TESWeather form ID every client shows.
+     * Puts map markers on the player's map, as `ObjectReference.AddToMap` does, without its notice. The map is their game's own: the server keeps no copy, so send it again when they join.
+     * @param markers Map marker references, each a form ID as a number or hex string; up to 4096.
+     * @param canTravel Also fast travel destinations (default true); false shows them on the map only.
+     * @returns True when sent; false when the player is gone.
      */
-    readonly weather: number;
+    discoverLocations(markers: (number | string)[], canTravel?: boolean): boolean;
 
     /**
-     * Whether the weather was swapped in at once rather than transitioned to.
+     * Takes map markers off the player's map; they stop being fast travel destinations.
+     * @param markers Map marker references, each a form ID as a number or hex string; up to 4096.
+     * @returns True when sent; false when the player is gone.
      */
-    readonly weatherForced: boolean;
+    forgetLocations(markers: (number | string)[]): boolean;
 
     /**
-     * Sets the clock. Every client jumps to it.
-     * @param hour The hour, wrapped into 0-24; 13.5 is half past one.
+     * Changes one of the game's own tuning values (a game setting, GMST) in the player's game, where it takes effect at once and lasts until they leave. The server keeps no copy: to make it a rule, set it for each player as they join. A name their game has not, or a value of the wrong kind, changes nothing there.
+     * @param name The setting's name as the game's data defines it: "fJumpHeightMin", "fSprintSpeedMult".
+     * @param value The new value, of the setting's kind: a boolean for a b setting, a number for the others.
+     * @returns True when sent; false when the player is gone.
      */
-    setHour(hour: number): void;
+    setGameSetting(name: string, value: number | boolean): boolean;
 
     /**
-     * Sets how fast the clock runs.
-     * @param scale Game minutes per real minute, 0 or more; 0 holds the clock.
+     * Moves the roll of the player's VATS hits to the server. Their game rolls each queued shot against the chance it shows; while this is on, every shot with a chance above 0 strikes instead, and its hit reaches `playerHit` or `npcHit` as kind "vats" with that chance: the handler rolls it (`Math.random() < vatsChance`) and returns `false` for a miss. Lasts until they leave; set it again for each player as they join.
+     * @param enabled True to roll the player's VATS hits on the server, false to leave them to their game.
+     * @returns True when sent; false when the player is gone.
      */
-    setTimeScale(scale: number): void;
+    setVatsRolledByServer(enabled: boolean): boolean;
 
     /**
-     * Sets the weather every client shows. Only a client's data files can tell whether the form is a weather, so a wrong one leaves the sky as it is.
-     * @param weather A TESWeather form ID, as a number or hex string; null for the server's default, CommonwealthClear.
+     * Gives the player a sky of their own, over the one `World` holds for everyone: the weather of the worldspace they stand in, a storm over one quest, a clear sky for a cutscene. The server strikes its lightning as for the World's. Lasts until they leave: to make it a rule, set it on `playerSpaceChange`, `playerWeatherRegionChange` or as they join.
+     * @param weather A TESWeather form ID for this player alone; null to follow `World.weather` again.
      * @param force Swap it in at once rather than transition to it.
+     * @returns True when sent; false when the player is gone.
      */
-    setWeather(weather: number | string | null, force?: boolean): void;
-  };
+    setWeather(weather: number | string | null, force?: boolean): boolean;
 
-  /**
-   * Doors, locks and containers, by the form ID of their placed reference. The server knows only what changed this session; the rest is as the data files place it, which only a client loads.
-   */
-  const Objects: {
     /**
-     * Whether a door stands open.
-     * @param ref The placed reference's form ID.
-     * @returns Null when nobody moved it this session.
+     * Holds the player's clock, and the sun and the sky with it, at an hour of their own until it is released. Their game's day count and date stay the world's. Lasts until they leave.
+     * @param hour The hour to hold the player's clock at, wrapped into 0-24; null to follow `World.hour` again.
+     * @returns True when sent; false when the player is gone.
      */
-    isDoorOpen(ref: number | string): boolean | null;
+    setHour(hour: number | null): boolean;
 
     /**
-     * Whether a door or container is locked.
-     * @param ref The placed reference's form ID.
-     * @returns Null when nobody changed its lock this session.
+     * The weather `setWeather` gave the player alone.
+     * @returns Null while they follow `World.weather`, or once they are gone.
      */
-    isLocked(ref: number | string): boolean | null;
+    getWeather(): number | null;
 
     /**
-     * Opens or closes a door for everyone, players who join later included.
-     * @param ref The placed reference's form ID.
-     * @param open Open or closed.
+     * Strikes lightning in the player's sky alone: a flash and a thunderclap, if their sky is in a weather that thunders. In a session the game's own strikes come from the server (`World.setLightningEnabled`).
+     * @returns True when sent; false when the player is gone.
      */
-    setDoorOpen(ref: number | string, open: boolean): void;
+    strikeLightning(): boolean;
 
     /**
-     * Locks or unlocks a door or container for everyone.
-     * @param ref The placed reference's form ID.
-     * @param locked Locked or not.
+     * The region whose weathers the player's game would roll where they stand, as their game finds it each time they change cell: the TESRegion form ID, for `World.getRegionWeathers`.
+     * @returns 0 when they stand in no region with weathers, or their game has not said yet.
      */
-    setLocked(ref: number | string, locked: boolean): void;
+    getWeatherRegion(): number;
+
+    /**
+     * The players around a point, a player or an NPC, nearest first, as FiveM scripts run GetActivePlayers through a distance check: who hears a shout, who stands in a zone, who is close enough to trade. Positions are the ones the players' games last reported.
+     * @param center A point, or a player or an NPC, whose position and space are then the search's; a player is not counted among its own.
+     * @param radius How far from it, in game units.
+     * @param options `space`: where a point is, the Commonwealth when left out. `limit`: how many at most, 32 by default, never more than 512.
+     * @returns Empty when nobody is in range, or the center is gone. Throws for a center that is none of these, or a negative radius.
+     */
+    static getInRange(center: Vector3 | Player | Npc, radius: number, options?: { space?: { worldSpace: number } | { interiorCell: number }; limit?: number }): Player[];
+
+    /**
+     * Every connected player.
+     * @returns One handle per player, in no particular order.
+     */
+    static all(): Player[];
+
+    /**
+     * Looks a player up by network ID.
+     * @param id Network entity identifier.
+     * @returns The handle, or null when no connected player has that ID.
+     */
+    static getById(id: number): Player | null;
+  }
+
+  interface Player extends BasePlayer {}
+
+  /**
+   * A calendar date as the game keeps it: twelve months of 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30 and 31 days, no leap years.
+   */
+  interface WorldDate {
+    /**
+     * The full year, 2000 to 2999.
+     */
+    year: number;
+
+    /**
+     * 1 to 12.
+     */
+    month: number;
+
+    /**
+     * 1 to the month's last.
+     */
+    day: number;
+  }
+
+  /**
+   * A weather the game's data files define.
+   */
+  interface WeatherRecord {
+    /**
+     * The TESWeather form ID.
+     */
+    weather: number;
+
+    /**
+     * Its editor ID: "CommonwealthClear", "CommonwealthRadstorm".
+     */
+    editorId: string;
+
+    /**
+     * Its classification, as the game's GetIsPleasant/Cloudy/Rain/Snow conditions read it.
+     */
+    kind: "none" | "pleasant" | "cloudy" | "rain" | "snow";
+  }
+
+  /**
+   * One weather a climate rolls.
+   */
+  interface ClimateWeather {
+    /**
+     * The TESWeather form ID.
+     */
+    weather: number;
+
+    /**
+     * Its weight among the climate's weathers, as the data files give it (they sum to 100 in the official climates).
+     */
+    chance: number;
+  }
+
+  /**
+   * The weathers a worldspace's sky rolls once a weather has run its course.
+   */
+  interface Climate {
+    /**
+     * The climate's editor ID.
+     */
+    editorId: string;
+
+    /**
+     * Its weathers and their chances.
+     */
+    weathers: ClimateWeather[];
+  }
+
+  /**
+   * The server's clock, calendar and weather, which every client follows, and what the game's data files say of weathers and climates.
+   */
+  const World: {
+    /**
+     * The hour of the day, from 0 up to but not including 24, with the minutes as the fraction: 13.5 is half past one.
+     */
+    readonly hour: number;
+
+    /**
+     * Game minutes per real minute. 20 is the game's own pace; 0 holds the clock.
+     */
+    readonly timeScale: number;
+
+    /**
+     * The calendar date every client's game shows. It turns over at midnight as the clock runs.
+     */
+    readonly date: WorldDate;
+
+    /**
+     * Whole days the clock has run, the game's GameDaysPassed: what its timers, vendors' restocks and crops count in.
+     */
+    readonly daysPassed: number;
+
+    /**
+     * The TESWeather form ID every client shows.
+     */
+    readonly weather: number;
+
+    /**
+     * Whether the weather was swapped in at once rather than transitioned to.
+     */
+    readonly weatherForced: boolean;
+
+    /**
+     * The weather the sky is still moving away from, 0 once the move is over: up to two game hours after `setWeather`, past the game's longest transition.
+     */
+    readonly previousWeather: number;
+
+    /**
+     * Whether the server strikes lightning on its own while `weather` thunders, at the pace the game would. In a session the game strikes only on the server's word, so every player sees the same strikes.
+     */
+    readonly lightningEnabled: boolean;
+
+    /**
+     * Sets the clock. Every client jumps to it. The date stays as it is.
+     * @param hour The hour, wrapped into 0-24; 13.5 is half past one.
+     */
+    setHour(hour: number): void;
+
+    /**
+     * Sets how fast the clock runs.
+     * @param scale Game minutes per real minute, 0 or more; 0 holds the clock.
+     */
+    setTimeScale(scale: number): void;
+
+    /**
+     * Sets the calendar date every client's Pip-Boy shows. The hour and the day count stay as they are.
+     * @param year The full year, 2000 to 2999.
+     * @param month 1 to 12.
+     * @param day 1 to the month's last; the calendar has no leap years.
+     */
+    setDate(year: number, month: number, day: number): void;
+
+    /**
+     * Sets how many days the clock has run, which the game's timers count in. The date stays as it is.
+     * @param days Whole days, 0 or more.
+     */
+    setDaysPassed(days: number): void;
+
+    /**
+     * Sets the weather every client shows. A transition runs on the game clock, so every client fades at the same point, one that joins during it included. Only a client's data files can tell whether the form is a weather, so a wrong one leaves the sky as it is.
+     * @param weather A TESWeather form ID, as a number or hex string; null for the server's default, CommonwealthClear.
+     * @param force Swap it in at once rather than transition to it.
+     */
+    setWeather(weather: number | string | null, force?: boolean): void;
+
+    /**
+     * Every weather the game's official masters define, by form ID.
+     * @returns Empty when the server could not read the game's data files.
+     */
+    getWeathers(): WeatherRecord[];
+
+    /**
+     * Starts or stops the server's own lightning.
+     * @param enabled On, or off: no lightning but what scripts strike.
+     */
+    setLightningEnabled(enabled: boolean): void;
+
+    /**
+     * Strikes lightning in every player's sky that thunders: a flash and a thunderclap, at the same moment for all.
+     * @param weather Only for skies in this weather; any weather that thunders when left out.
+     */
+    strikeLightning(weather?: number | string): void;
+
+    /**
+     * The weathers a region rolls, as the data files give it: the game takes them over the worldspace's climate while the player stands in the region.
+     * @param region A TESRegion form ID, as `Player.getWeatherRegion` gives it.
+     * @returns Null when the region has no weathers, or the form is not one.
+     */
+    getRegionWeathers(region: number | string): Climate | null;
+
+    /**
+     * The climate a worldspace's sky rolls its weathers from, as the data files give it: the base a script rolls its own weather cycle on.
+     * @param worldSpace A TESWorldSpace form ID.
+     * @returns Null when the worldspace has none, or the form is not one.
+     */
+    getClimate(worldSpace: number | string): Climate | null;
+  };
+
+  /**
+   * Explosions set off in every player's game at once, as the game sets off its own: the blast, its light, sound, debris and decals, and whatever the explosion leaves behind. An explosion is named by form ID (a number or hex string) or by its editor ID in the official masters ("FragGrenadeExplosion").
+   */
+  const Explosion: {
+    /**
+     * Sets off an explosion in the game of every player in that space whose game has the spot loaded. Each game's blast hurts what that game simulates: its own player, the NPCs it runs.
+     * @param explosion A BGSExplosion (EXPL) form ID: a frag grenade's, a mini nuke's, a car's.
+     * @param position Where it goes off.
+     * @param options `space`: the worldspace or interior cell; the owner's when an owner is given, else the Commonwealth. `scale`: of its radii, 1 by default. `damage`: a multiplier of its damage, 0 for one that hurts nobody. `owner`: who it is credited to.
+     */
+    spawn(explosion: number | string, position: Vector3, options?: { space?: { worldSpace?: number | string; interiorCell?: number | string }; scale?: number; damage?: number; owner?: Player | Npc }): void;
+  };
+
+  /**
+   * Effects in every player's game: placed effects that stream like any entity, effect shaders and visual effects on bodies and references, and impacts. Forms are named by form ID (a number or hex string) or by their editor ID in the official masters; an editor ID made only of hex digits reads as a form ID.
+   */
+  const Effect: {
+    /**
+     * Places an effect every player near it sees, players who come near later included: each game places its own copy while they are in range. Attached, it is a prop: a box carried, a lantern on the back, a flame over a head.
+     * @param form The base object to place: a fog patch, a smoke column or a fire (the game's FX statics, movable statics and activators), a hazard (HAZD), a light (LIGH), any other placeable object.
+     * @param position Where it stands; null for an attached one, which starts where its body stands.
+     * @param options `angle`: its rotation in radians. `space`: the worldspace or interior cell; the body's when attached, else the Commonwealth. `lifetime`: seconds until it is removed on its own; it stays until `remove` when left out. `range`: how near players must be to have it, 8192 units by default. `attach`: holds it on a body or a placed reference every frame, on the named node ("WEAPON", "RArm_Hand", "Head"; the root when left out), shifted by `offset` and turned by `rotation` (radians) in the node's frame; everyone in the space has it. Give it something without collision, or it pushes what it touches.
+     * @returns The effect's ID, for `remove`; 0 when it could not be made.
+     */
+    spawn(form: number | string, position: Vector3 | null, options?: { angle?: Vector3; space?: { worldSpace?: number | string; interiorCell?: number | string }; lifetime?: number; range?: number; attach?: { to: Player | Npc | number | string; node?: string; offset?: Vector3; rotation?: Vector3 } }): number;
+
+    /**
+     * Removes a placed effect from every game.
+     * @param effect An ID `spawn` gave.
+     * @returns False when there is no such effect.
+     */
+    remove(effect: number): boolean;
+
+    /**
+     * Moves a placed effect in every game, players who come near later included: a lift, a gate, a prop a script carries. Each call is one step; call it each tick for a glide.
+     * @param effect An ID `spawn` gave.
+     * @param position Where it stands now.
+     * @param angle Its rotation in radians; kept when left out.
+     * @returns False when there is no such effect, or it is attached.
+     */
+    move(effect: number, position: Vector3, angle?: Vector3): boolean;
+
+    /**
+     * Whether a placed effect is still there: its lifetime may have run out.
+     * @param effect An ID `spawn` gave.
+     */
+    exists(effect: number): boolean;
+
+    /**
+     * Plays an effect shader over a body or a reference in every game where it is loaded, as EffectShader.Play does.
+     * @param target A player, an NPC, or a placed reference's form ID.
+     * @param shader A TESEffectShader (EFSH) form ID: a glow, a burn, a membrane.
+     * @param seconds How long; until `stopShader` when left out.
+     */
+    playShader(target: Player | Npc | number | string, shader: number | string, seconds?: number): void;
+
+    /**
+     * Stops an effect shader on a body or a reference.
+     * @param target A player, an NPC, or a placed reference's form ID.
+     * @param shader The shader played.
+     */
+    stopShader(target: Player | Npc | number | string, shader: number | string): void;
+
+    /**
+     * Attaches a visual effect to a body or a reference in every game where it is loaded, as VisualEffect.Play does.
+     * @param target A player, an NPC, or a placed reference's form ID.
+     * @param effect A BGSReferenceEffect (RFCT) form ID: an art object's particles or model, with or without a shader.
+     * @param seconds How long; until `stopVisual` when left out.
+     */
+    playVisual(target: Player | Npc | number | string, effect: number | string, seconds?: number): void;
+
+    /**
+     * Takes a visual effect off a body or a reference.
+     * @param target A player, an NPC, or a placed reference's form ID.
+     * @param effect The visual effect played.
+     */
+    stopVisual(target: Player | Npc | number | string, effect: number | string): void;
+
+    /**
+     * Plays an impact where a ray from the target lands, in every game where the target is loaded, as ObjectReference.PlayImpactEffect does: the decal, particles and sound of the surface's material.
+     * @param target A player, an NPC, or a placed reference's form ID.
+     * @param impactSet A BGSImpactDataSet (IPDS) form ID: what each material shows when hit.
+     * @param options The ray: from the named node of the target (its root when left out), along the direction (straight down by default), for the length in game units (512).
+     */
+    playImpact(target: Player | Npc | number | string, impactSet: number | string, options?: { node?: string; direction?: Vector3; length?: number }): void;
+  };
+
+  /**
+   * Sounds in every player's game at once, heard where each game places its listener.
+   */
+  const Sound: {
+    /**
+     * Plays a sound for every player near enough to hear it: the descriptor's own attenuation decides how far it carries.
+     * @param sound A sound descriptor (SNDR) by form ID or editor ID.
+     * @param at A spot, or a player, an NPC or a placed reference the sound follows as it moves.
+     * @param options `space`: the spot's worldspace or interior cell, the Commonwealth when left out. `volume`: 0 to 1, 1 by default.
+     * @returns The sound's number, for `stop`.
+     */
+    play(sound: number | string, at: Vector3 | Player | Npc | number | string, options?: { space?: { worldSpace?: number | string; interiorCell?: number | string }; volume?: number }): number;
+
+    /**
+     * Stops a sound in every game still playing it.
+     * @param sound A number `play` gave.
+     */
+    stop(sound: number): void;
+  };
+
+  /**
+   * Doors, locks and containers, by the form ID of their placed reference. The server knows only what changed this session; the rest is as the data files place it, which only a client loads.
+   */
+  const Objects: {
+    /**
+     * Whether a door stands open.
+     * @param ref The placed reference's form ID.
+     * @returns Null when nobody moved it this session.
+     */
+    isDoorOpen(ref: number | string): boolean | null;
+
+    /**
+     * Whether a door or container is locked.
+     * @param ref The placed reference's form ID.
+     * @returns Null when nobody changed its lock this session.
+     */
+    isLocked(ref: number | string): boolean | null;
+
+    /**
+     * Whether a script blocked activating a reference.
+     * @param ref The placed reference's form ID.
+     * @returns Null when no script decided this session: the game's own state stands, which blocks a settlement's workbench until its quest gives it to the player.
+     */
+    isActivationBlocked(ref: number | string): boolean | null;
+
+    /**
+     * Blocks or allows activating a reference for everyone, players who join later included. Allowing a settlement's workbench lets players enter its build mode.
+     * @param ref The placed reference's form ID.
+     * @param blocked Blocked or allowed.
+     */
+    setActivationBlocked(ref: number | string, blocked: boolean): void;
+
+    /**
+     * Whether a script left a reference in the world or took it out.
+     * @param ref The placed reference's form ID.
+     * @returns Null when no script decided this session: the game's own state stands.
+     */
+    isEnabled(ref: number | string): boolean | null;
+
+    /**
+     * Takes a reference the data files place out of every player's world, as ObjectReference.Disable does, or puts it back, players who join later included: a barricade torn down, a door bricked up, a prop shown for an event. Held against the game's own scripts and cell loads, which put references back as they please.
+     * @param ref The placed reference's form ID.
+     * @param enabled In the world, or out of it.
+     */
+    setEnabled(ref: number | string, enabled: boolean): void;
+
+    /**
+     * Moves a placed reference for everyone, players who join later included, as a player moving it in a settlement's build mode does: the power it receives through the air and its wires follow it.
+     * @param ref The placed reference's form ID.
+     * @param position Where it stands now.
+     * @param angle Its rotation, radians.
+     * @returns False for a reference the session scrapped or a pose that is not finite.
+     */
+    move(ref: number | string, position: Vector3, angle?: Vector3): boolean;
+
+    /**
+     * Where a player's build mode or a script last put a placed reference.
+     * @param ref The placed reference's form ID.
+     * @returns Null while it stands where the data files place it.
+     */
+    getMovedPosition(ref: number | string): Vector3 | null;
+
+    /**
+     * Opens or closes a door for everyone, players who join later included.
+     * @param ref The placed reference's form ID.
+     * @param open Open or closed.
+     */
+    setDoorOpen(ref: number | string, open: boolean): void;
+
+    /**
+     * Locks or unlocks a door or container for everyone.
+     * @param ref The placed reference's form ID.
+     * @param locked Locked or not.
+     */
+    setLocked(ref: number | string, locked: boolean): void;
 
     /**
      * What a container holds.
@@ -1131,160 +1820,486 @@ declare global {
     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.
+     * 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;
+  };
+
+  /**
+   * Areas of the world the server watches, as FiveM resources do with PolyZone: an upright cylinder, around a point in a worldspace or an interior. `zoneEnter` and `zoneLeave` tell scripts who came in and who went out, from the places players' games report: a safe zone, a shop's floor, a job's drop point. The server alone knows of them.
+   */
+  const Zone: {
+    /**
+     * Starts watching an area. Players already in it are told so at the next update.
+     * @param options `center` and `radius`, on the ground plane, in game units. `height`: how far above and below the center it reaches, no limit when left out. `name`: given back with its events. `space`: its worldspace or interior, the Commonwealth when left out.
+     * @returns The zone's ID. Throws for a missing center or a radius that is not above 0.
+     */
+    create(options: { center: Vector3; radius: number; height?: number; name?: string; space?: { worldSpace: number } | { interiorCell: number } }): number;
+
+    /**
+     * Stops watching an area; the players in it are told they left.
+     * @param zone The zone's ID, as `create` gave it.
+     * @returns False for an unknown ID.
+     */
+    remove(zone: number): boolean;
+
+    /**
+     * The players in an area, as the last update found them.
+     * @param zone The zone's ID, as `create` gave it.
+     * @returns Empty for an unknown ID.
+     */
+    getPlayers(zone: number): Player[];
+
+    /**
+     * Whether a point lies in an area: where an NPC stands, a drop, a spawn.
+     * @param zone The zone's ID, as `create` gave it.
+     * @param position The point.
+     * @param space Where the point is; the Commonwealth when left out.
+     * @returns False for an unknown ID.
+     */
+    contains(zone: number, position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
+
+    /**
+     * Every zone's ID.
+     * @returns In the order they were made.
+     */
+    all(): number[];
+  };
+
+  /**
+   * The game's own quests, given to players as scripts decide. A player's game lists the quests they have in the Pip-Boy, and tracks the active ones on the HUD with the data files' quest name and objective texts. There is no quest logic here: scripts decide which quest a player has, which objectives they see, and when each is done. A player's quests go when they disconnect.
+   */
+  const Quests: {
+    /**
+     * Gives the player the quest, with no objectives and not active. Nothing changes when they have it already.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @returns False when the player is gone.
+     */
+    show(player: Player, quest: number): boolean;
+
+    /**
+     * Takes the quest and its objectives off the player.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @returns False when they did not have it.
+     */
+    hide(player: Player, quest: number): boolean;
+
+    /**
+     * Tracks the quest on the player's HUD, or stops tracking it.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @param active Whether the HUD tracks it.
+     * @returns False when they do not have the quest.
+     */
+    setActive(player: Player, quest: number, active: boolean): boolean;
+
+    /**
+     * Sets one of the quest's objectives for the player. A quest holds 32 objectives at most.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @param index The objective's index in the quest (its QOBJ value, as the data files give it).
+     * @param state 'displayed' shows it on the HUD tracker; 'completed' and 'failed' mark it in the Pip-Boy; 'hidden' takes it off.
+     * @returns False when they do not have the quest, or it holds 32 objectives already.
+     */
+    setObjective(player: Player, quest: number, index: number, state: 'hidden' | 'displayed' | 'completed' | 'failed'): boolean;
+
+    /**
+     * The quests the player has, by form ID.
+     * @param player A connected player.
+     * @returns Empty when they have none.
+     */
+    getShown(player: Player): number[];
+
+    /**
+     * Whether the player's HUD tracks the quest.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @returns Null when they do not have it.
+     */
+    isActive(player: Player, quest: number): boolean | null;
+
+    /**
+     * The state of one of the quest's objectives for the player.
+     * @param player A connected player.
+     * @param quest The quest's form ID (QUST) in the game's data files.
+     * @param index The objective's index in the quest (its QOBJ value, as the data files give it).
+     * @returns Null when they do not have the quest.
+     */
+    getObjective(player: Player, quest: number, index: number): 'hidden' | 'displayed' | 'completed' | 'failed' | null;
+  };
+
+  /**
+   * 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.
+   */
+  class Mine {
+    /**
+     * Wraps an armed mine with this ID; it lays nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * How close a player must come to set it off, in game units; 0 once it is gone.
+     */
+    readonly radius: number;
+
+    /**
+     * The BGSExplosion form ID it sets off; 0 once it is gone.
+     */
+    readonly explosion: number;
+
+    /**
+     * Has the owner's game set the mine off where it lies, as if a player walked onto it. The blast is the owner's: `playerExplosion` and `playerHit` follow.
+     * @returns True when sent; false when it is gone or already going off.
+     */
+    detonate(): boolean;
+
+    /**
+     * Takes the mine out of the world without a blast.
+     * @returns True when it was armed.
+     */
+    remove(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The mine's network ID, owner and radius.
+     */
+    toString(): string;
+
+    /**
+     * The player who laid it.
+     * @returns The owner, or null once the mine or its owner is gone.
+     */
+    getOwner(): Player | null;
+
+    /**
+     * Every armed mine.
+     * @returns One handle per mine.
+     */
+    static all(): Mine[];
+  }
+
+  interface Mine extends Entity {}
+
+  /**
+   * A radio station every player's game carries. It joins each Pip-Boy's station list once heard and plays through world radios tuned to it, everywhere in the world. The server says what is on air and since when, so every player hears the same moment of the same track. A station outlives the resource that created it until destroyed.
+   */
+  class RadioStation {
+    /**
+     * Wraps the station with this ID; it creates nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * What the Pip-Boy lists it as; empty once it is gone.
+     */
+    readonly name: string;
+
+    /**
+     * The frequency it transmits on; 0 once it is gone.
+     */
+    readonly frequency: number;
+
+    /**
+     * The BGSSoundDescriptorForm form ID on air; 0 while it is silent.
+     */
+    readonly sound: number;
+
+    /**
+     * How long the track on air runs, in milliseconds, as given to `play`; 0 when not given.
+     */
+    readonly duration: number;
+
+    /**
+     * How long the track on air has run, in milliseconds; 0 while it is silent.
+     */
+    readonly elapsed: number;
+
+    /**
+     * Takes the track off air: every player's radio falls silent on this station.
+     * @returns False once the station is gone.
+     */
+    stop(): boolean;
+
+    /**
+     * Takes the station off every player's radio.
+     * @returns False once the station is gone.
+     */
+    destroy(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The station's network ID, name and frequency.
+     */
+    toString(): string;
+
+    /**
+     * Puts a track on air from now, replacing what played. Only a player's data files can tell whether the form is a sound descriptor, so a wrong one stays silent. No event marks the end of a track: the script schedules the next one itself, from the duration it knows.
+     * @param sound A BGSSoundDescriptorForm form ID, as a number or hex string.
+     * @param durationMs How long it runs. With it, a player tuning in until then still hears it; without it, a player's radio drops it once it has played out.
+     * @returns False once the station is gone.
+     */
+    play(sound: number | string, durationMs?: number): boolean;
+
+    /**
+     * Creates a silent station on every player's radio.
+     * @param name What the Pip-Boy lists it as, up to 64 characters.
+     * @param frequency What it transmits on, 80 to 110, the Pip-Boy's dial; no other station may hold it. A game station on the same frequency plays over it unless the game's stations are off.
+     * @returns The station, or null when the name or frequency was refused.
+     */
+    static create(name: string, frequency: number): RadioStation | null;
+
+    /**
+     * Puts the game's own stations (Diamond City Radio, Classical Radio, and the quest signals and distress beacons too) on or off every player's radio. Each player's game runs them alone, so no two players hear the same thing on them. Off, they leave the Pip-Boy's list and every world radio, and the scenes behind them play out in person instead. A player joining later follows the setting.
+     * @param enabled False takes them off; true puts them back.
+     */
+    static setVanillaStationsEnabled(enabled: boolean): void;
+
+    /**
+     * Whether the game's own stations are on the radio.
+     * @returns True unless a script turned them off.
+     */
+    static areVanillaStationsEnabled(): boolean;
+
+    /**
+     * Every station.
+     * @returns One handle per station.
+     */
+    static all(): RadioStation[];
+  }
+
+  interface RadioStation extends Entity {}
+
+  /**
+   * A marker on every player's HUD compass and Pip-Boy map, as FiveM's blips: at a point, or following a player or an NPC. A player sees it while they are in its worldspace or interior. A blip outlives the resource that made it until destroyed. Move it with `setPosition` or `attachTo`, not by setting `position`.
+   */
+  class Blip {
+    /**
+     * Wraps the blip with this ID; it creates nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * What the Pip-Boy map's tooltip says; empty once it is gone.
+     */
+    readonly label: string;
+
+    /**
+     * Takes the blip off every player's compass and map.
+     * @returns False once it is gone.
+     */
+    destroy(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The blip's network ID and label.
      */
-    clearReaction(faction: number | string, other: number | string, mutual?: boolean): boolean;
-  };
+    toString(): string;
 
-  /**
-   * 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.
-   */
-  class Mine {
     /**
-     * Wraps an armed mine with this ID; it lays nothing.
-     * @param id Network entity identifier.
+     * Moves the blip to a point, as FiveM's SetBlipCoords does; it stops following anyone.
+     * @param position Where, in world units.
+     * @param space Where that is; its current space when left out.
+     * @returns False once it is gone.
      */
-    constructor(id: number);
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
 
     /**
-     * How close a player must come to set it off, in game units; 0 once it is gone.
+     * Has the blip follow a player or an NPC, as FiveM's AddBlipForEntity does: each player's game puts it on that body while it has it loaded, and on where the server last saw it otherwise.
+     * @param target Whose body to follow; null to stay where it is.
+     * @returns False once it is gone.
      */
-    readonly radius: number;
+    attachTo(target: Player | Npc | null): boolean;
 
     /**
-     * The BGSExplosion form ID it sets off; 0 once it is gone.
+     * Whom the blip follows.
+     * @returns Null for a blip at a point, or once that body is gone.
      */
-    readonly explosion: number;
+    getAttached(): Player | Npc | null;
 
     /**
-     * Has the owner's game set the mine off where it lies, as if a player walked onto it. The blast is the owner's: `playerExplosion` and `playerHit` follow.
-     * @returns True when sent; false when it is gone or already going off.
+     * Shows the blip to one player only, as a FiveM blip a client script made for its own player: a delivery's drop point, a bounty on someone's own map.
+     * @param player The one player who sees it; null for everyone.
+     * @returns False once it is gone.
      */
-    detonate(): boolean;
+    setPlayer(player: Player | null): boolean;
 
     /**
-     * Takes the mine out of the world without a blast.
-     * @returns True when it was armed.
+     * The one player who sees the blip.
+     * @returns Null while everyone does.
      */
-    remove(): boolean;
+    getPlayer(): Player | null;
 
     /**
-     * Formats this handle for logging.
-     * @returns The mine's network ID, owner and radius.
+     * Changes what the Pip-Boy map's tooltip says.
+     * @param label Up to 63 bytes of UTF-8.
+     * @returns False once it is gone.
      */
-    toString(): string;
+    setLabel(label: string): boolean;
 
     /**
-     * The player who laid it.
-     * @returns The owner, or null once the mine or its owner is gone.
+     * Puts a blip on every player's compass and map, as FiveM's AddBlipForCoord and AddBlipForEntity do.
+     * @param options `position` or `entity`, where it is or whom it follows. `label`: the map's tooltip. `kind`: the icon, "quest" by default. `compass` and `map`: where it shows, both by default. `space`: a point's worldspace or interior, the Commonwealth when left out. `player`: the one player who sees it, everyone when left out.
+     * @returns The blip; null when it could not be made. Throws for options that name neither a position nor a body.
      */
-    getOwner(): Player | null;
+    static create(options: { position?: Vector3; entity?: Player | Npc; label?: string; kind?: "quest" | "custom" | "powerArmor"; compass?: boolean; map?: boolean; space?: { worldSpace: number } | { interiorCell: number }; player?: Player }): Blip | null;
 
     /**
-     * Every armed mine.
-     * @returns One handle per mine.
+     * Every blip.
+     * @returns One handle per blip.
      */
-    static all(): Mine[];
+    static all(): Blip[];
   }
 
-  interface Mine extends Entity {}
+  interface Blip extends Entity {}
 
   /**
-   * A radio station every player's game carries. It joins each Pip-Boy's station list once heard and plays through world radios tuned to it, everywhere in the world. The server says what is on air and since when, so every player hears the same moment of the same track. A station outlives the resource that created it until destroyed.
+   * Text floating in the world on every player's screen, as FiveM resources draw 3D text: over a shop's door, a ped's head, a player. A player sees it while they are in its worldspace or interior and within its range. A label outlives the resource that made it until destroyed. Move it with `setPosition` or `attachTo`, not by setting `position`.
    */
-  class RadioStation {
+  class TextLabel {
     /**
-     * Wraps the station with this ID; it creates nothing.
+     * Wraps the label with this ID; it creates nothing.
      * @param id Network entity identifier.
      */
     constructor(id: number);
 
     /**
-     * What the Pip-Boy lists it as; empty once it is gone.
+     * What it says; empty once it is gone.
      */
-    readonly name: string;
+    readonly text: string;
 
     /**
-     * The frequency it transmits on; 0 once it is gone.
+     * Takes the label off every player's screen.
+     * @returns False once it is gone.
      */
-    readonly frequency: number;
+    destroy(): boolean;
 
     /**
-     * The BGSSoundDescriptorForm form ID on air; 0 while it is silent.
+     * Formats this handle for logging.
+     * @returns The label's network ID and text.
      */
-    readonly sound: number;
+    toString(): string;
 
     /**
-     * How long the track on air runs, in milliseconds, as given to `play`; 0 when not given.
+     * Changes what the label says.
+     * @param text Up to 127 bytes of UTF-8; a line break starts a new line.
+     * @returns False once it is gone.
      */
-    readonly duration: number;
+    setText(text: string): boolean;
 
     /**
-     * How long the track on air has run, in milliseconds; 0 while it is silent.
+     * Changes the text's color.
+     * @param color 0xRRGGBBAA: 0xFFFFFFFF is opaque white.
+     * @returns False once it is gone.
      */
-    readonly elapsed: number;
+    setColor(color: number): boolean;
 
     /**
-     * Takes the track off air: every player's radio falls silent on this station.
-     * @returns False once the station is gone.
+     * Moves the label to a point; it stops floating over anyone.
+     * @param position Where, in world units.
+     * @param space Where that is; its current space when left out.
+     * @returns False once it is gone.
      */
-    stop(): boolean;
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
 
     /**
-     * Takes the station off every player's radio.
-     * @returns False once the station is gone.
+     * Has the label float over a player or an NPC: each player's game draws it over that body while it has it loaded, and over where the server last saw it otherwise.
+     * @param target Whose body to float over; null to stay where it is.
+     * @returns False once it is gone.
+     */
+    attachTo(target: Player | Npc | null): boolean;
+
+    /**
+     * Puts floating text in the world for every player, as FiveM's DrawText3D is drawn: "[E] Shop" over a counter, a name over a head.
+     * @param options `text`: what it says. `position` or `entity`: where it is or whom it floats over. `height`: how far above, 140 over a body and 0 at a point by default. `color`: 0xRRGGBBAA, white by default. `range`: how far from a player it is drawn, 1000 by default, at most 20000. `space`: a point's worldspace or interior, the Commonwealth when left out. `player`: the one player who sees it, everyone when left out.
+     * @returns The label; null when it could not be made. Throws for options without text, or naming neither a position nor a body.
+     */
+    static create(options: { text: string; position?: Vector3; entity?: Player | Npc; height?: number; color?: number; range?: number; space?: { worldSpace: number } | { interiorCell: number }; player?: Player }): TextLabel | null;
+
+    /**
+     * Every label.
+     * @returns One handle per label.
+     */
+    static all(): TextLabel[];
+  }
+
+  interface TextLabel extends Entity {}
+
+  /**
+   * A ring on the ground on every player's screen, as FiveM resources draw a marker with CreateCheckpoint or DrawMarker: a translucent upright cylinder at a job's pickup, a shop's door, a race's next gate. A player sees it while they are in its worldspace or interior and within its range. It shows the place; `Zone.create` with the same center and radius tells scripts who steps in. Move it with `setPosition`, not by setting `position`.
+   */
+  class Checkpoint {
+    /**
+     * Wraps the checkpoint with this ID; it creates nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * Its radius in game units; 0 once it is gone.
+     */
+    readonly radius: number;
+
+    /**
+     * Takes the checkpoint off every player's screen.
+     * @returns False once it is gone.
      */
     destroy(): boolean;
 
     /**
      * Formats this handle for logging.
-     * @returns The station's network ID, name and frequency.
+     * @returns The checkpoint's network ID and radius.
      */
     toString(): string;
 
     /**
-     * Puts a track on air from now, replacing what played. Only a player's data files can tell whether the form is a sound descriptor, so a wrong one stays silent. No event marks the end of a track: the script schedules the next one itself, from the duration it knows.
-     * @param sound A BGSSoundDescriptorForm form ID, as a number or hex string.
-     * @param durationMs How long it runs. With it, a player tuning in until then still hears it; without it, a player's radio drops it once it has played out.
-     * @returns False once the station is gone.
+     * Changes its color.
+     * @param color 0xRRGGBBAA; the alpha is the wall's, the rim is drawn more solid.
+     * @returns False once it is gone.
      */
-    play(sound: number | string, durationMs?: number): boolean;
+    setColor(color: number): boolean;
 
     /**
-     * Creates a silent station on every player's radio.
-     * @param name What the Pip-Boy lists it as, up to 64 characters.
-     * @param frequency What it transmits on, 80 to 110, the Pip-Boy's dial; no other station may hold it. A game station on the same frequency plays over it unless the game's stations are off.
-     * @returns The station, or null when the name or frequency was refused.
+     * Widens or narrows it.
+     * @param radius Game units, above 0 and at most 5000.
+     * @returns False once it is gone.
      */
-    static create(name: string, frequency: number): RadioStation | null;
+    setRadius(radius: number): boolean;
 
     /**
-     * Puts the game's own stations (Diamond City Radio, Classical Radio, and the quest signals and distress beacons too) on or off every player's radio. Each player's game runs them alone, so no two players hear the same thing on them. Off, they leave the Pip-Boy's list and every world radio, and the scenes behind them play out in person instead. A player joining later follows the setting.
-     * @param enabled False takes them off; true puts them back.
+     * Moves it.
+     * @param position The middle of its base, on the ground.
+     * @param space Where that is; its current space when left out.
+     * @returns False once it is gone.
      */
-    static setVanillaStationsEnabled(enabled: boolean): void;
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
 
     /**
-     * Whether the game's own stations are on the radio.
-     * @returns True unless a script turned them off.
+     * Puts a ring on the ground for every player, or one player.
+     * @param options `position`: the middle of its base, on the ground. `radius`: 100 by default, at most 5000. `height`: how high its wall rises, 50 by default, 0 for a flat ring. `color`: 0xRRGGBBAA, a translucent amber by default. `range`: how far from a player it is drawn, 3000 by default, at most 20000. `space`: its worldspace or interior, the Commonwealth when left out. `player`: the one player who sees it, everyone when left out.
+     * @returns The checkpoint; null when it could not be made. Throws for options without a position, or a radius out of range.
      */
-    static areVanillaStationsEnabled(): boolean;
+    static create(options: { position: Vector3; radius?: number; height?: number; color?: number; range?: number; space?: { worldSpace: number } | { interiorCell: number }; player?: Player }): Checkpoint | null;
 
     /**
-     * Every station.
-     * @returns One handle per station.
+     * Every checkpoint.
+     * @returns One handle per checkpoint.
      */
-    static all(): RadioStation[];
+    static all(): Checkpoint[];
   }
 
-  interface RadioStation extends Entity {}
+  interface Checkpoint 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`.
+   * 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. A script also makes its own with `Npc.spawn`: those stay dead until `respawn` and leave with `remove`. Move it with `teleport`, not by setting `position`.
    */
   class Npc {
     /**
@@ -1294,7 +2309,7 @@ declare global {
     constructor(id: number);
 
     /**
-     * The form ID of the placed reference (ACHR) it stands for.
+     * The form ID of the placed reference (ACHR) it stands for; 0 for one a script spawned.
      */
     readonly ref: number;
 
@@ -1303,6 +2318,16 @@ declare global {
      */
     readonly form: number;
 
+    /**
+     * The editor ID of its TESNPC record, such as "EncRaider01"; empty when the record has none. The game's display names are localized in each player's own files, so the server has none to give.
+     */
+    readonly editorId: string;
+
+    /**
+     * The level its TESNPC record gives it. A record that scales with the player's level has none of its own: the lowest level it can have is given.
+     */
+    readonly level: 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.
      */
@@ -1318,6 +2343,31 @@ declare global {
      */
     readonly isDead: boolean;
 
+    /**
+     * Whether `setRestrained` froze it in place.
+     */
+    readonly isRestrained: boolean;
+
+    /**
+     * Whether the game that runs it has it in the sneak stance, as its last report says.
+     */
+    readonly isSneaking: boolean;
+
+    /**
+     * Whether `setActivationBlocked` stopped the game's own activation of it.
+     */
+    readonly isActivationBlocked: boolean;
+
+    /**
+     * The name `setName` gave it; empty while it shows its record's own.
+     */
+    readonly name: string;
+
+    /**
+     * Whether `setInvulnerable` made it unhurtable.
+     */
+    readonly isInvulnerable: boolean;
+
     /**
      * Facing, in radians around Z.
      */
@@ -1329,6 +2379,12 @@ declare global {
      */
     kill(): boolean;
 
+    /**
+     * Takes an NPC a script spawned out of the session; every player's game drops it at the next update. The handle resolves to nothing after.
+     * @returns True when it goes; false for one that stands for a placed reference, which lives for the whole session.
+     */
+    remove(): boolean;
+
     /**
      * Puts it back at its placement, whole, dead or alive; `npcRespawn` follows.
      * @returns True when done.
@@ -1353,6 +2409,12 @@ declare global {
      */
     getSimulator(): Player | null;
 
+    /**
+     * Who the NPC fights, as the game that runs it reports: its own choice, or the target `attack` gave it. The `npcTarget` event tells each change.
+     * @returns Null while it fights nobody, or is dead.
+     */
+    getCombatTarget(): Player | Npc | null;
+
     /**
      * The player the NPC follows as a companion.
      * @returns Null when it follows nobody.
@@ -1373,6 +2435,240 @@ declare global {
      */
     damage(amount: number): boolean;
 
+    /**
+     * Gives the NPC health back, as FiveM's SetEntityHealth raises a ped's and Actor.RestoreValue does: the game that runs it restores it, and `health` follows with its next report. One nobody runs is healed on the server.
+     * @param amount Health to give back, above 0; the NPC stops at its maximum.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    heal(amount: number): boolean;
+
+    /**
+     * Sends the NPC somewhere, as FiveM's TaskGoToCoord does a ped: the game that runs it has it travel there as a commanded companion does, along the navmesh, and the server walks it there while nobody near runs it. `npcArrive` follows once it is there; it then stands there until `stopGoing` or the next `goTo`. Its fights still come first.
+     * @param target A point of the NPC's space, or a player or NPC to walk up to.
+     * @returns True when sent; false when it is dead or the target is itself.
+     */
+    goTo(target: Vector3 | Player | Npc): boolean;
+
+    /**
+     * Has the NPC use a piece of furniture, as FiveM's TaskStartScenarioAtPosition puts a ped to a scenario and a companion obeys the player's command: the game that runs it walks it there and activates it, sitting down or getting to work, and sends it back if it gets up on its own. It replaces a `goTo` order, and `goTo` replaces it. `stopUsing` lets it go.
+     * @param ref A placed piece of furniture, by its reference's form ID: a chair, a bench, a workstation.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    use(ref: number | string): boolean;
+
+    /**
+     * Sets the NPC's health at full, as FiveM's SetEntityMaxHealth does an entity: the game that runs it carries it as the NPC's permanent Health, and every player's copy takes it from there. The damage it took is kept, so an unhurt NPC stays at full. It lasts while the NPC does, through respawns.
+     * @param value Health at full, at least 1.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    setMaxHealth(value: number): boolean;
+
+    /**
+     * Scales the NPC on every player's copy, as ObjectReference.SetScale does: its body, its collision and its reach grow or shrink together. It lasts while the NPC does, through respawns.
+     * @param scale 1 for its record's size, from 0.01 to 10: 1.5 a hulking boss, 0.5 a runt.
+     * @returns True when sent; false when it is gone.
+     */
+    setScale(scale: number): boolean;
+
+    /**
+     * Sets one of the NPC's actor values on every player's copy, as FiveM's ped natives tune a ped: SpeedMult (100 is its own speed) for SetPedMoveRateOverride, Aggression, Confidence and Assistance for SetPedCombatAttributes. Each copy holds the base, its own coming back with `resetValue`. A value the game derives from something else keeps its own: DamageResist comes from the armor worn, so dress the NPC (`setOutfit`) instead. An `attack` or `flee` order holds Aggression or Confidence while it runs. Up to 16 values per NPC; it lasts while the NPC does.
+     * @param value An actor value by editor ID, such as `"SpeedMult"`, `"Aggression"` or `"Confidence"`, or by form ID. Not Health: `setMaxHealth` sets that.
+     * @param base The base every copy holds.
+     * @returns True when sent; false when the NPC is gone or 16 values are already set. Throws for a name or form no actor value has, and for Health.
+     */
+    setValue(value: string | number, base: number): boolean;
+
+    /**
+     * The base `setValue` gave one of the NPC's actor values.
+     * @param value An actor value by editor ID, such as `"SpeedMult"`, `"Aggression"` or `"Confidence"`, or by form ID. Not Health: `setMaxHealth` sets that.
+     * @returns Null when the script set none; the record's own is in each player's game alone.
+     */
+    getValue(value: string | number): number | null;
+
+    /**
+     * Gives every copy its own base for one actor value back.
+     * @param value An actor value by editor ID, such as `"SpeedMult"`, `"Aggression"` or `"Confidence"`, or by form ID. Not Health: `setMaxHealth` sets that.
+     * @returns True when sent; false when the NPC is gone or the value was not set.
+     */
+    resetValue(value: string | number): boolean;
+
+    /**
+     * Holds the NPC's weapon out or away, as FiveM's SetCurrentPedWeapon draws a ped's: the game that runs it draws or holsters it (Actor.DrawWeapon) and keeps it so when its AI would change it, and every player's copy follows. A guard on watch, a trader with nothing in hand. It does not start or end a fight.
+     * @param drawn True to hold its weapon out, false to keep it away, null to leave it to its AI.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    setWeaponDrawn(drawn: boolean | null): boolean;
+
+    /**
+     * Takes the NPC's collision away or gives it back on every player's copy, as FiveM's SetEntityCollision does a ped and the console's tcl a selected actor: without it the NPC moves along where it looks, through walls and floors, without gravity. A ghost through a wall, a body walked out of a locked room. It lasts while the NPC does.
+     * @param enabled False to take its collision away, true to give it back.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    setCollision(enabled: boolean): boolean;
+
+    /**
+     * Has the NPC sneak, as FiveM's SetPedStealthMovement does a ped: the game that runs it holds it in the sneak stance (the console's SetForceSneak) wherever its AI takes it, and every player's copy crouches with it. `isSneaking` reports the stance its game runs.
+     * @param sneaking True to crouch into sneak, false to stand up.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    setSneaking(sneaking: boolean): boolean;
+
+    /**
+     * Knocks the NPC off its feet into its ragdoll, as FiveM's SetPedToRagdoll does a ped: the game that runs it pushes its body, it lies a moment and gets up by itself, and every player's copy falls and gets up with it. One that is down already, seated or held in place is left as it is.
+     * @param force How hard it is thrown, as ObjectReference.PushActorAway takes it: small numbers, 1 to 50 (600 threw an NPC 8,700 units); 0, the default, drops it where it stands.
+     * @param from The point it is thrown away from; where it stands by default.
+     * @returns True when sent; false when it is dead, gone, or no player's game runs it.
+     */
+    knockDown(force?: number, from?: Vector3): boolean;
+
+    /**
+     * Draws the NPC more or less see-through on every player's copy, as FiveM's SetEntityAlpha does a ped and Actor.SetAlpha an actor: a ghost, a stalker, an NPC kept out of sight. Its collision and its AI are left as they are. It lasts while the NPC does.
+     * @param alpha 0, invisible, to 1, solid.
+     * @returns True when sent; false when it is gone.
+     */
+    setAlpha(alpha: number): boolean;
+
+    /**
+     * Has the NPC run from a player or an NPC, as FiveM's TaskSmartFleePed does a ped: the game that runs it puts it in combat with that body with its Confidence at Cowardly, so it runs and hides as a frightened settler does, and every player sees it. Its own Confidence comes back when it stops. It replaces an `attack` order, and `attack` replaces it. `stopFleeing` ends it.
+     * @param from The body it runs from.
+     * @returns True when sent; false when it is dead or gone, or the body is not alive in its space.
+     */
+    flee(from: Player | Npc): boolean;
+
+    /**
+     * Ends a `flee` order: the NPC's fight ends and its own Confidence comes back.
+     * @returns True when sent; false when it is dead, gone or not fleeing.
+     */
+    stopFleeing(): boolean;
+
+    /**
+     * Has the NPC live around a point, as FiveM's TaskWanderInArea does a ped: the game that runs it idles, sits, leans and walks about within 512 units of the center, as Fallout 4's settlers sandbox, and every player sees it do so. It replaces a `goTo` or `use` order, and either replaces it. `stopWandering` gives it back its own packages.
+     * @param center The middle of the area, in the NPC's space; where it stands when left out.
+     * @returns True when sent; false when it is dead or gone.
+     */
+    wander(center?: Vector3): boolean;
+
+    /**
+     * Ends a `wander` order: the NPC goes back to its own packages.
+     * @returns True when sent; false when it is dead, gone or not wandering.
+     */
+    stopWandering(): boolean;
+
+    /**
+     * Freezes the NPC in place on every player's copy, as FiveM's FreezeEntityPosition does a ped and Actor.SetRestrained an actor: it stands where it is and neither walks, fights nor talks, its head still free to turn (`lookAt`). A shopkeeper behind his counter, a prisoner. It lasts through respawns.
+     * @param restrained True to freeze it where it stands, false to let it go.
+     * @returns True when sent; false when the NPC is gone.
+     */
+    setRestrained(restrained: boolean): boolean;
+
+    /**
+     * Turns the NPC's head and eyes toward a player or another NPC and keeps them there, on every player's copy, as FiveM's TaskLookAtEntity does a ped and Actor.SetLookAt an actor: a shopkeeper watching his customer, a guard eyeing a stranger. It does not turn its body or stop what it does.
+     * @param target Whose body to watch; null to look where it pleases again.
+     * @returns True when sent; false when the NPC is gone, the target is itself, or it looked at nobody and null was given.
+     */
+    lookAt(target: Player | Npc | null): boolean;
+
+    /**
+     * Drops the order `use` gave: the NPC gets up and goes back to its own business.
+     * @returns True when it had one.
+     */
+    stopUsing(): boolean;
+
+    /**
+     * Drops the order `goTo` gave: the NPC goes back to its own business.
+     * @returns True when it had one.
+     */
+    stopGoing(): boolean;
+
+    /**
+     * Sets the NPC on someone, as FiveM's TaskCombatPed does a ped: the game that runs it starts combat with the target, as Actor.StartCombat does, and keeps its aim on it whatever its own target choice would be. It fights with what it carries, and the hits go through `npcAttack` as any other. The order ends when the target dies or leaves, or with `stopAttacking`.
+     * @param target Who to fight: a living player or NPC of its space.
+     * @returns True when sent; false when it is dead, or the target is itself or no living player or NPC of its space.
+     */
+    attack(target: Player | Npc): boolean;
+
+    /**
+     * The memberships scripts changed on the NPC, each with its rank, or -1 for a faction it was taken out of. The factions its record gives it and no script touched are not listed.
+     * @returns One entry per faction, in the order they were first changed; empty when the NPC is gone.
+     */
+    getFactions(): { faction: number; rank: number }[];
+
+    /**
+     * Puts the NPC in a faction at a rank, or re-ranks it, as `Actor.SetFactionRank` does and FiveM's relationship groups do for a ped: every player's copy holds the membership, so the game's own hostility follows. A raider taken out of RaiderFaction and put in PlayerFaction (0x1C21C) treats players as its own. Up to 16 factions per NPC.
+     * @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 NPC is gone or 16 of its factions are already changed.
+     */
+    setFactionRank(faction: number | string, rank?: number): boolean;
+
+    /**
+     * Takes the NPC out of a faction on every player's copy, as `Actor.RemoveFromFaction` does, whether its record or a script put it there.
+     * @param faction A TESFaction form ID, as a number or hex string.
+     * @returns True when sent; false when the NPC is gone or 16 of its factions are already changed.
+     */
+    removeFromFaction(faction: number | string): boolean;
+
+    /**
+     * Names the NPC on every player's copy, as a named ped in a FiveM resource: the crosshair, its health bar and its dialogue show the name in place of its record's ("Settler", "Raider"), as a reference's ExtraTextDisplayData does.
+     * @param name What it is called, up to 47 bytes of UTF-8; null or an empty string gives it back its record's own name.
+     * @returns True when sent; false when the NPC is gone.
+     */
+    setName(name: string | null): boolean;
+
+    /**
+     * Stops what the game does when a player activates the NPC (its greeting, its dialogue, a trade), as ObjectReference.BlockActivation does, on every player's copy: `npcActivate` is still raised, so a script answers with its own interaction, as FiveM resources do for a ped.
+     * @param blocked True to stop the game's own activation, false to give it back.
+     * @returns True when sent; false when the NPC is gone.
+     */
+    setActivationBlocked(blocked: boolean): boolean;
+
+    /**
+     * Makes the NPC unhurtable by players and NPCs, as FiveM's SetEntityInvincible does a ped: every player's copy is a ghost (Actor.SetGhost), which shots, blows and explosions pass over, and the server drops any hit still reported on it. The script's own `damage` and `kill` still go through.
+     * @param invulnerable True to make it unhurtable, false to make it hurtable again.
+     * @returns True when sent; false when the NPC is gone.
+     */
+    setInvulnerable(invulnerable: boolean): boolean;
+
+    /**
+     * Plays an idle animation on the NPC, as FiveM's TaskPlayAnim does a ped and `Player.playIdle` a player: every player's copy plays it. The idle's own conditions apply, so one meant for another skeleton, a piece of furniture or a state the NPC is not in does nothing, and the NPC's own AI may cut it short. `stopIdle` ends it.
+     * @param idle An idle animation (IDLE) by editor ID, such as `"IdleWave"`, or form ID.
+     * @returns True when sent; false when the NPC is dead or gone. Throws for a form no IDLE record has.
+     */
+    playIdle(idle: number | string): boolean;
+
+    /**
+     * Has the NPC speak, voice and subtitle, as FiveM's PlayPedAmbientSpeechNative does a ped and Papyrus ObjectReference.Say an actor: every player near it hears the same line. A topic's line is picked by the game running the NPC among those whose conditions pass for it (its voice type, its faction), and the others say that one; a topic with no line for this NPC says nothing. Most generic topics have no editor ID: give their form ID.
+     * @param line A dialogue topic (DIAL) by form ID or editor ID, such as `0x47895`, a raider's idle chatter, or one line of a topic (INFO) by form ID.
+     * @returns True when sent; false when the NPC is dead or gone. Throws for a form no DIAL or INFO record has.
+     */
+    say(line: number | string): boolean;
+
+    /**
+     * Ends the idle animation the NPC plays, on every player's copy.
+     * @returns True when sent; false when the NPC is dead or gone.
+     */
+    stopIdle(): boolean;
+
+    /**
+     * Dresses the NPC, as FiveM's SetPedComponentVariation does a ped: every player's copy wears the pieces, locked, each over what the NPC's record gives it in the same body slots. It lasts while the NPC does, through respawns.
+     * @param armors Up to 12 armor pieces or clothes (ARMO) by form ID or editor ID, such as `"Armor_Raider_Underarmor"`; null or an empty list gives it back its own clothes.
+     * @returns True when sent; false when the NPC is gone. Throws for a piece no ARMO record has.
+     */
+    setOutfit(armors: (number | string)[] | null): boolean;
+
+    /**
+     * Arms the NPC, as FiveM's GiveWeaponToPed does a ped: every player's copy carries the weapon with ammunition and wears it locked, so the game that runs it fights with it and everyone sees it. It lasts while the NPC does, through respawns.
+     * @param weapon A weapon (WEAP) by form ID or editor ID, such as `"Minigun"`; null hands the NPC back its own.
+     * @returns True when sent; false when the NPC is gone. Throws for a form no WEAP record has.
+     */
+    giveWeapon(weapon: number | string | null): boolean;
+
+    /**
+     * Drops the order `attack` gave: the NPC stops fighting, as Actor.StopCombat does.
+     * @returns True when it had one.
+     */
+    stopAttacking(): 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.
@@ -1381,6 +2677,24 @@ declare global {
      */
     teleport(position: Vector3, heading?: number): boolean;
 
+    /**
+     * The NPCs around a point or a player, nearest first, as FiveM scripts walk the ped pool or ask GetClosestPed: where a script finds the shopkeeper by a door or the raiders near a camp. Positions are the ones the simulators last reported.
+     * @param center A point, or a player, whose position and space are then the search's.
+     * @param radius How far from it, in game units.
+     * @param options `space`: where a point is, the Commonwealth when left out. `limit`: how many at most, 32 by default, never more than 512. `includeDead`: count the dead too.
+     * @returns Empty when none is in range, or the player is gone. Throws for a center that is neither, or a negative radius.
+     */
+    static getInRange(center: Vector3 | Player, radius: number, options?: { space?: { worldSpace: number } | { interiorCell: number }; limit?: number; includeDead?: boolean }): Npc[];
+
+    /**
+     * Makes a new NPC, as a FiveM script creates a ped: every player's game builds it, a client near it runs it with the game's own AI and the server walks it while nobody is near, as it does the placed ones. Unique, essential and quest actors are each player's own: spawn generic ones. It stays dead when killed (`npcDeath` is raised) until `respawn` puts it back where it was spawned.
+     * @param base What to make: an NPC record (NPC_) or a leveled list of them (LVLN, rolled here), by form ID or editor ID, such as `"LCharRaider"` or `"EncRaider01"`.
+     * @param position Where it stands, in game units.
+     * @param options `heading` in radians around Z (0 faces +Y); `space` the worldspace or interior cell, the Commonwealth when left out.
+     * @returns The new NPC; null when a leveled list rolled to nothing. Throws for a base that is no NPC_ or LVLN record.
+     */
+    static spawn(base: number | string, position: Vector3, options?: { heading?: number; space?: { worldSpace: number } | { interiorCell: number } }): Npc | null;
+
     /**
      * Every NPC the server took over.
      * @returns One handle per NPC; empty when the server could not read the game's data files.
@@ -1448,15 +2762,16 @@ declare global {
     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.
+     * 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. A wire is laid out between its two ends on every client once both are loaded, and linked into their power grid.
      * @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.
+     * @param wire For a wire (the game's workshop spline), the two objects it joins: a built object, or a placed reference's form ID, each with the connect point the wire takes on it (0 by default).
      * @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;
+    static place(form: number | string, workbench: number | string, position: Vector3, space: { worldSpace?: number | string; interiorCell?: number | string }, angle?: Vector3, wire?: { from: WorkshopItem | number | string; to: WorkshopItem | number | string; fromPoint?: number; toPoint?: number }): WorkshopItem | null;
 
     /**
      * Every object built this session.
@@ -2306,31 +3621,31 @@ declare global {
     /**
      * Broadcasts a named event to every connected client's shared Events handlers.
      * @param eventName Client shared-event name.
-     * @param payload Optional string payload sent verbatim; other values are JSON-serialized.
+     * @param payload Optional payload. A string is sent as is and must already be JSON text: each client parses it and drops an event that does not parse. Other values are JSON-serialized.
      */
     emitAllClients(eventName: string, payload?: unknown): void;
 
     /**
      * Registers a persistent server handler for events originating from clients; this namespace is isolated from native events.
      * @param eventName Case-sensitive event name.
-     * @param handler Resource-owned callback invoked with the emitted arguments.
+     * @param handler Resource-owned callback invoked with the sending player and the parsed payload, which is absent when the client sent none. The payload is untrusted.
      * @returns Function that removes this exact subscription.
      */
-    onClient(eventName: string, handler: EventHandler): Unsubscribe;
+    onClient(eventName: string, handler: (player: Player, payload?: unknown) => unknown | Promise<unknown>): Unsubscribe;
 
     /**
      * Registers a one-shot server handler for a client-originated event.
      * @param eventName Case-sensitive event name.
-     * @param handler Resource-owned callback invoked with the emitted arguments.
+     * @param handler Resource-owned callback invoked with the sending player and the parsed payload, which is absent when the client sent none. The payload is untrusted.
      */
-    onceClient(eventName: string, handler: EventHandler): void;
+    onceClient(eventName: string, handler: (player: Player, payload?: unknown) => unknown | Promise<unknown>): void;
 
     /**
      * Removes a matching client-originated event handler owned by the calling resource.
      * @param eventName Case-sensitive event name.
-     * @param handler Resource-owned callback invoked with the emitted arguments.
+     * @param handler Resource-owned callback invoked with the sending player and the parsed payload, which is absent when the client sent none. The payload is untrusted.
      */
-    offClient(eventName: string, handler: EventHandler): void;
+    offClient(eventName: string, handler: (player: Player, payload?: unknown) => unknown | Promise<unknown>): void;
   }
 
   /**
@@ -2621,6 +3936,11 @@ declare global {
      */
     readonly discordId: string;
 
+    /**
+     * Discord username the client reported, or an empty string when it had none.
+     */
+    readonly discordName: string;
+
     /**
      * Framework hardware identifier the client reported, or an empty string when it had none.
      */
@@ -2791,6 +4111,11 @@ declare global {
      */
     readonly discordId: string;
 
+    /**
+     * Discord username the client reported, not verified by the server, or an empty string when unavailable.
+     */
+    readonly discordName: string;
+
     /**
      * Framework hardware identifier, or an empty string when unavailable.
      */