@falloutmp/types 0.3.1 → 0.3.2

package/generated/server-api.d.ts

@@ -46,9 +46,14 @@ 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.
@@ -95,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.
      */
@@ -170,6 +190,16 @@ 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.
      */
@@ -336,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.
@@ -350,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`.
      */
@@ -559,6 +604,11 @@ 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`.
      */
@@ -689,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.
@@ -836,6 +914,50 @@ declare global {
      */
     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.
@@ -1091,6 +1213,55 @@ declare global {
      */
     setGameSetting(name: string, value: number | boolean): boolean;
 
+    /**
+     * 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.
+     */
+    setVatsRolledByServer(enabled: boolean): boolean;
+
+    /**
+     * 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): boolean;
+
+    /**
+     * 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.
+     */
+    setHour(hour: number | null): boolean;
+
+    /**
+     * The weather `setWeather` gave the player alone.
+     * @returns Null while they follow `World.weather`, or once they are gone.
+     */
+    getWeather(): number | null;
+
+    /**
+     * 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.
+     */
+    strikeLightning(): boolean;
+
+    /**
+     * 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.
+     */
+    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.
@@ -1108,7 +1279,77 @@ declare global {
   interface Player extends BasePlayer {}
 
   /**
-   * The server's clock and weather, which every client follows.
+   * 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: {
     /**
@@ -1121,6 +1362,16 @@ declare global {
      */
     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.
      */
@@ -1132,7 +1383,17 @@ declare global {
     readonly weatherForced: boolean;
 
     /**
-     * Sets the clock. Every client jumps to it.
+     * 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;
@@ -1144,11 +1405,164 @@ declare global {
     setTimeScale(scale: number): void;
 
     /**
-     * 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.
+     * 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;
   };
 
   /**
@@ -1183,6 +1597,36 @@ declare global {
      */
     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.
@@ -1385,6 +1829,47 @@ declare global {
     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.
    */
@@ -1593,7 +2078,228 @@ declare global {
   interface RadioStation extends Entity {}
 
   /**
-   * A non-player actor the server took over from the data files: the generic placed ones, not the unique, essential or quest actors, which stay each client's own. A client near it runs it with the game's own AI and reports its health; nobody near, the server walks it. It lives for the whole session and comes back on its own a while after it dies. Move it with `teleport`, not by setting `position`.
+   * 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.
+     */
+    toString(): string;
+
+    /**
+     * 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.
+     */
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
+
+    /**
+     * 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.
+     */
+    attachTo(target: Player | Npc | null): boolean;
+
+    /**
+     * Whom the blip follows.
+     * @returns Null for a blip at a point, or once that body is gone.
+     */
+    getAttached(): Player | Npc | null;
+
+    /**
+     * 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.
+     */
+    setPlayer(player: Player | null): boolean;
+
+    /**
+     * The one player who sees the blip.
+     * @returns Null while everyone does.
+     */
+    getPlayer(): Player | null;
+
+    /**
+     * Changes what the Pip-Boy map's tooltip says.
+     * @param label Up to 63 bytes of UTF-8.
+     * @returns False once it is gone.
+     */
+    setLabel(label: string): boolean;
+
+    /**
+     * 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.
+     */
+    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 blip.
+     * @returns One handle per blip.
+     */
+    static all(): Blip[];
+  }
+
+  interface Blip extends Entity {}
+
+  /**
+   * 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 TextLabel {
+    /**
+     * Wraps the label with this ID; it creates nothing.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * What it says; empty once it is gone.
+     */
+    readonly text: string;
+
+    /**
+     * Takes the label off every player's screen.
+     * @returns False once it is gone.
+     */
+    destroy(): boolean;
+
+    /**
+     * Formats this handle for logging.
+     * @returns The label's network ID and text.
+     */
+    toString(): string;
+
+    /**
+     * 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.
+     */
+    setText(text: string): boolean;
+
+    /**
+     * Changes the text's color.
+     * @param color 0xRRGGBBAA: 0xFFFFFFFF is opaque white.
+     * @returns False once it is gone.
+     */
+    setColor(color: number): boolean;
+
+    /**
+     * 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.
+     */
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
+
+    /**
+     * 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 checkpoint's network ID and radius.
+     */
+    toString(): string;
+
+    /**
+     * Changes its color.
+     * @param color 0xRRGGBBAA; the alpha is the wall's, the rim is drawn more solid.
+     * @returns False once it is gone.
+     */
+    setColor(color: number): boolean;
+
+    /**
+     * Widens or narrows it.
+     * @param radius Game units, above 0 and at most 5000.
+     * @returns False once it is gone.
+     */
+    setRadius(radius: number): boolean;
+
+    /**
+     * 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.
+     */
+    setPosition(position: Vector3, space?: { worldSpace: number } | { interiorCell: number }): boolean;
+
+    /**
+     * 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 create(options: { position: Vector3; radius?: number; height?: number; color?: number; range?: number; space?: { worldSpace: number } | { interiorCell: number }; player?: Player }): Checkpoint | null;
+
+    /**
+     * Every checkpoint.
+     * @returns One handle per checkpoint.
+     */
+    static all(): Checkpoint[];
+  }
+
+  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. 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 {
     /**
@@ -1603,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;
 
@@ -1637,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.
      */
@@ -1648,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.
@@ -1672,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.
@@ -1692,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.
@@ -1700,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.
@@ -1767,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.