@falloutmp/types 0.2.5 → 0.3.1

package/generated/client-api.d.ts

@@ -80,6 +80,11 @@ declare global {
      */
     inventoryChange: [changes: InventoryDelta[]];
 
+    /**
+     * Dispatched when the local player activates a reference: the Activate button, a prompt, a pick-up. `ref` is the placed reference's form ID, `base` its base object's. It tells of the attempt, which the game may still refuse; a reference with an activate parent raises one for the parent first. To stop an activation, block it beforehand with References.setActivationBlocked or Controls.setEnabled.
+     */
+    activate: [ref: number, base: number];
+
     /**
      * Dispatched when the local player opens or closes a door the session shares, as the server is told. `ref` is the placed reference's form ID.
      */
@@ -120,6 +125,11 @@ declare global {
      */
     workshopMove: [form: number, position: { x: number; y: number; z: number }];
 
+    /**
+     * Dispatched when the local player enters workshop mode at a workbench (`entering`) and when they leave it. `workbench` is the workbench reference's form ID.
+     */
+    workshopMode: [workbench: number, entering: boolean];
+
     /**
      * Dispatched when the local player scraps or stores a built object the session shares.
      */
@@ -199,6 +209,26 @@ declare global {
      * Dispatched on view creation and whenever Web.loadURL re-locks an owned view to a different origin.
      */
     browserOriginChange: [event: BrowserOriginChangeEvent];
+
+    /**
+     * Dispatched for every chat line the server sends. An empty author is a notice line; color is packed 0xRRGGBBAA, 0 for the chat box's default.
+     */
+    chatMessage: [message: { author: string; text: string; color: number }];
+
+    /**
+     * Dispatched synchronously for a line the player typed into the chat box, before it is sent. A handler returning false, not a Promise of it, blocks it; Chat.send does not raise this.
+     */
+    chatSend: [text: string];
+
+    /**
+     * Dispatched when the local player starts speaking, as isTalking turns true.
+     */
+    voiceStart: [];
+
+    /**
+     * Dispatched when the local player stops speaking, as isTalking turns false.
+     */
+    voiceStop: [];
   }
 
   /** Names of native events available in this scripting environment. */
@@ -215,6 +245,56 @@ declare global {
      */
     notify(message: string, sound?: string): void;
 
+    /**
+     * Plays a Vault Boy clip on the HUD, the animation a perk shows when it triggers, as Game.ShowPerkVaultBoyOnHUD does.
+     * @param swf The clip's path under Interface, such as "Components/VaultBoys/Perks/PerkClip_1d247c.swf".
+     * @param sound A sound descriptor's editor ID to play with it, such as "UIPerkRicochet".
+     * @returns False when the path is empty or the sound is not one the game knows; the clip still plays without it.
+     */
+    showVaultBoy(swf: string, sound?: string): boolean;
+
+    /**
+     * Shows a place name on the HUD, as the game does on coming up to a location the player knows: a zone a script defines announces itself this way.
+     * @param name The name to show.
+     * @returns False for an empty name.
+     */
+    showLocation(name: string): boolean;
+
+    /**
+     * Turns one of the HUD's own modes on or off, as Game.SetInsideMemoryHUDMode and Game.SetCharGenHUDMode do for theirs: the HUD shows, hides and restyles its parts by the modes that are on. A mode a script turned on stays until it turns it off; the game switches its own as before.
+     * @param mode The mode's name as the game knows it: "PowerArmor", "InsideMemory", "DialogueMode", "IronSights", "VATS", "WorkshopMode", "CharGen_Init" and the like.
+     * @param on On or off.
+     * @returns False for an empty name. A name the HUD does not know changes nothing.
+     */
+    setMode(mode: string, on: boolean): boolean;
+
+    /**
+     * Flashes the hit marker around the crosshair, as the game does when a sneak attack or a critical lands: the cue for a hit the server confirmed.
+     */
+    showHitMarker(): void;
+
+    /**
+     * Keeps the health or the action point bar on the HUD. The game hides each while it is full and nothing touches it; this holds one up until it is let go.
+     * @param meter Which bar.
+     * @param shown Kept up, or left to the HUD again.
+     */
+    setMeterShown(meter: "health" | "actionPoints", shown: boolean): void;
+
+    /**
+     * Blinks the health or the action point bar, as the game blinks the action points when an attack needs more than are left. A bar the HUD is hiding blinks unseen: keep it up with `setMeterShown` first.
+     * @param meter Which bar.
+     * @returns False when the game has no such actor value.
+     */
+    flashMeter(meter: "health" | "actionPoints"): boolean;
+
+    /**
+     * Shows a quest objective line on the HUD with any text, alone or under a banner shown just before, with the game's own sound and timing.
+     * @param text The line's text, shown as given: the game's own completed and failed lines open with "Completed: " and "Failed: ".
+     * @param kind A new objective, by default, or one drawn as done.
+     * @returns False when the quest that lends the objective is not loaded.
+     */
+    showObjective(text: string, kind?: "added" | "completed" | "failed"): boolean;
+
     /**
      * Shows the HUD's quest banner with any text. Banners queue behind the game's own. False when the quest that lends the icon is not loaded.
      * @param text The banner's text.
@@ -268,6 +348,14 @@ declare global {
    * The game's own menus, message boxes and dialogue wheel.
    */
   const Ui: {
+    /**
+     * Plays a Bink video over the game, as Game.PlayBink does: an intro, a cutscene between rounds. `Ui.hideMenu("PlayBinkMenu")` ends it early; `Ui.isMenuOpen("PlayBinkMenu")` tells when it is over.
+     * @param file The video's file name under Data/Video, such as "Intro.bk2": a name alone, no path.
+     * @param options Whether a key ends it (default false), whether it is letterboxed (default true), and whether the game's sound and music are silenced while it plays (default true).
+     * @returns False for an empty name or one that is not a bare file name.
+     */
+    playVideo(file: string, options?: { interruptible?: boolean; letterbox?: boolean; muteAudio?: boolean; muteMusic?: boolean }): boolean;
+
     /**
      * Opens a game menu by name. Takes effect next frame; an unknown name does nothing.
      * @param name The menu's registered name, such as "PipboyMenu".
@@ -447,6 +535,36 @@ declare global {
      */
     getFov(): { horizontal: number; vertical: number } | null;
 
+    /**
+     * Whether the player's camera is in its first-person state.
+     * @returns False in third person and in every other state: the fly camera, furniture, a scripted camera.
+     */
+    isFirstPerson(): boolean;
+
+    /**
+     * Puts the player's camera in first person, as Game.ForceFirstPerson does. The game only does it while the camera follows the player.
+     * @returns False before the camera exists.
+     */
+    forceFirstPerson(): boolean;
+
+    /**
+     * Makes the camera follow another body in third person, as Game.SetCameraTarget does: what a spectator mode is built on. The player's own body stays where it is and still takes its input; the camera comes back by itself when the body followed leaves this game.
+     * @param entityId The network ID of a player or an NPC, as the server knows it (`player.id`); null for the player's own body.
+     * @returns False when no such player or NPC has a body loaded here.
+     */
+    setTarget(entityId: number | null): boolean;
+
+    /**
+     * The network ID of the body the camera was told to follow; null while it follows the player's own.
+     */
+    getTarget(): number | null;
+
+    /**
+     * Puts the player's camera in third person, as Game.ForceThirdPerson does. The game refuses from some states, such as furniture, and waits for an open menu to close.
+     * @returns False before the camera exists.
+     */
+    forceThirdPerson(): boolean;
+
     /**
      * The game's back buffer, in pixels: the space worldToScreen answers in.
      */
@@ -461,6 +579,58 @@ declare global {
     worldToScreen(x: number, y: number, z: number): { x: number; y: number; onScreen: boolean } | null;
   };
 
+  /**
+   * The game's own tuning values (game settings, GMST) in this player's game: how high a jump goes, how fast a sprint is, what a lock costs to pick. The game reads them where they stand, so a change takes effect at once, for this player alone; a server sets the same on every client to make it a rule. What a script changed goes back to what it was when the session ends.
+   */
+  const GameSettings: {
+    /**
+     * A game setting's value.
+     * @param name The setting's name as the game's data defines it: "fJumpHeightMin", "fSprintSpeedMult", "iMaxCharacterLevel". The first letter says what it holds: f a number, i and u a whole number, b a boolean, s a text.
+     * @returns Null when the game has no setting of that name.
+     */
+    get(name: string): number | boolean | string | null;
+
+    /**
+     * Changes a game setting for this player's game, until the session ends.
+     * @param name The setting's name as the game's data defines it: "fJumpHeightMin", "fSprintSpeedMult", "iMaxCharacterLevel". The first letter says what it holds: f a number, i and u a whole number, b a boolean, s a text.
+     * @param value The new value, of the setting's kind.
+     * @returns False when the game has no setting of that name, it holds a text, or the value is not of its kind.
+     */
+    set(name: string, value: number | boolean): boolean;
+  };
+
+  /**
+   * The local player's controls, on a layer of the game's own input locks: a control the game itself holds off stays off.
+   */
+  const Controls: {
+    /**
+     * Turns one control off or back on. Everything comes back on disconnect.
+     * @param control Which control.
+     * @param enabled False holds it off.
+     * @returns False when the game had no free layer.
+     */
+    setEnabled(control: "movement" | "looking" | "fighting" | "sneaking" | "menu" | "jumping" | "journal" | "activate" | "fastTravel" | "camSwitch" | "vats" | "favorites" | "zKey" | "running" | "sprinting", enabled: boolean): boolean;
+
+    /**
+     * Whether every layer, the game's included, lets the control through.
+     * @param control Which control.
+     * @returns True when it is on.
+     */
+    isEnabled(control: "movement" | "looking" | "fighting" | "sneaking" | "menu" | "jumping" | "journal" | "activate" | "fastTravel" | "camSwitch" | "vats" | "favorites" | "zKey" | "running" | "sprinting"): boolean;
+
+    /**
+     * Whether a script holds the control off, whatever the game's own layers do.
+     * @param control Which control.
+     * @returns True when setEnabled turned it off.
+     */
+    isDisabledByScripts(control: "movement" | "looking" | "fighting" | "sneaking" | "menu" | "jumping" | "journal" | "activate" | "fastTravel" | "camSwitch" | "vats" | "favorites" | "zKey" | "running" | "sprinting"): boolean;
+
+    /**
+     * Gives back everything scripts held off.
+     */
+    reset(): void;
+  };
+
   /**
    * Markers on the local player's HUD compass and Pip-Boy map, drawn by the game's own widgets. Only this client sees them; they go when the resource that made them stops.
    */
@@ -748,6 +918,139 @@ declare global {
      */
     getOutfit(): OutfitPiece[];
 
+    /**
+     * Whether the player's Pip-Boy light is on.
+     * @returns False before the player exists.
+     */
+    isPipboyLightOn(): boolean;
+
+    /**
+     * Turns the player's Pip-Boy light on or off, as the light key does, without its sound.
+     * @param on On or off.
+     * @returns False before the player stands in the world.
+     */
+    setPipboyLight(on: boolean): boolean;
+
+    /**
+     * Puts the player into a piece of furniture at once, wherever they stand, as Actor.SnapIntoInteraction does: a chair seats them, a bed lays them down, once its animations are loaded. A seated player stands up by moving; one lying in a bed is there until leaveFurniture.
+     * @param furniture The furniture reference: a chair, a bed, a workbench.
+     * @returns False before the player stands in the world, while they are down or dead, when the furniture is not loaded here or would not take them.
+     */
+    useFurniture(furniture: number | string): boolean;
+
+    /**
+     * Has the player get up from the furniture they are in, or stop making for it.
+     * @returns False when they are in none.
+     */
+    leaveFurniture(): boolean;
+
+    /**
+     * Whether the player is in a piece of furniture: seated, lying asleep, or on their way in or out of one.
+     */
+    getFurnitureState(): "none" | "sitting" | "sleeping" | "moving";
+
+    /**
+     * Holds the player in place, as Actor.SetRestrained does: they stand where they are and neither move nor act until let go. Cuffs, a stun, a cutscene.
+     * @param restrained Held, or let go.
+     * @returns False before the player stands in the world, or while they are down or dead.
+     */
+    setRestrained(restrained: boolean): boolean;
+
+    /**
+     * Knocks the player off their feet into their ragdoll, as ObjectReference.PushActorAway does: they fall, lie a moment and get up by themselves. Every other player sees them fall and get up.
+     * @param force How hard they are thrown, as ObjectReference.PushActorAway takes it; 0, the default, drops them where they stand.
+     * @param from The point they are thrown away from; their own position by default.
+     * @returns False before the player stands in the world, while they are dead, down already, bleeding out, held in place or in furniture.
+     */
+    knockDown(force?: number, from?: { x: number; y: number; z: number }): boolean;
+
+    /**
+     * Whether the player is knocked down: in their ragdoll or getting up from it, by a script or by the game, a blast for one.
+     */
+    isKnockedDown(): boolean;
+
+    /**
+     * Puts the player into the game's bleedout, or gets them out of it: down on the ground and alive, the camera pulled out, the controls held, as a downed companion is. Every other player sees them down. Nothing kills them there, as nothing kills a downed companion; they stay until a script gets them up or the session ends, and get up at full health.
+     * @param bleedingOut True to go down, false to get back up.
+     * @returns False before the player stands in the world, while they are dead or held in place.
+     */
+    setBleedingOut(bleedingOut: boolean): boolean;
+
+    /**
+     * Whether the player is in the game's bleedout.
+     */
+    isBleedingOut(): boolean;
+
+    /**
+     * Whether the player is held in place by `setRestrained`.
+     */
+    isRestrained(): boolean;
+
+    /**
+     * Plays a holotape recording in the player's Pip-Boy, in place of the one in it, without the loading animation: the radio goes quiet while it runs, as when the player loads one. Seen and heard in this game alone.
+     * @param holotape The holotape's form ID. It need not be carried.
+     * @returns False when the form is no holotape, holds no recording (a game or a terminal tape), or would not start.
+     */
+    playHolotape(holotape: number | string): boolean;
+
+    /**
+     * Stops the player's holotape and takes it out.
+     * @returns False when there was none.
+     */
+    stopHolotape(): boolean;
+
+    /**
+     * The holotape in the player's Pip-Boy and whether it runs now; null for none.
+     */
+    getHolotape(): { form: number; playing: boolean } | null;
+
+    /**
+     * The named location the player is in, a BGSLocation form ID, as ObjectReference.GetCurrentLocation reads it.
+     * @returns Null in the open, where the game names no location.
+     */
+    getLocation(): number | null;
+
+    /**
+     * Where the player's own map marker is: the waypoint dropped on the Pip-Boy map.
+     * @returns Null while there is none.
+     */
+    getMapWaypoint(): { x: number; y: number; z: number } | null;
+
+    /**
+     * Drops the player's own map marker, or takes it off, as they would on the Pip-Boy map: the server's `playerMapWaypoint` hears of it and may put back what was there.
+     * @param position Where to, in the space the player stands in; null takes it off.
+     * @returns False before the player stands in the world.
+     */
+    setMapWaypoint(position: { x: number; y: number; z: number } | null): boolean;
+
+    /**
+     * Asks to fast travel to a reference, as picking it on the Pip-Boy map does: the server's `playerFastTravel` decides, and the player travels when no script refuses.
+     * @param destination The reference to arrive at: a map marker, or any other placed reference.
+     * @returns True when asked; false when the reference is not here or the player does not stand in the world.
+     */
+    fastTravel(destination: number | string): boolean;
+
+    /**
+     * Draws the player's body more or less see-through in this game, as Actor.SetAlpha does. Other players' games are not told.
+     * @param alpha 0, invisible, to 1, opaque.
+     * @param fade Fade there rather than cut (default false).
+     * @returns False before the player stands in the world.
+     */
+    setAlpha(alpha: number, fade?: boolean): boolean;
+
+    /**
+     * Whether the game holds the player invulnerable: setInvulnerable, or the game's own god mode.
+     * @returns False before the player exists.
+     */
+    isInvulnerable(): boolean;
+
+    /**
+     * Makes the player a ghost, as Actor.SetGhost does: attacks in their own game pass through them, and their game refuses the hits other players' games land on them.
+     * @param invulnerable The flag.
+     * @returns False before the player exists.
+     */
+    setInvulnerable(invulnerable: boolean): boolean;
+
     /**
      * The power armor frame the player wears.
      * @returns Null when they wear none, and outside a session.
@@ -851,6 +1154,30 @@ declare global {
     counterpart: number | null;
   }
 
+  /**
+   * The local player's workshop mode: the settlement build mode a workbench opens.
+   */
+  const Workshop: {
+    /**
+     * The workbench the player's workshop mode runs on, its reference's form ID.
+     * @returns Null outside workshop mode.
+     */
+    getCurrent(): number | null;
+
+    /**
+     * Puts the player in workshop mode on a workbench, wherever they stand, as ObjectReference.StartWorkshop does.
+     * @param workbench A workbench reference loaded in this game.
+     * @returns False when it is no loaded workbench or the player is in workshop mode already.
+     */
+    enter(workbench: number | string): boolean;
+
+    /**
+     * Ends workshop mode, as leaving its menu does; the game does it on its next frame.
+     * @returns False outside workshop mode.
+     */
+    leave(): boolean;
+  };
+
   /**
    * The server's clock and sky, as this client holds them. Read-only: the server's `World` sets them.
    */
@@ -872,6 +1199,13 @@ declare global {
      * @returns Null while the region decides the weather, and before the server's world streams in.
      */
     getWeather(): number | null;
+
+    /**
+     * What a weather is, from this game's data: its kind, its wind from 0 to 1, where its fog starts and ends by day and by night in game units, and the precipitation and screen effect it comes with.
+     * @param weather A weather (WTHR) by form ID; the one the sky is in or moving to when left out.
+     * @returns Null when the form is not a weather, or the sky has none yet.
+     */
+    getWeatherInfo(weather?: number | string): { weather: number; kind: "none" | "pleasant" | "cloudy" | "rain" | "snow"; windSpeed: number; fog: { dayNear: number; dayFar: number; nightNear: number; nightFar: number; dayPower: number; nightPower: number; dayMax: number; nightMax: number }; precipitation: number | null; visualEffect: number | null } | null;
   };
 
   /**
@@ -883,6 +1217,241 @@ declare global {
      * @returns One entry per station, in no particular order; empty outside a session.
      */
     getStations(): { name: string; frequency: number }[];
+
+    /**
+     * Whether the player's Pip-Boy radio is on, as Game.IsPlayerRadioOn reads it.
+     * @returns False while it is off or the player has no radio.
+     */
+    isOn(): boolean;
+
+    /**
+     * Turns the player's Pip-Boy radio on or off, as Game.TurnPlayerRadioOn does.
+     * @param on On or off.
+     */
+    setOn(on: boolean): void;
+
+    /**
+     * The frequency the player's Pip-Boy radio is tuned to, as Game.GetPlayerRadioFrequency reads it.
+     * @returns 0 while the player has no radio.
+     */
+    getFrequency(): number;
+
+    /**
+     * Tunes the player's Pip-Boy radio, as Game.SetPlayerRadioFrequency does.
+     * @param frequency A station's frequency, as getStations lists it.
+     */
+    setFrequency(frequency: number): void;
+  };
+
+  /**
+   * The state of a placed reference in this player's game alone. Nothing here reaches another player: a script that wants everyone to agree tells each client.
+   */
+  const References: {
+    /**
+     * Has the local player activate the reference, wherever they stand, as ObjectReference.Activate does: a door opens, an item is picked up, a container shows its menu. Raises `activate` like any other.
+     * @param ref The reference's form ID.
+     * @param defaultProcessingOnly Skip what the reference's own scripts would do about it (default false).
+     * @returns False when the reference is not loaded here or the game activated nothing.
+     */
+    activate(ref: number | string, defaultProcessingOnly?: boolean): boolean;
+
+    /**
+     * What a reference is and where it stands: the form ID of the base object it is placed from, its position in world units and its rotation in radians about the X, Y and Z axes.
+     * @param ref The reference's form ID.
+     * @returns Null when the reference is not here.
+     */
+    getInfo(ref: number | string): { base: number; position: { x: number; y: number; z: number }; rotation: { x: number; y: number; z: number } } | null;
+
+    /**
+     * The placed references around the player, nearest first: what a script looks the world up by before it reads or changes a reference. It walks the cells loaded in this game, so call it when needed, not every frame. Actors are not references here.
+     * @param base The base object the references are placed from, such as a container's or a door's form ID; null for any.
+     * @param radius How far from the player, in world units.
+     * @param limit How many at most (default 32, never more than 512).
+     * @returns Empty before the player stands in the world, or when the base is no form.
+     */
+    find(base: number | string | null, radius: number, limit?: number): number[];
+
+    /**
+     * Sends an animation event to the reference's behavior graph, as ObjectReference.PlayAnimation does: a machine starts, a prop moves, without the activation and what it would trigger. Seen in this game alone. Only objects animated by a behavior graph take one; `getAnimationGraph` tells which are.
+     * @param ref The reference's form ID.
+     * @param event The animation event's name, as the object's behavior graph knows it.
+     * @returns False when the reference is not loaded here or no graph of its took the event.
+     */
+    playAnimation(ref: number | string, event: string): boolean;
+
+    /**
+     * The name of the behavior graph that animates the reference, the one `playAnimation` sends its events to.
+     * @param ref The reference's form ID.
+     * @returns Null when the reference is not loaded here or no behavior graph animates it.
+     */
+    getAnimationGraph(ref: number | string): string | null;
+
+    /**
+     * Says whether the physics moves an object, as ObjectReference.SetMotionType does: freeze a crate in mid-air, or let a fixed prop fall. In this game alone.
+     * @param ref The reference's form ID.
+     * @param type Dynamic: the physics moves it, so it falls and can be pushed. Keyframed: it stays where it is put, whatever hits it.
+     * @returns False when the reference is not loaded here or its model has no physics.
+     */
+    setMotionType(ref: number | string, type: "dynamic" | "keyframed"): boolean;
+
+    /**
+     * Pushes an object the physics moves, as ObjectReference.ApplyHavokImpulse does: a can flies, a crate slides. In this game alone, as its physics are.
+     * @param ref The reference's form ID.
+     * @param direction Which way to push, in world axes; its length does not matter.
+     * @param magnitude How hard, as ObjectReference.ApplyHavokImpulse takes it; the game scales it by the object's mass.
+     * @returns False when the reference is not loaded here or nothing of it is a physics body. A body the physics holds fixed takes the push and stays where it is.
+     */
+    applyImpulse(ref: number | string, direction: { x: number; y: number; z: number }, magnitude: number): boolean;
+
+    /**
+     * The form ID of the actor that stands for another player or an NPC in this game: what `openTrade` and `showBarterMenu` take. A session's players and NPCs are this game's own copies, so the reference ID the server knows an NPC by is not theirs; this one is good only here and only while the body is loaded.
+     * @param entityId The network ID of a player or an NPC, as the server knows it (`player.id`, `npc.id`).
+     * @returns Null for the local player and for an entity with no body loaded here.
+     */
+    getEntityBody(entityId: number): number | null;
+
+    /**
+     * Holds an actor in place, as Actor.SetRestrained does: it stays as it is and its own behavior stops until it is let go. It holds while this game simulates the actor.
+     * @param actor The actor's form ID in this game, as `getEntityBody` gives it.
+     * @param restrained Held, or let go.
+     * @returns False when the actor is not loaded here, or is down or dead.
+     */
+    setActorRestrained(actor: number | string, restrained: boolean): boolean;
+
+    /**
+     * Puts an actor into a piece of furniture at once, without walking to it, as Actor.SnapIntoInteraction does: a chair seats it, a bed lays it down asleep. It lasts while this game simulates the actor and its own behavior leaves it there.
+     * @param actor The actor's form ID in this game, as `getEntityBody` gives it.
+     * @param furniture The furniture reference: a chair, a bed, a workbench.
+     * @returns False when the actor or the furniture is not loaded here, or the furniture would not take it.
+     */
+    useFurniture(actor: number | string, furniture: number | string): boolean;
+
+    /**
+     * Opens the game's container menu on a container, wherever the player stands, as activating it does but without its lock or its opening animation. In a session the server's `containerOpen` runs first and the menu opens once it lets the player in, holding what a server script filled the container with there: a stash or a shop of the player's own.
+     * @param ref The reference's form ID.
+     * @returns False when the reference is not loaded here or is no container, when another player has it open, or while this player has a container open.
+     */
+    openContainer(ref: number | string): boolean;
+
+    /**
+     * Opens the give-and-take screen on an actor, the one the game shows for a companion, as Actor.OpenInventory does when forced.
+     * @param ref The reference's form ID.
+     * @returns False when the reference is no actor loaded here.
+     */
+    openTrade(ref: number | string): boolean;
+
+    /**
+     * Opens the game's barter screen on an actor, as Actor.ShowBarterMenu does: it sells what the game works out as that actor's vendor stock.
+     * @param ref The reference's form ID.
+     * @returns False when the reference is no actor loaded here.
+     */
+    showBarterMenu(ref: number | string): boolean;
+
+    /**
+     * An actor value on the reference, as ObjectReference.GetValue reads it. A workbench keeps its settlement's figures this way: its build budget, its population, its power.
+     * @param ref The reference's form ID.
+     * @param value An ActorValueInfo form ID.
+     * @returns Null when the reference is not here or the form ID is no actor value.
+     */
+    getValue(ref: number | string, value: number | string): number | null;
+
+    /**
+     * Sets an actor value on the reference, as ObjectReference.SetValue does.
+     * @param ref The reference's form ID.
+     * @param value An ActorValueInfo form ID.
+     * @param amount The new value.
+     * @returns False when the reference is not here or the form ID is no actor value.
+     */
+    setValue(ref: number | string, value: number | string, amount: number): boolean;
+
+    /**
+     * A map marker's state on this player's map: whether it shows, whether it is a fast travel destination, and its icon type. The server changes it with `Player.discoverLocations` and `forgetLocations`.
+     * @param ref The reference's form ID.
+     * @returns Null when the reference is not here or is no map marker.
+     */
+    getMapMarker(ref: number | string): { visible: boolean; canTravel: boolean; type: number } | null;
+
+    /**
+     * Whether the reference is in this game with its 3D loaded.
+     * @param ref The reference's form ID.
+     * @returns False when it is not here.
+     */
+    isLoaded(ref: number | string): boolean;
+
+    /**
+     * The reference's scale, 1 being its normal size.
+     * @param ref The reference's form ID.
+     * @returns Null when it is not here.
+     */
+    getScale(ref: number | string): number | null;
+
+    /**
+     * Scales the reference.
+     * @param ref The reference's form ID.
+     * @param scale 0.01 to 10.
+     * @returns False when it is not here.
+     */
+    setScale(ref: number | string, scale: number): boolean;
+
+    /**
+     * The level a pick attempt on the reference's lock faces.
+     * @param ref The reference's form ID.
+     * @returns Null when it is not here or has no lock.
+     */
+    getLockLevel(ref: number | string): number | null;
+
+    /**
+     * Sets the level of the reference's lock; one with no lock gets an unlocked one.
+     * @param ref The reference's form ID.
+     * @param level 0 to 255.
+     * @returns False when it is not here.
+     */
+    setLockLevel(ref: number | string, level: number): boolean;
+
+    /**
+     * The game's destroyed flag.
+     * @param ref The reference's form ID.
+     * @returns False when it is not here.
+     */
+    isDestroyed(ref: number | string): boolean;
+
+    /**
+     * Sets the game's destroyed flag: a destroyed reference cannot be activated.
+     * @param ref The reference's form ID.
+     * @param destroyed The flag.
+     * @returns False when it is not here.
+     */
+    setDestroyed(ref: number | string, destroyed: boolean): boolean;
+
+    /**
+     * Whether a flora or produce reference is picked.
+     * @param ref The reference's form ID.
+     * @returns False when it is not here.
+     */
+    isHarvested(ref: number | string): boolean;
+
+    /**
+     * Shows a flora or produce reference picked, or grown back.
+     * @param ref The reference's form ID.
+     * @param harvested The flag.
+     * @returns False when it is not here or is neither.
+     */
+    setHarvested(ref: number | string, harvested: boolean): boolean;
+
+    /**
+     * Whether activating the reference is refused.
+     * @param ref The reference's form ID.
+     * @returns False when it is not here.
+     */
+    isActivationBlocked(ref: number | string): boolean;
+
+    /**
+     * Blocks or allows activating the reference.
+     * @param ref The reference's form ID.
+     * @param blocked The flag.
+     * @returns False when it is not here.
+     */
+    setActivationBlocked(ref: number | string, blocked: boolean): boolean;
   };
 
   /**
@@ -1695,7 +2264,7 @@ declare global {
     /**
      * Sends a named event from this client to the server's isolated onClient handlers.
      * @param eventName Server-side client-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: the server parses it and drops an event that does not parse. Other values are JSON-serialized.
      */
     emitServer(eventName: string, payload?: unknown): void;
   }
@@ -2436,6 +3005,12 @@ declare global {
      */
     getUserId(): string;
 
+    /**
+     * Returns the signed-in Discord user's username.
+     * @returns Username string, or an empty string until available.
+     */
+    getUsername(): string;
+
     /**
      * Checks whether Discord is connected and can publish presence.
      * @returns True when rich presence is initialized.
@@ -2514,7 +3089,7 @@ declare global {
     getPushToTalkKey(): string;
 
     /**
-     * Sets how long transmission continues after push-to-talk is released, so letting go slightly early does not clip the end of a word. Muting, turning voice off and losing input focus still stop it at once.
+     * Sets how long transmission continues after push-to-talk is released, so letting go slightly early does not clip the end of a word. Muting, turning voice off and starting to type into a text field still stop it at once.
      * @param milliseconds How long to keep transmitting after the key goes up. Clamped to 0..2000.
      */
     setPushToTalkReleaseDelay(milliseconds: number): void;
@@ -2562,8 +3137,8 @@ declare global {
     getActivationThreshold(): number;
 
     /**
-     * Reads how loud the microphone is right now, whether or not anything is being sent -- the value to draw a level meter from and to tune the activation threshold against.
-     * @returns Smoothed level from 0 to 1; 0 while no microphone is open.
+     * Reads how loud the microphone is while this player is sending voice. The microphone stays open for the whole session, so what it hears the rest of the time is not given to scripts.
+     * @returns Smoothed level from 0 to 1 while isTalking is true; 0 otherwise.
      */
     getInputLevel(): number;
 

package/generated/server-api.d.ts

@@ -55,6 +55,11 @@ declare global {
      */
     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.
      */
@@ -165,6 +170,156 @@ declare global {
      */
     playerValueChange: [player: Player, value: string, base: number, previous: number];
 
+    /**
+     * 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.
      */
@@ -220,6 +375,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 +411,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 +559,16 @@ declare global {
      */
     readonly armor: number;
 
+    /**
+     * 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`.
      */
@@ -654,6 +823,19 @@ 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;
+
     /**
      * 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.
@@ -860,6 +1042,55 @@ declare global {
      */
     removeFromAllFactions(): boolean;
 
+    /**
+     * 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.
+     */
+    fastTravel(destination: number | string): boolean;
+
+    /**
+     * 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.
+     */
+    getLocation(): number | null;
+
+    /**
+     * 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.
+     */
+    getMapWaypoint(): Vector3 | null;
+
+    /**
+     * 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.
+     */
+    setMapWaypoint(position: Vector3 | null): boolean;
+
+    /**
+     * 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.
+     */
+    discoverLocations(markers: (number | string)[], canTravel?: boolean): boolean;
+
+    /**
+     * 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.
+     */
+    forgetLocations(markers: (number | string)[]): boolean;
+
+    /**
+     * 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.
+     */
+    setGameSetting(name: string, value: number | boolean): boolean;
+
     /**
      * Every connected player.
      * @returns One handle per player, in no particular order.
@@ -938,6 +1169,20 @@ declare global {
      */
     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;
+
     /**
      * Opens or closes a door for everyone, players who join later included.
      * @param ref The placed reference's form ID.
@@ -1140,6 +1385,70 @@ declare global {
     clearReaction(faction: number | string, other: number | string, mutual?: boolean): boolean;
   };
 
+  /**
+   * 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.
    */
@@ -1303,6 +1612,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.
      */
@@ -2306,31 +2625,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 +2940,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 +3115,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.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falloutmp/types",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "TypeScript declarations for the Fallout Multiplayer scripting API: @falloutmp/types/server and @falloutmp/types/client",
   "license": "UNLICENSED",
   "exports": {