@falloutmp/types 0.2.5 → 0.3.2

package/generated/client-api.d.ts

@@ -15,6 +15,11 @@ declare global {
      */
     menuClose: [name: string];
 
+    /**
+     * Dispatched when what lies under the crosshair changes, as the activation prompt follows it: the reference now there and the one before, 0 for none, and, when the new one is another player's body or an NPC, its network ID as the server knows it.
+     */
+    crosshairChange: [ref: number, previous: number, entity: number | null];
+
     /**
      * Dispatched once when the local player goes down. The server decides when they come back.
      */
@@ -80,6 +85,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,11 +130,31 @@ 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.
      */
     workshopRemove: [form: number];
 
+    /**
+     * Dispatched when the sky switches its current weather: a change the server made, this player's own, or one the game rolled, starting its fade or snapping to it. `previous` is the weather it leaves, 0 for none. The fade itself goes on for up to a game hour; `World.getSky` follows it.
+     */
+    weatherChange: [weather: number, previous: number];
+
+    /**
+     * Dispatched when lightning strikes in the sky: a flash and a thunderclap, with the flash's brightness from 0 to 1. In a session every player's sky strikes together, on the server's word.
+     */
+    lightning: [flash: number];
+
+    /**
+     * Dispatched when the game finds the player under another weather region as they change cell: the TESRegion form ID whose weathers the sky would roll, 0 for none. The server hears it too (`playerWeatherRegionChange`).
+     */
+    weatherRegionChange: [region: number, previous: number];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -199,6 +229,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 +265,108 @@ 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;
+
+    /**
+     * What the HUD's ammo counter shows: the rounds in the weapon and the rounds carried besides.
+     * @returns Null while the HUD shows no counter: no gun in hand.
+     */
+    getAmmo(): { clip: number; reserve: number } | null;
+
+    /**
+     * What the HUD's enemy health bar shows for the actor the player is aiming at: its name, its health from 0 to 100, the bar's second meter, and whether it is hostile, legendary or far above the player's level.
+     * @returns Null while the HUD shows no bar: nobody under the crosshair.
+     */
+    getEnemyHealth(): { name: string; healthPercent: number; secondaryPercent: number; hostile: boolean; legendary: boolean; skull: boolean } | null;
+
+    /**
+     * What the HUD's activation prompt shows for what the player looks at: its name, the label of the activate button and of the second button, whether activating is enabled, the legendary and tagged-for-search icons, and whether activating would be a crime.
+     * @returns Null while the HUD shows no prompt.
+     */
+    getRollover(): { name: string; activateText: string; secondaryText: string; activateEnabled: boolean; legendary: boolean; taggedForSearch: boolean; crime: boolean } | null;
+
+    /**
+     * The arcs the HUD's hit indicator shows: for each recent hit, the angle to the attacker in radians, where an attacker straight ahead reads about -pi/2, and a strength that starts at 100 and fades.
+     * @returns Empty while the HUD shows none.
+     */
+    getHitIndicators(): { angle: number; strength: number }[];
+
+    /**
+     * The markers the HUD's explosive indicator shows: for each grenade or mine near the player, whether it is a placed explosive, how far it is in game units and the angle to it in radians, where straight ahead reads about -pi/2.
+     * @returns Empty while the HUD shows none.
+     */
+    getExplosiveIndicators(): { placed: boolean; distance: number; angle: number }[];
+
+    /**
+     * What the HUD's experience meter last showed: the amount it printed, its fill, and whether it announced a level.
+     * @returns Null until the meter has come up once.
+     */
+    getExperienceMeter(): { amount: number; percent: number; levelUp: boolean } | null;
+
+    /**
+     * The icons the HUD's active effects widget shows: four arrays, one per effect category, each holding the indices of the icons lit.
+     */
+    getActiveEffectIcons(): number[][];
+
+    /**
+     * What the HUD's radiation meter holds: the rads it displays, their share of a lethal dose, and how many radiation sources reach the player. Each is null until the game has set it.
+     * @returns Null before the HUD exists.
+     */
+    getRadiation(): { rads: number | null; lethalShare: number | null; sources: number | null } | null;
+
+    /**
+     * Whether the HUD still has corner messages to show or on screen, as its notification model was last told: a script can wait for the corner to clear before it shows its own.
+     */
+    hasMessages(): boolean;
+
+    /**
+     * 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 +420,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 +607,50 @@ declare global {
      */
     getFov(): { horizontal: number; vertical: number } | null;
 
+    /**
+     * Sets the field of view the world renders with, as FiveM's SetCamFov and the console's fov do: a zoom for a cutscene, a fish-eye for a drunk effect. It holds through camera changes until set again; the game's own comes back with null or when the session ends. The player's own settings are not touched.
+     * @param degrees The horizontal field of view, 10 to 160 degrees; null for the game's own.
+     * @returns False before the world is built.
+     */
+    setFov(degrees: number | null): boolean;
+
+    /**
+     * Takes the camera from the player and puts it where the script says, as FiveM's CreateCam, SetCamCoord, PointCamAtCoord and RenderScriptCams do: a cutscene shot, a security camera, an intro flight. The player's controls move neither the camera nor their body while it is up: their movement, looking, jumping and fighting are held off, and their body keeps its heading. Called again it moves: a script tweens it by calling every tick. It is given back with null, when the resource that set it stops, or when the session ends.
+     * @param view Where the camera stands, and where it looks: a rotation in radians (pitch positive down, yaw 0 facing +Y, clockwise) or a point to face. Null gives the player their camera back.
+     * @returns False when there is no player in a cell, or the console's fly camera holds the camera.
+     */
+    setView(view: { position: Vector3; rotation?: { pitch: number; yaw: number }; lookAt?: Vector3 } | null): boolean;
+
+    /**
+     * 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.
      */
@@ -459,6 +663,72 @@ declare global {
      * @param z World units.
      */
     worldToScreen(x: number, y: number, z: number): { x: number; y: number; onScreen: boolean } | null;
+
+    /**
+     * What lies under the crosshair, as the game picks it for the activation prompt, the activate button and VATS: the reference, the network ID of the player or NPC it stands for when it is one, and how far it is from the player in game units.
+     * @returns Null with nothing under the crosshair. It is the activation pick: an actor is under it only when the game offers to activate it, so another player's body never is; Camera.raycast strikes it.
+     */
+    getCrosshairTarget(): { ref: number; entity: number | null; distance: number } | null;
+
+    /**
+     * What the player is aiming at: World.raycast from the camera through the middle of the screen, where the crosshair sits, in first or third person. Unlike getCrosshairTarget it strikes anything solid, other players' bodies included.
+     * @param distance How far to look, in game units; 10000 when left out.
+     * @param options As World.raycast's: the actor whose body the ray passes over, the local player by default.
+     * @returns As World.raycast's; null before the world is built or the player is in a cell.
+     */
+    raycast(distance?: number, options?: { ignore?: number | string | null }): { hit: boolean; position: Vector3; normal: Vector3; fraction: number; ref: number | null; entity: number | null } | 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;
   };
 
   /**
@@ -517,9 +787,59 @@ declare global {
   };
 
   /**
-   * Screen and controller effects only the local player sees and feels. Fades are on Hud.fade.
+   * Effects only the local player sees and feels: screen and controller effects, and explosions, shaders, visual effects and impacts in this game alone. Fades are on Hud.fade; the server's `Explosion` and `Effect` play for everyone.
    */
   const Effects: {
+    /**
+     * Sets off an explosion in this game alone. Its blast hurts what this game simulates.
+     * @param explosion A BGSExplosion (EXPL) form ID.
+     * @param position Where it goes off, in the player's space.
+     * @param options `scale` of its radii, `damage` a multiplier of its damage (0 for a harmless one); 1 by default.
+     * @returns False when there is no such explosion, or the spot is not loaded here.
+     */
+    explode(explosion: number | string, position: Vector3, options?: { scale?: number; damage?: number }): boolean;
+
+    /**
+     * Plays an effect shader on a reference in this game alone, as EffectShader.Play does.
+     * @param ref A reference or actor of this game by form ID: 0x14 for the player, `References.getEntityBody` for another player or an NPC.
+     * @param shader A TESEffectShader (EFSH) form ID.
+     * @param seconds How long; until stopShader when left out.
+     * @returns False when the reference is not loaded here or the form is no shader.
+     */
+    playShader(ref: number | string, shader: number | string, seconds?: number): boolean;
+
+    /**
+     * Stops an effect shader on a reference.
+     * @param ref A reference or actor of this game by form ID: 0x14 for the player, `References.getEntityBody` for another player or an NPC.
+     * @param shader The shader played.
+     */
+    stopShader(ref: number | string, shader: number | string): void;
+
+    /**
+     * Attaches a visual effect to a reference in this game alone, as VisualEffect.Play does.
+     * @param ref A reference or actor of this game by form ID: 0x14 for the player, `References.getEntityBody` for another player or an NPC.
+     * @param effect A BGSReferenceEffect (RFCT) form ID.
+     * @param seconds How long; until stopVisual when left out.
+     * @returns False when the reference is not loaded here or the form is no visual effect.
+     */
+    playVisual(ref: number | string, effect: number | string, seconds?: number): boolean;
+
+    /**
+     * Takes a visual effect off a reference.
+     * @param ref A reference or actor of this game by form ID: 0x14 for the player, `References.getEntityBody` for another player or an NPC.
+     * @param effect The visual effect played.
+     */
+    stopVisual(ref: number | string, effect: number | string): void;
+
+    /**
+     * Plays an impact where a ray from the reference lands, in this game alone, as ObjectReference.PlayImpactEffect does.
+     * @param ref A reference or actor of this game by form ID: 0x14 for the player, `References.getEntityBody` for another player or an NPC.
+     * @param impactSet A BGSImpactDataSet (IPDS) form ID.
+     * @param options The ray: from the named node (the root when left out), along the direction (straight down by default), for the length in game units (512).
+     * @returns False when the reference is not loaded here or the ray hit nothing.
+     */
+    playImpact(ref: number | string, impactSet: number | string, options?: { node?: string; direction?: Vector3; length?: number }): boolean;
+
     /**
      * Applies an image space modifier, as ImageSpaceModifier.Apply does; it runs its own length, and is removed once this resource stops. False when there is no such modifier or no world to run it in.
      * @param modifier An image space modifier (IMAD): its editor ID, or its form ID (a number, or a string starting 0x).
@@ -748,6 +1068,182 @@ 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;
+
+    /**
+     * Holds the player's weapon out or away, as FiveM's SetCurrentPedWeapon forces a ped's: drawn or holstered at once, then kept so against the ready-weapon key and the game. With no weapon in hand, out raises the fists. `Controls.setEnabled("fighting", false)` stops attacks too.
+     * @param drawn True to hold the weapon out, false to keep it away, null to hand it back to the player.
+     */
+    setWeaponDrawn(drawn: boolean | null): void;
+
+    /**
+     * Loads rounds into the weapon in the player's hands, as FiveM's SetAmmoInClip does a ped's. The rounds come from those the player carries, as a reload takes them: never more than they have; the server's `player.giveItem` gives more.
+     * @param rounds The rounds to load, 0 to 100000; more than the weapon's clip loads a full clip.
+     * @returns False without a weapon that loads ammo in hand.
+     */
+    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. It comes back when the session ends.
+     * @param enabled False to take the player's collision away, true to give it back.
+     */
+    setCollision(enabled: boolean): void;
+
+    /**
+     * Rebuilds the player on another race, as the console's setrace and Actor.SetRace do: a ghoul. Every other player sees their puppet rebuilt the same way; their head parts stay their own. Only human and ghoul are supported; any other race is refused. The race they had comes back with null, and when the session ends.
+     * @param race 0x13746 (HumanRace) or 0xEAFB6 (GhoulRace); null for the race the player had.
+     * @returns False when the player is not standing in the world.
+     */
+    setRace(race: number | string | null): boolean;
+
+    /**
+     * Whether the player has their collision: false after setCollision(false) or the console's tcl.
+     */
+    isCollisionEnabled(): 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;
+
+    /**
+     * Where the game places the points of the player's body, in world units: the height of the eyes above the feet in the current pose and the standing height the game keeps for the player, the point others look at, and the four points the game keeps on the body, from the eyes down.
+     * @returns Null while the player is not in the world.
+     */
+    getBodyPoints(): { eyeLevel: number; standingEyeHeight: number; lookAt: Vector3; parts: Vector3[] } | null;
+
+    /**
+     * The player's critical meter as the game holds it: the charge towards the next stored critical, how many are stored and how many can be.
+     * @returns Null before the player exists.
+     */
+    getCritMeter(): { charge: number; stored: number; max: number } | null;
+
+    /**
+     * 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.
@@ -852,26 +1348,101 @@ declare global {
   }
 
   /**
-   * The server's clock and sky, as this client holds them. Read-only: the server's `World` sets them.
+   * 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, calendar and sky, as this client holds them, and what the sky is doing right now. Read-only: the server's `World`, `Player.setWeather` and `Player.setHour` set them.
    */
   const World: {
     /**
-     * The game hour the server keeps, 0 to 24.
+     * The game hour the server keeps, 0 to 24; the player's own while a script holds their clock.
      * @returns Null before the server's world streams in.
      */
     getHour(): number | null;
 
     /**
-     * Game minutes per real minute; 0 holds the clock.
+     * Game minutes per real minute; 0 holds the clock, as it is while a script holds the player's own hour.
      * @returns Null before the server's world streams in.
      */
     getTimeScale(): number | null;
 
     /**
-     * The TESWeather form ID the server holds the sky to.
+     * The calendar date the server keeps: the full year, the month 1 to 12, the day of the month.
+     * @returns Null before the server's world streams in.
+     */
+    getDate(): { year: number; month: number; day: number } | null;
+
+    /**
+     * Whole days the server's clock has run, the game's GameDaysPassed.
+     * @returns Null before the server's world streams in.
+     */
+    getDaysPassed(): number | null;
+
+    /**
+     * The TESWeather form ID the server holds the sky to: the player's own while a script gave them one, else the World's.
      * @returns Null while the region decides the weather, and before the server's world streams in.
      */
     getWeather(): number | null;
+
+    /**
+     * What the game's sky and clock show right now: the weather it is in or fading to, the one it fades from (null once the fade is done), the override it is held to, how far the fade is from 0 to 1, the game's own hour and day count, whether the whole sky is drawn (outdoors; indoors there is none to fade), and the region whose weathers the sky would roll where the player stands.
+     * @returns Null before the game's data files are loaded.
+     */
+    getSky(): { weather: number | null; outgoing: number | null; override: number | null; transition: number; hour: number; daysPassed: number; full: boolean; region: number | null } | null;
+
+    /**
+     * The wind the sky is blowing right now: its speed from 0 to 1, the weather's direction in degrees and how many degrees it may swing either side, and the direction the sky drew within that swing, in degrees: the same on every player's sky in a session.
+     * @returns Null before the sky exists.
+     */
+    getWind(): { speed: number; angle: number; angleRange: number; direction: 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;
+
+    /**
+     * Casts a ray through the physics world the player stands in and tells what it struck first, testing what a bullet's impact would: the ground, buildings, props, clutter and the bodies of actors, passing over the player's own unless the options say otherwise.
+     * @param from Where the ray starts, in game units.
+     * @param to Where it ends.
+     * @param options `ignore`: an actor (form ID in this game, as `References.getEntityBody` gives one) whose own body the ray passes over; the local player when left out, nobody for null.
+     * @returns Whether it struck something before `to`; where; the surface's unit normal there; how far along the ray, 0 to 1; the reference hit (null for the landscape); and, when that is another player's body or an NPC, its network ID as the server knows it (`player.id`, `npc.id`). Without a hit the position is `to`, the fraction 1 and the normal zero. Null before the player is in a cell.
+     */
+    raycast(from: Vector3, to: Vector3, options?: { ignore?: number | string | null }): { hit: boolean; position: Vector3; normal: Vector3; fraction: number; ref: number | null; entity: number | null } | null;
+  };
+
+  /**
+   * What the player's own game holds of their quests. Read-only: the server's `Quests` gives quests and sets their objectives.
+   */
+  const Quests: {
+    /**
+     * Every objective the player's game holds that is not hidden, as its quest log has it.
+     * @returns One entry per objective: the quest's form ID, the objective's index in it and its state. Empty before the player is in the world.
+     */
+    getObjectives(): { quest: number; index: number; state: "displayed" | "completed" | "failed" }[];
   };
 
   /**
@@ -883,6 +1454,248 @@ 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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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, its model has no physics, or it is an actor.
+     */
+    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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @returns Null when it is not here.
+     */
+    getScale(ref: number | string): number | null;
+
+    /**
+     * Scales the reference.
+     * @param ref The reference's form ID: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @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: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @returns False when it is not here.
+     */
+    isActivationBlocked(ref: number | string): boolean;
+
+    /**
+     * Whether the reference is in the world: false once ObjectReference.Disable, a quest's enable parent or the server's `Objects.setEnabled` took it out.
+     * @param ref The reference's form ID: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @returns Null when this game holds no such reference now.
+     */
+    isEnabled(ref: number | string): boolean | null;
+
+    /**
+     * Blocks or allows activating the reference.
+     * @param ref The reference's form ID: a placed object, or an actor's, such as a body getEntityBody, World.raycast or the crosshair gives.
+     * @param blocked The flag.
+     * @returns False when it is not here.
+     */
+    setActivationBlocked(ref: number | string, blocked: boolean): boolean;
   };
 
   /**
@@ -1695,7 +2508,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 +3249,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 +3333,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 +3381,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;