@falloutmp/types 0.3.1 → 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.
      */
@@ -135,6 +140,21 @@ declare global {
      */
     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.
      */
@@ -273,6 +293,58 @@ declare global {
      */
     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.
@@ -535,6 +607,20 @@ 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.
@@ -577,6 +663,20 @@ 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;
   };
 
   /**
@@ -687,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).
@@ -931,6 +1081,37 @@ declare global {
      */
     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.
@@ -964,6 +1145,18 @@ declare global {
      */
     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.
      */
@@ -1179,33 +1372,77 @@ declare global {
   };
 
   /**
-   * The server's clock and sky, as this client holds them. Read-only: the server's `World` sets them.
+   * 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" }[];
   };
 
   /**
@@ -1249,7 +1486,7 @@ declare global {
   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 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.
      */
@@ -1257,7 +1494,7 @@ declare global {
 
     /**
      * 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.
+     * @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;
@@ -1273,7 +1510,7 @@ declare global {
 
     /**
      * 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 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.
      */
@@ -1281,22 +1518,22 @@ declare global {
 
     /**
      * The name of the behavior graph that animates the reference, the one `playAnimation` sends its events to.
-     * @param ref The reference's form ID.
+     * @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.
+     * @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 or its model has no physics.
+     * @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.
+     * @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.
@@ -1328,28 +1565,28 @@ declare global {
 
     /**
      * 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.
+     * @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.
+     * @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.
+     * @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.
+     * @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.
      */
@@ -1357,7 +1594,7 @@ declare global {
 
     /**
      * Sets an actor value on the reference, as ObjectReference.SetValue does.
-     * @param ref The reference's form ID.
+     * @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.
@@ -1366,28 +1603,28 @@ declare global {
 
     /**
      * 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.
+     * @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.
+     * @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.
+     * @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.
+     * @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.
      */
@@ -1395,14 +1632,14 @@ declare global {
 
     /**
      * The level a pick attempt on the reference's lock faces.
-     * @param ref The reference's form ID.
+     * @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.
+     * @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.
      */
@@ -1410,14 +1647,14 @@ declare global {
 
     /**
      * The game's destroyed flag.
-     * @param ref The reference's form ID.
+     * @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.
+     * @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.
      */
@@ -1425,14 +1662,14 @@ declare global {
 
     /**
      * Whether a flora or produce reference is picked.
-     * @param ref The reference's form ID.
+     * @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.
+     * @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.
      */
@@ -1440,14 +1677,21 @@ declare global {
 
     /**
      * Whether activating the reference is refused.
-     * @param ref The reference's form ID.
+     * @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.
+     * @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.
      */