@kingdomsconnected/types 1.5.3 → 1.5.5

package/generated/client-api.d.ts

@@ -84,6 +84,16 @@ declare global {
      */
     noclipChanged: [active: boolean, reason: "script" | "mapEditor" | "viewLost" | "sessionOver"];
 
+    /**
+     * Dispatched when a book `Book.open` asked for is in the player's hands and showing its first page, on this machine only.
+     */
+    bookOpened: [bookId: number];
+
+    /**
+     * Dispatched when a book leaves the player's hands, on this machine only. `reason` is `player` for the player's own exit (or the game ending the reading itself), `script` for `Book.close`, `failed` for a book that never reached the hands, and `sessionOver` for the session ending. Handler promises are not awaited, and a handler may open the next book straight away.
+     */
+    bookClosed: [bookId: number, reason: "player" | "script" | "failed" | "sessionOver"];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -604,6 +614,11 @@ declare global {
      */
     readonly appearance: Appearance;
 
+    /**
+     * The prop-catalog mesh this player's body is drawn as, by its `objects/...cgf` path, or null while they look like themselves. Published by their own client, so it follows `setDisguise` once they have actually put it on.
+     */
+    readonly disguise: string | null;
+
     /**
      * Whether this player's body has both a pose and a soul, which is what everyone else waits for before spawning a puppet for them. False for the first moments of a connection.
      */
@@ -893,7 +908,7 @@ declare global {
   };
 
   /**
-   * The game's own HUD messages, shown to the player at this machine. Nothing here is replicated: a message everyone should see is sent to everyone, and each client shows it. Every call returns false while there is no HUD, which is the case in the main menu and across a level load.
+   * The game's own HUD messages, shown to the player at this machine. Nothing here is replicated: a message everyone should see is sent to everyone, and each client shows it. Every message call returns false while there is no HUD, which is the case in the main menu and across a level load.
    */
   const Hud: {
     /**
@@ -1005,6 +1020,21 @@ declare global {
      * @returns True when the HUD took it.
      */
     clearNotifications(): boolean;
+
+    /**
+     * Hides or shows one element of the game's HUD at this client, through the switch the game itself keeps for each. It can be called at any time, before the HUD has loaded included: the game re-applies the switch every time the HUD loads, across level loads too. Turning an element on does not force it up; the game still hides it where it would anyway, in dialogue or a menu, say. The player's own setting comes back when the resource that changed it stops.
+     * @param element The element, by the game's own name for it: `Stats` is the health, stamina and nourishment bars along the bottom. One of `Compass`, `Stats`, `QAMWeapon`, `QAMFood`, `Subtitles`, `InfoText`, `GameLog`, `Hints`, `DialogLeft`, `DialogRight`, `Cursor`, `Crime`, `Wanted`, `PopUpBackground`, `TutorialMessage`, `FancyEvent`, `SkillCheck`, `ItemTransfer`, `Buffs`, `CommonEvent`, `DiceCursor`, `Trespassing`, `RatioStrips`, `ShootingContest`, `Bubbles`, `TutorialInDialog`, `DiceContainer`, `Vignette`, compared exactly.
+     * @param visible False hides the element, true lets the game show it again.
+     * @returns True when the switch took it; false only before the game has created its HUD switches, which it does at startup.
+     */
+    setElementVisible(element: string, visible: boolean): boolean;
+
+    /**
+     * Whether one element's switch is on. An element whose switch is on can still be hidden by the game at that moment.
+     * @param element The element, by the game's own name for it, as `setElementVisible` takes it.
+     * @returns True while the element is allowed to show.
+     */
+    isElementVisible(element: string): boolean;
   };
 
   /**
@@ -1304,6 +1334,11 @@ declare global {
      * This machine's own handle for it. Local to this client and to this session -- it is not the network ID and it is not portable, so store `entityGuid` instead. Null for terrain and static geometry.
      */
     entityId: number | null;
+
+    /**
+     * The player whose body it was -- the local player's own included, when `ignoreSelf` is off -- or null for anything else. Found through the body's own entity, so it holds for a disguised player too: their collider is the mesh's size, and a trace that meets the mesh names them.
+     */
+    player: Player | null;
   }
 
   /**
@@ -1782,7 +1817,7 @@ declare global {
   /**
    * The view this client is drawing through. Nothing here is replicated and nothing here is authority: it describes one machine's own camera at one moment.
    * 
-   * This is the game's camera, not a camera of the mod's own -- it follows the player, a dialogue, a cutscene or a free flight, whichever the game currently has. `NoClip` is what takes it over.
+   * This is the game's camera, not a camera of the mod's own -- it follows the player, a dialogue, a cutscene or a free flight, whichever the game currently has. `NoClip` is what takes it over, and `setThirdPerson` puts it behind the player.
    */
   const Camera: {
     /**
@@ -1797,6 +1832,24 @@ declare global {
      * @returns The ray, or null when there is no active view.
      */
     screenRay(options?: { x?: number; y?: number; range?: number }): CameraRay | null;
+
+    /**
+     * Puts this player's camera behind them, for as long as it is on.
+     * 
+     * The game has no third-person view to switch to, so this is a camera of the mod's own, placed every frame behind the body along the direction the player is looking. Nothing about their controls changes: they walk and turn as they did, and the mouse still turns the body. When a wall is behind them the camera comes in along the same line rather than going through it.
+     * 
+     * This is what a disguised player needs -- `player.setDisguise` hides the body the game's own camera sits in. It is this client's own view, so a gamemode turns it on from a client script, typically on an event the server sends the disguised player.
+     * 
+     * There is one view to draw through: `NoClip` cannot start while this holds it, and while `NoClip` flies this waits. The map, the inventory and the other pause-screen pages are filmed by the game's own camera, so this steps aside while one is open and comes back when it closes. It lasts until the session ends.
+     * @param options Where the camera sits, in metres: `distance` back from the body along where the player looks (3.5 by default, 0.3 to 20), `height` of the point it orbits above the body's feet (1.6, up to 5 either way), and `shoulder` to the right of it, negative for the left (0, up to 3 either way). Null hands the view back to the game's own camera. Called again while on, it only moves the camera.
+     */
+    setThirdPerson(options?: { distance?: number; height?: number; shoulder?: number } | null): void;
+
+    /**
+     * Whether `setThirdPerson` is on.
+     * @returns True from `setThirdPerson` until it is turned off, also while it waits for a body or for `NoClip`.
+     */
+    isThirdPerson(): boolean;
   };
 
   /**
@@ -2529,6 +2582,111 @@ declare global {
     getCatalog(): EmoteCatalogEntry[];
   };
 
+  /**
+   * A picture for the skill-book and map layouts, which place pictures by page rather than inline.
+   */
+  interface BookPageImage {
+    /**
+     * Zero-based page the picture belongs to.
+     */
+    page: number;
+
+    /**
+     * Its name under the game's own `Libs/UI/Textures/Books/` Skills or Maps folder, without the `_ui.dds` suffix, e.g. `swords1`.
+     */
+    image: string;
+  }
+
+  /**
+   * What `Book.open` shows and how it looks.
+   */
+  interface BookOptions {
+    /**
+     * One string per page, written in the book movie's own markup: `<title>`, `<subtitle>`, `<heading>`, `<paragraph>`, `<br/>`, `<accent>`, `<inc>X</inc>` for a decorated initial, `<poem>`, `<lpoem>`, `<note>`, `<p align>`, `<font size>`, `<i>` and `<img src='...' width='W' height='H' align='center'/>`. A page break follows every page but the last; `<newpage/>` inside a page breaks it further. The player's own reading skill never scrambles it; `legibility` decides that.
+     */
+    pages: string[];
+
+    /**
+     * The object in the player's hands: a red-covered book (the default), a plain-covered one, or a folded letter.
+     */
+    style: "book" | "plainBook" | "letter" | undefined;
+
+    /**
+     * The layout the movie uses, by `document_class` id: 1 book (the default), 2 recipe, 3 skill book, 4 map, 5 letter (the default for `letter`), 6 plan.
+     */
+    type: number | undefined;
+
+    /**
+     * How ornate the pages are, 1 plain to 7 embellished. Defaults to 1.
+     */
+    visual: number | undefined;
+
+    /**
+     * How much of the text can be read, 0 to 1; values outside are clamped. Defaults to 1, fully legible. Below 1 the movie swaps letters for look-alike glyphs, the same effect a vanilla book shows a player with low reading skill. It works in tenths: each step brings roughly another tenth of the character classes back, so 0.31 and 0.39 look the same. The substitution is deterministic -- the same text at the same level always reads the same way -- and markup is never touched.
+     */
+    legibility: number | undefined;
+
+    /**
+     * A picture `Book.image` returned, replacing the carrier's own diffuse texture: the paper and the cover together, which the model maps from one atlas. Paint it over the vanilla atlas to keep the UV layout -- `Objects/manmade/task_specific_props/read_and_write/books/book_alchemy_diff.dds` for the two book styles, `.../scrolls/scroll_diff.dds` for `letter`. The material's diffuse colour multiplies it: `book` darkens it to about 78% and `letter` to about 72%, while `plainBook` shows it as painted. It applies to this book's own copy of the material only, and goes with the book.
+     */
+    texture: string | undefined;
+
+    /**
+     * Pictures for the skill-book and map layouts. Inline pictures go in the page text as `<img>` instead.
+     */
+    images: BookPageImage[] | undefined;
+  }
+
+  /**
+   * Books a resource composes and opens in this player's hands.
+   * 
+   * A book is shown through the game's own reading: the same book in hand, camera, page-turn animation, prompts and pagination as any book the player reads from their inventory. The player turns pages and leaves it with the game's own keys, and `bookClosed` says when they did.
+   * 
+   * Client-only and local: the book exists on this machine alone, and reading it grants nothing -- no XP, no read marker, no quest progress. A server that wants a player to read something sends the pages in its own event.
+   * 
+   * Pictures a resource ships go through `Book.image`, which returns what an `<img src>` and the `texture` option take.
+   */
+  const Book: {
+    /**
+     * Opens a book in the player's hands.
+     * @param options The pages and how they look.
+     * @returns The book's id, which `bookOpened` and `bookClosed` carry; null when the game will not open one now -- no body yet, a book already open, or a place the player cannot read in (on horseback, in combat). `getLastError` says which. Malformed options throw.
+     */
+    open(options: BookOptions): number | null;
+
+    /**
+     * Closes the open book the way the player's own exit does.
+     * @returns False when no book is open.
+     */
+    close(): boolean;
+
+    /**
+     * Changes how legible the open book is, while it is in the player's hands.
+     * @param value 0 fully scrambled to 1 fully legible; clamped.
+     * @returns False when no book is in the hands yet (wait for `bookOpened`). The movie applies legibility while laying the text out, so the book is laid out again, which can return it to its first page. Throws for a non-number.
+     */
+    setLegibility(value: number): boolean;
+
+    /**
+     * The id of the book in the player's hands.
+     * @returns Null when there is none.
+     */
+    getOpenBook(): number | null;
+
+    /**
+     * Why the last `open` returned null.
+     * @returns Empty after one that succeeded.
+     */
+    getLastError(): string;
+
+    /**
+     * Makes a picture the resource ships reachable from page text.
+     * @param path A `.dds` file the calling resource ships, relative to the resource.
+     * @returns The value for an `<img src='...'>` attribute. Give the tag a `width` and `height` too: the movie sizes the picture to them and has no size of its own for it. Throws when the file is missing, not a `.dds`, or larger than 16 MiB.
+     */
+    image(path: string): string;
+  };
+
   /**
    * Mutable two-dimensional vector.
    */

package/generated/server-api.d.ts

@@ -195,27 +195,27 @@ declare global {
     playerPickpocketCaught: [thief: Player, victim: Player];
 
     /**
-     * A player asks to open an alchemy table. Every handler runs; one returning literal `false` refuses it. An async handler cannot refuse.
+     * A player asks to open an alchemy table, or to begin a smithing recipe. Every handler runs; one returning literal `false` refuses it. An async handler cannot refuse.
      */
     craftingStarting: [player: Player, proposal: CraftStartProposal];
 
     /**
-     * A batch is brewing.
+     * A batch is brewing, or a workpiece took its materials.
      */
     craftingStarted: [player: Player, event: CraftStartedEvent];
 
     /**
-     * A batch finished and its result is computed. Every handler runs; one returning literal `false` refuses it: the batch ends as failed, what was spent stays spent, and nothing is granted.
+     * A batch or workpiece finished and its result is computed. Every handler runs; one returning literal `false` refuses it: alchemy ends the batch as failed, what was spent stays spent, and nothing is granted; smithing fails the workpiece, spending its failure share.
      */
     craftingCompleting: [player: Player, proposal: CraftCompletionProposal];
 
     /**
-     * A batch's result was granted, followed by `craftingEnded`. Raised after the `playerInventoryChanged` it caused.
+     * A result was granted, followed by `craftingEnded`. Raised after the `playerInventoryChanged` it caused.
      */
     craftingCompleted: [player: Player, event: CraftCompletedEvent];
 
     /**
-     * A batch is over. Raised after the `playerInventoryChanged` of any refund.
+     * A batch or workpiece is over. Raised after the `playerInventoryChanged` of any refund.
      */
     craftingEnded: [player: Player, event: CraftEndedEvent];
 
@@ -386,6 +386,16 @@ declare global {
      */
     doorInteract: [player: Player, door: Door, action: "open" | "close" | "unlock" | "lockpick", keySide: boolean];
 
+    /**
+     * Dispatched when a body comes to be inside an enabled area: it walked or rode in, or the area was created, moved, reshaped or enabled around it. The server decides this itself from the pose it already replicates, by the game's own rule for that kind of area, so a client cannot claim it. `matchingVirtualWorld` is false when a script area bound to one world is crossed by a body in another; a level area is in every world.
+     */
+    areaEnter: [area: Area, entity: Player | Horse | Cart | Npc, matchingVirtualWorld: boolean];
+
+    /**
+     * Dispatched when a body stops being inside an area: it walked out, or the area was moved, reshaped, disabled or destroyed. A body that leaves the server entirely -- a player disconnecting, a horse despawned -- raises nothing here; its own event already says it is gone.
+     */
+    areaExit: [area: Area, entity: Player | Horse | Cart | Npc, matchingVirtualWorld: boolean];
+
     /**
      * A container now exists: one a script spawned, or one the level places, built in a virtual world the first time anything there asked for it. Every container starts empty; restore saved contents here with `setInventory`. The level's containers in the global world are built before any resource runs, so restore those from `resourceStart` by walking `Stash.all()`.
      */
@@ -948,6 +958,11 @@ declare global {
      */
     readonly appearance: Appearance;
 
+    /**
+     * The prop-catalog mesh this player's body is drawn as, by its `objects/...cgf` path, or null while they look like themselves. Published by their own client, so it follows `setDisguise` once they have actually put it on.
+     */
+    readonly disguise: string | null;
+
     /**
      * Whether this player's body has both a pose and a soul, which is what everyone else waits for before spawning a puppet for them. False for the first moments of a connection.
      */
@@ -1435,6 +1450,19 @@ declare global {
      */
     heal(options?: { health?: number | boolean; injuries?: boolean; poisons?: boolean; bleeding?: boolean }): boolean;
 
+    /**
+     * Draws this player as a static mesh instead of themselves -- a barrel, a haystack, a cart wheel -- on their own screen and on everybody else's. It is state: a player who streams in or joins sees it too, and it lasts until the next call.
+     * 
+     * Only the look and the collision change. The body is hidden rather than replaced, and its collision cylinder is resized around the mesh, so the player walks and is traced against in roughly the mesh's shape -- a client's `World.raycast` with `mode: "anything"` finds them where the mesh is drawn, and says which player it found. The mesh turns with the body. They keep everything else a person has: they can still be hurt, bleed and die, and nothing stops them drawing a weapon, which a gamemode that does not want that has to take away.
+     * 
+     * The game's own camera sits in the head, which the mesh now covers: pair this with the client's `Camera.setThirdPerson` for the disguised player. Nametags are not touched; `setNametagVisible` is the call for that. NPCs still see a person.
+     * 
+     * The owning client is authoritative for its body, so this is a request that lands on their next frame; `player.disguise` reads what they actually have on.
+     * @param model A mesh from the prop catalog, by its `objects/...cgf` path or its file stem -- anything `Prop.spawn` takes. Null puts the player back in their own body.
+     * @returns True when the request went out; false for a player with no connection to ask. Throws for a model the catalog does not carry.
+     */
+    setDisguise(model: string | null): boolean;
+
     /**
      * Takes this player out of whatever saddle they are in: their own client gets them off, and `horseDismount` is raised.
      * @returns The horse they were taken off, or null when they were not riding one.
@@ -1585,7 +1613,7 @@ declare global {
     ok: boolean;
 
     /**
-     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
+     * Empty on success, otherwise why not: `inventoryUnavailable`, `invalidRequest`, `staleRevision`, `invalidItem`, `invalidItems`, `invalidAmount`, `unknownItem`, `insufficientItems`, `inventoryCapacity`, `sameInventory`, or a property policy code (`invalidMetadata`, `unknownItemClass`, `questItem`, `invalidQuality`, `immutableItemHealth`, `invalidItemHealth`, `contradictoryItemHealth`, `invalidCreationSentinel`, `unsupportedPoisonProperties`, `unsupportedOnEquipBuffs`).
      */
     code: string;
 
@@ -1634,6 +1662,21 @@ declare global {
      * Moves exact units from one player to another with their properties, all or nothing. They join matching rows in the target, so the target's row ids are the ones in the result's `items`. Whether the two may trade -- distance, consent, price -- is for the script to decide.
      */
     transfer(source: Player, target: Player, request: { units: InventoryUnit[]; sourceRevision?: number; targetRevision?: number }): InventoryResult;
+
+    /**
+     * What the game prices one unit of an item at, in money units, worked out the way the game does it. `pristine` is the price at the best health its quality allows, `current` at its own health. Quality changes the price only through that health. The metadata reads as `Inventory.add` reads it -- left out, quality 1 at full condition -- so `Inventory.getItemPrice(row.item, row.metadata)` prices a row. This is the item's own worth: what the game's shopkeepers would ask depends on their terms and the haggling, and a `Vendor` charges whatever its script says.
+     * @param metadata The item's properties, as a row's `metadata` holds them.
+     * @returns Null for a class the server does not know, or metadata `Inventory.add` would refuse.
+     */
+    getItemPrice(item: string, metadata?: Record<string, unknown>): { pristine: number; current: number } | null;
+
+    /**
+     * Changes what every player's game calls an item, in their inventory, the shops, loot and anywhere else the game names it; null gives the game its own name back. Every player sees it, including those who join later, until the server stops.
+     * 
+     * The game does not name classes one by one: many classes show the same name -- every kite shield is a Kite Shield -- and renaming one renames all of them. The result lists them. A name is up to 128 bytes with no control characters, and is not translated.
+     * @returns The GUIDs of every class that now shows this name.
+     */
+    setItemName(item: string, name: string | null): string[];
   };
 
   /**
@@ -2103,31 +2146,46 @@ declare global {
   }
 
   /**
-   * A table a player is about to open. Frozen: a handler can refuse it, not change it.
+   * A table a player is about to open, or a workpiece about to take its materials. Frozen: a handler can refuse it, not change it.
    */
   interface CraftStartProposal {
+    /**
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
     /**
      * Station id, as `Crafting.stations` names it.
      */
     station: string;
 
     /**
-     * The player's virtual world; each world has its own tables.
+     * The player's virtual world; each world has its own stations.
      */
     virtualWorld: number;
 
     /**
-     * The batch this one follows at a table the player kept, or empty for a fresh entry.
+     * Smithing only: the recipe id the player chose, as `Crafting.recipes` keys it.
+     */
+    recipe: string | undefined;
+
+    /**
+     * The batch this one follows at a table the player kept, or empty for a fresh entry. Always empty for smithing.
      */
     continuationOf: string;
   }
 
   /**
-   * A batch that is now brewing: the table's opening animation finished, or the next batch started at a table the player kept.
+   * A batch that is now brewing, or a workpiece whose materials were taken.
    */
   interface CraftStartedEvent {
     /**
-     * The batch's session id.
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * The batch's or workpiece's session id.
      */
     session: string;
 
@@ -2137,22 +2195,32 @@ declare global {
     station: string;
 
     /**
-     * The table's virtual world.
+     * The station's virtual world.
      */
     virtualWorld: number;
 
     /**
-     * The previous batch at this table, or empty for the first.
+     * Smithing only: the recipe being worked.
+     */
+    recipe: string | undefined;
+
+    /**
+     * The previous batch at this table, or empty for the first. Always empty for smithing.
      */
     continuationOf: string;
   }
 
   /**
-   * What a finished batch is about to grant, computed by the server. Frozen: a handler can refuse it, not change it.
+   * What a finished batch or workpiece is about to grant, computed by the server. Frozen: a handler can refuse it, not change it.
    */
   interface CraftCompletionProposal {
     /**
-     * The batch's session id.
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * The session id.
      */
     session: string;
 
@@ -2162,22 +2230,22 @@ declare global {
     station: string;
 
     /**
-     * `failed` brews the game's failed potion.
+     * `failed` brews the game's failed potion. A smithing proposal is always `success`: a failed workpiece grants nothing to review.
      */
     outcome: 'success' | 'failed';
 
     /**
-     * The recipe the brew matched, or empty when it matched none.
+     * The recipe the brew matched, or empty when it matched none; the smithing recipe worked.
      */
     recipe: string;
 
     /**
-     * The product's native rank.
+     * The product's native rank; for smithing, its item quality tier.
      */
     grade: number;
 
     /**
-     * Item class GUID of what would be granted, or empty when the yield came out at zero.
+     * Item class GUID of what would be granted, or empty when nothing is: a zero alchemy yield, or a smithing quest product its quest creates.
      */
     product: string;
 
@@ -2187,22 +2255,32 @@ declare global {
     amount: number;
 
     /**
-     * Brewing quality, 0 to 1, after perks and the table-entry bonus.
+     * Brewing quality, 0 to 1, after perks and the table-entry bonus; for smithing, the workpiece quality the player's game reported.
      */
     quality: number;
 
     /**
-     * Base alchemy XP; the player's own multipliers apply on top.
+     * Base alchemy or craftsmanship XP; the player's own multipliers apply on top.
      */
     xp: number;
+
+    /**
+     * Smithing only: lockpicks granted alongside, drawn by the server from the player's perks.
+     */
+    lockpicks: number | undefined;
   }
 
   /**
-   * A batch whose result was granted: the output is in the inventory and the XP was ordered.
+   * A batch or workpiece whose result was granted: the output is in the inventory and the XP was ordered.
    */
   interface CraftCompletedEvent {
     /**
-     * The batch's session id.
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * The session id.
      */
     session: string;
 
@@ -2212,7 +2290,7 @@ declare global {
     station: string;
 
     /**
-     * The table's virtual world.
+     * The station's virtual world.
      */
     virtualWorld: number;
 
@@ -2227,37 +2305,47 @@ declare global {
     recipe: string;
 
     /**
-     * The product's native rank.
+     * The product's native rank; for smithing, its item quality tier.
      */
     grade: number;
 
     /**
-     * Brewing quality, 0 to 1.
+     * Brewing or workpiece quality, 0 to 1.
      */
     quality: number;
 
     /**
-     * Base alchemy XP ordered.
+     * Base XP ordered.
      */
     xp: number;
 
     /**
-     * The inventory rows that received the output. Do not grant it again.
+     * Smithing only: lockpicks granted.
+     */
+    lockpicks: number | undefined;
+
+    /**
+     * The inventory rows that received the output, lockpicks included. Do not grant it again.
      */
     outputs: InventoryUnit[];
 
     /**
-     * The player's recipe knowledge after this batch, as `Crafting.knowledge` returns it.
+     * Alchemy only: the player's recipe knowledge after this batch, as `Crafting.knowledge` returns it.
      */
-    knowledge: Record<string, number>;
+    knowledge: Record<string, number> | undefined;
   }
 
   /**
-   * A batch that is over, for any reason. A table kept for the next batch is not closed by this.
+   * A batch or workpiece that is over, for any reason. A table kept for the next batch is not closed by this.
    */
   interface CraftEndedEvent {
     /**
-     * The batch's session id.
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * The session id.
      */
     session: string;
 
@@ -2267,7 +2355,7 @@ declare global {
     station: string;
 
     /**
-     * The table's virtual world.
+     * The station's virtual world.
      */
     virtualWorld: number;
 
@@ -2277,12 +2365,12 @@ declare global {
     outcome: 'success' | 'failed' | 'cancelled';
 
     /**
-     * Empty for a completed batch. `craftingCompletingRejected` when a handler refused the result; `cancelled` by the player or a script; `disconnected`; `timeout` after 30 minutes; `contextInvalidated` when the player walked away, died or changed world.
+     * Empty for a completed batch or a workpiece the game finished or broke. `craftingCompletingRejected` when a handler refused the result; `cancelled` by the player or a script; `disconnected`; `timeout` after 30 minutes; `contextInvalidated` when the player walked away, died or changed world. Smithing adds `abandoned` (the recipe never reached the anvil), `abandonTooLate`, `invalidQuality` and `inventoryUnavailable`.
      */
     reason: string;
 
     /**
-     * The inventory rows ingredients went back to. Wholly unmilled bowl, mortar and herb groups come back; everything else put on the table was spent.
+     * The inventory rows ingredients went back to. Alchemy: wholly unmilled bowl, mortar and herb groups come back; everything else put on the table was spent. Smithing: a failed workpiece spends half of each divisible material, rounded down, and a coin decides a single unit; the rest comes back.
      */
     refunded: InventoryUnit[];
   }
@@ -2305,6 +2393,11 @@ declare global {
      * Units required for one attempt.
      */
     amount: number;
+
+    /**
+     * A quest item, which only its quest hands out: the game cannot create one, so the inventory refuses it (`questItem`) and Player.giveItem returns false. It must be held to craft, and is never taken.
+     */
+    quest: boolean;
   }
 
   /**
@@ -2408,7 +2501,7 @@ declare global {
   }
 
   /**
-   * Who holds an alchemy table. A player keeps it between batches until they leave it.
+   * Who holds a station. A player keeps an alchemy table between batches until they leave it; a smithery is held for one workpiece.
    */
   interface CraftStationOccupant {
     /**
@@ -2427,9 +2520,9 @@ declare global {
     sessionId: string;
 
     /**
-     * `entering` until the opening animation finishes; `finishing` while a finished batch waits to settle.
+     * `entering` until the opening animation finishes; `finishing` while a finished batch waits to settle; `working` at a smithery.
      */
-    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches' | 'working';
 
     /**
      * Milliseconds until the table is taken back. Each batch has 30 minutes.
@@ -2438,7 +2531,7 @@ declare global {
   }
 
   /**
-   * One table in one virtual world. A free table may still be unusable in the game, for instance behind a quest layer.
+   * One station in one virtual world. A free station may still be unusable in the game, for instance behind a quest layer.
    */
   interface CraftStationOccupancy {
     /**
@@ -2463,11 +2556,16 @@ declare global {
   }
 
   /**
-   * A player's alchemy session, or the table they kept between batches. A copy: changing it changes nothing.
+   * A player's alchemy session or kept table, or their smithing workpiece. A copy: changing it changes nothing.
    */
   interface CraftSessionInfo {
     /**
-     * The batch's session id.
+     * Which craft.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * The session id.
      */
     id: string;
 
@@ -2477,24 +2575,34 @@ declare global {
     station: string;
 
     /**
-     * The table's virtual world.
+     * The station's virtual world.
      */
     virtualWorld: number;
 
     /**
-     * Where the batch is.
+     * Where the batch is; `working` for a smithing workpiece.
+     */
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches' | 'working';
+
+    /**
+     * Alchemy only: native actions accepted so far.
+     */
+    sequence: number | undefined;
+
+    /**
+     * Alchemy only: what is on the table: item class, the inventory row it came from (empty for a base liquid), and the native table position.
      */
-    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
+    resources: { id: number; item: string; itemId: string; position: number; base: boolean; milled: boolean; distilled: boolean }[] | undefined;
 
     /**
-     * Native actions accepted so far.
+     * Smithing only: the recipe being worked.
      */
-    sequence: number;
+    recipe: string | undefined;
 
     /**
-     * What is on the table: item class, the inventory row it came from (empty for a base liquid), and the native table position.
+     * Smithing only: the units taken from the inventory for this workpiece. Quest materials are required but never taken.
      */
-    resources: { id: number; item: string; itemId: string; position: number; base: boolean; milled: boolean; distilled: boolean }[];
+    materials: { item: string; amount: number }[] | undefined;
 
     /**
      * Milliseconds until the session times out.
@@ -2503,11 +2611,11 @@ declare global {
   }
 
   /**
-   * Crafting catalogs, alchemy table occupancy, sessions and recipe knowledge. Held in memory for each connection; nothing is saved.
+   * Crafting catalogs, station occupancy, alchemy and smithing sessions, and alchemy recipe knowledge. Held in memory for each connection; nothing is saved.
    */
   const Crafting: {
     /**
-     * True for alchemy, false for smithing, which is not synchronized yet. Omitted kind checks alchemy.
+     * True: alchemy and smithing are both ruled by the server. Omitted kind checks alchemy.
      */
     isAvailable(kind?: 'alchemy' | 'smithing'): boolean;
 
@@ -2522,17 +2630,17 @@ declare global {
     recipes(player: Player, kind?: 'alchemy' | 'smithing'): readonly CraftRecipeInfo[];
 
     /**
-     * The player's alchemy session or the table they kept between batches, or null.
+     * The player's alchemy session or the table they kept between batches, else their smithing workpiece, else null.
      */
     session(player: Player): CraftSessionInfo | null;
 
     /**
-     * Who holds a table. World defaults to 0. Null for an unknown or non-alchemy station.
+     * Who holds a station. World defaults to 0. Null for an unknown station.
      */
     occupancy(stationId: string, virtualWorld?: number): CraftStationOccupancy | null;
 
     /**
-     * Ends the player's session as leaving the table would: wholly unmilled groups go back to the inventory, the rest is spent, the table is released and their game closes it. `craftingEnded` follows next tick. False when there was nothing to end.
+     * Ends the player's session as leaving the station would, and their game closes it. Alchemy: wholly unmilled groups go back to the inventory, the rest is spent. Smithing: the workpiece fails, spending its failure share. `craftingEnded` follows next tick. False when there was nothing to end.
      */
     cancel(player: Player): boolean;
 
@@ -3156,6 +3264,173 @@ declare global {
 
   interface Blip extends Entity {}
 
+  /** */
+  interface LevelEditDefinition {
+    /**
+     * What the object is; a brush when omitted. A brush has no identity of its own, so it is found by its mesh and where the level put it; a level entity by its EntityGuid.
+     */
+    kind: 'brush' | 'entity' | undefined;
+
+    /**
+     * A brush's mesh path, `objects/...cgf`, as the World Builder shows it; required for a brush. An entity's name, kept for reading only.
+     */
+    name: string | undefined;
+
+    /**
+     * An entity's level EntityGuid as sixteen hex digits; required for an entity.
+     */
+    guid: string | undefined;
+
+    /**
+     * An entity's class, kept for reading only.
+     */
+    class: string | undefined;
+
+    /**
+     * Where the level put the object: its pivot, matched within 5 cm. A brush's key, with its mesh.
+     */
+    at: Vector3 | number[];
+
+    /**
+     * Whether it is taken out of the world: not drawn and not solid.
+     */
+    hidden: boolean | undefined;
+
+    /**
+     * Where it stands instead; present, the edit is a move.
+     */
+    position: Vector3 | number[] | undefined;
+
+    /**
+     * A move's orientation: a Quaternion, {x, y, z, w} or [x, y, z, w]. None when omitted.
+     */
+    rotation: Quaternion | number[] | undefined;
+
+    /**
+     * A move's scale per axis, from 0.01 to 100. None when omitted.
+     */
+    scale: Vector3 | number[] | undefined;
+  }
+
+  /**
+   * One change the server makes, for every player, to an object the level itself placed -- a brush or a level entity taken out of the world, moved, or both. It is what a World Builder map's `world` array carries.
+   */
+  class LevelEdit {
+    /**
+     * Wraps an edit the server already holds; use LevelEdit.apply or LevelEdit.applyMap to make one.
+     * @param id Network entity identifier.
+     */
+    constructor(id: number);
+
+    /**
+     * Immutable network entity identifier.
+     */
+    readonly id: number;
+
+    /**
+     * False once the edit has been restored; every other read then returns its empty value.
+     */
+    readonly exists: boolean;
+
+    /**
+     * Whether the object is a brush, found by its mesh and where the level put it, or a level entity, found by its EntityGuid.
+     */
+    readonly kind: 'brush' | 'entity';
+
+    /**
+     * A brush's mesh path, or the name the level gives the entity.
+     */
+    readonly name: string;
+
+    /**
+     * An entity's level EntityGuid as sixteen lowercase hex digits; empty for a brush.
+     */
+    readonly guid: string;
+
+    /**
+     * The virtual world whose players see the edit, fixed when it was applied.
+     */
+    readonly virtualWorld: number;
+
+    /**
+     * Whether the object is taken out of the world: not drawn and not solid. Assignment takes it out or puts it back for every player, keeping any move.
+     */
+    hidden: boolean;
+
+    /**
+     * Whether the object stands somewhere other than where the level placed it; `move` and `clearMove` change it.
+     */
+    readonly moved: boolean;
+
+    /**
+     * Formats this edit for logging and debugging.
+     * @returns Its id, kind, object and what it does to it.
+     */
+    toString(): string;
+
+    /**
+     * Moves the object for every player, collision included.
+     * @param position Where the object stands instead.
+     * @param rotation Its orientation: a Quaternion, or Euler angles in degrees. Left out, it keeps the last move's.
+     * @param scale A uniform scale or one per axis, from 0.01 to 100. Left out, it keeps the last move's.
+     * @returns False for a gone edit or a transform that is not finite.
+     */
+    move(position: Vector3, rotation?: Quaternion | Vector3, scale?: number | Vector3): boolean;
+
+    /**
+     * Puts the object back where the level placed it, keeping it out of the world if the edit takes it out.
+     */
+    clearMove(): void;
+
+    /**
+     * Drops the edit: every player gets the object back exactly as the level had it, collision included.
+     */
+    restore(): void;
+
+    /**
+     * The definition `LevelEdit.apply` takes to make this edit again, which is what a script saves: the server keeps nothing past a restart. It is one entry of a World Builder map's `world` array.
+     * @returns Null once the edit is gone.
+     */
+    toJSON(): LevelEditDefinition | null;
+
+    /**
+     * Takes an object the level placed out of the world, or moves it, for every player in the virtual world -- whenever they join, and however far away they are. Collision goes with it. An edit already made to the same object in that world is restated rather than doubled, so applying one twice changes nothing. Kept in memory only: apply it again on boot.
+     * @param definition The object and what to do to it, in the format of one entry of a World Builder map's `world` array.
+     * @param virtualWorld Optional virtual world whose players see it; the global one when omitted.
+     * @returns The edit. Throws for a definition no client could find the object by.
+     */
+    static apply(definition: LevelEditDefinition, virtualWorld?: number): LevelEdit;
+
+    /**
+     * Applies every entry of a map's `world` array, which is how edits made in the World Builder reach every player instead of being loaded by hand on each.
+     * @param map A World Builder map saved from the editor, as its JSON text or the parsed object. Only its `world` array is read: its placed objects are `Prop.spawn`'s, its areas `Area.create`'s.
+     * @param virtualWorld Optional virtual world whose players see the edits; the global one when omitted.
+     * @returns One edit per entry, in the map's order. Throws, naming the entry, for one no client could find the object by.
+     */
+    static applyMap(map: string | Record<string, unknown>, virtualWorld?: number): LevelEdit[];
+
+    /**
+     * Lists every edit the server currently has.
+     * @param virtualWorld Optional virtual world to list; omitted lists every one of them.
+     * @returns One handle per live edit, in no particular order.
+     */
+    static all(virtualWorld?: number): LevelEdit[];
+
+    /**
+     * Looks an edit up by its network entity ID.
+     * @param id Network entity identifier.
+     * @returns The edit, or null when no live edit has that ID.
+     */
+    static getById(id: number): LevelEdit | null;
+
+    /**
+     * Drops edits, giving every player the objects back as the level had them.
+     * @param virtualWorld Optional virtual world to clear; omitted clears every one of them.
+     * @returns How many edits were dropped.
+     */
+    static restoreAll(virtualWorld?: number): number;
+  }
+
   /**
    * A server-owned NPC: spawned by a resource, simulated by whichever client is nearest.
    */
@@ -3269,6 +3544,54 @@ declare global {
      */
     toString(): string;
 
+    /**
+     * Checks whether this NPC's nametag is drawn; the same switch as the `nametag` property.
+     * @returns True while the nametag is shown.
+     */
+    isNametagVisible(): boolean;
+
+    /**
+     * Shows or hides the name over this NPC's head for every player; the same switch as the `nametag` property. Each player can still hide all nametags locally.
+     * @param visible True to draw this NPC's nametag for every player, false to hide it.
+     */
+    setNametagVisible(visible: boolean): void;
+
+    /**
+     * Checks whether the health bar under this NPC's nametag is shown.
+     * @returns True unless the health bar was hidden.
+     */
+    isNametagHealthVisible(): boolean;
+
+    /**
+     * Shows or hides the health bar under this NPC's nametag, leaving the name itself alone.
+     * @param visible True to show the health bar under this NPC's name, false to hide it.
+     */
+    setNametagHealthVisible(visible: boolean): void;
+
+    /**
+     * Reads this NPC's nametag text override.
+     * @returns The override, or an empty string when the NPC's `name` is drawn.
+     */
+    getNametagText(): string;
+
+    /**
+     * Overrides the text drawn on this NPC's nametag without renaming it: `name` still reaches conversation and the soul.
+     * @param text Text to show instead of the NPC's name; empty or omitted restores the name.
+     */
+    setNametagText(text?: string): void;
+
+    /**
+     * Reads this NPC's nametag color.
+     * @returns Packed 0xAARRGGBB color; opaque white when untinted.
+     */
+    getNametagColor(): number;
+
+    /**
+     * Tints the text on this NPC's nametag.
+     * @param color Packed 0xAARRGGBB color.
+     */
+    setNametagColor(color: number): void;
+
     /**
      * Despawns this NPC everywhere, after emitting npcDestroy.
      */
@@ -3862,6 +4185,11 @@ declare global {
      */
     readonly lockpickable: boolean;
 
+    /**
+     * The level areas that link this door as one of their `crime_door`s -- the house, workshop or storage room it belongs to, as the level itself records it. Nothing is inferred from where the door stands.
+     */
+    readonly areas: Area[];
+
     /**
      * Whether the level builds this door locked, which is the state it has at boot.
      */
@@ -3902,6 +4230,13 @@ declare global {
      */
     static find(guid: string, virtualWorld?: number): Door | null;
 
+    /**
+     * Lists the doors the level links to an area as its `crime_door`s, with their GUID, name, position and link type, straight from the level catalog -- so a door that no client has reported yet is listed too. Pass a `guid` to `Door.find` for the live handle and its `locked` state. Only native links: a script area has none.
+     * @param areaId The area's id, as `area.id` prints it.
+     * @returns The doors; empty for an unknown area or one with no links.
+     */
+    static getForArea(areaId: string): AreaDoor[];
+
     /**
      * Asks a player's client which door their body is standing at. The server knows every door the level places but has no world to measure distances in, so this is how a command finds the door in front of a player, and the answer is what that client sees now rather than what the replica last carried.
      * 
@@ -4028,6 +4363,294 @@ declare global {
 
   interface Gate extends Entity {}
 
+  /** */
+  interface AreaDefinition {
+    /**
+     * The area's identity, unique among script areas. It may not be sixteen hex digits, which is how a level area's GUID reads.
+     */
+    id: string;
+
+    /**
+     * A readable name; the id when omitted.
+     */
+    name: string | undefined;
+
+    /**
+     * CryEngine's own area shapes: `AreaBox`, `AreaShape` (a closed polygon with a height) and `AreaSphere`.
+     */
+    type: 'box' | 'shape' | 'sphere';
+
+    /**
+     * Where the shape is placed from; the origin when omitted.
+     */
+    position: Vector3 | undefined;
+
+    /**
+     * The shape's orientation: a Quaternion or {x, y, z, w}, or Euler angles in degrees.
+     */
+    rotation: Quaternion | Vector3 | undefined;
+
+    /**
+     * box: the corner nearest negative infinity, relative to `position` before rotation.
+     */
+    min: Vector3 | undefined;
+
+    /**
+     * box: the opposite corner. Every component must be above `min`'s.
+     */
+    max: Vector3 | undefined;
+
+    /**
+     * shape: 3 to 256 corners relative to `position` before rotation, closed back to the first. As in the engine, the floor is the lowest corner.
+     */
+    points: Vector3[] | undefined;
+
+    /**
+     * shape: how far above its lowest corner the area reaches; 0, the default, for no ceiling.
+     */
+    height: number | undefined;
+
+    /**
+     * sphere: its radius around `position`.
+     */
+    radius: number | undefined;
+
+    /**
+     * Free-form labels, found again with `Area.withLabel`.
+     */
+    labels: string[] | undefined;
+
+    /**
+     * Anything JSON can hold, kept on the area for scripts.
+     */
+    metadata: Record<string, unknown> | undefined;
+
+    /**
+     * The one virtual world it belongs to; every world when omitted.
+     */
+    virtualWorld: number | undefined;
+
+    /**
+     * Whether it starts enabled; true when omitted.
+     */
+    enabled: boolean | undefined;
+  }
+
+  /** */
+  interface AreaDoor {
+    /**
+     * The door's level EntityGuid as hex, which `Door.find` takes.
+     */
+    guid: string;
+
+    /**
+     * The entity name the level gives the door.
+     */
+    name: string;
+
+    /**
+     * Where the level places the door.
+     */
+    position: Vector3;
+
+    /**
+     * The `crime_doorKind` the level gives the link: the way in, an inner door, or a storage room's.
+     */
+    link: 'entrance' | 'basic' | 'storage';
+  }
+
+  /**
+   * Handle for one area: one of the level's own gameplay areas, or one a script or the World Builder drew. The server tests who is inside itself, by the game's own rule for that kind of area.
+   */
+  class Area {
+    /**
+     * Wraps an area handle the server already holds; use Area.create, Area.getById or the lookups to get one.
+     * @param handle Internal area handle.
+     */
+    constructor(handle: number);
+
+    /**
+     * False once a script area has been destroyed; every other read then returns its empty value.
+     */
+    readonly exists: boolean;
+
+    /**
+     * The stable identity to store an area under. A level area's is its EntityGuid as sixteen lowercase hex digits, the same on every machine and every boot, as `door.guid` prints a door's; a script area's is the id it was created with.
+     */
+    readonly id: string;
+
+    /**
+     * Whether the level placed it or a script built it.
+     */
+    readonly kind: 'level' | 'script';
+
+    /**
+     * A level area's entity class -- a `TriggerArea` prism, an `AreaUnion` of them, or a `SmartAreaShape` -- or a script area's shape.
+     */
+    readonly type: 'TriggerArea' | 'AreaUnion' | 'SmartAreaShape' | 'box' | 'shape' | 'sphere';
+
+    /**
+     * The level's entity name, or the script area's name. Only a script area's can be changed.
+     */
+    name: string;
+
+    /**
+     * The level's own `Label` values -- `private`, `personal`, `interior`, `prohibited`, `castle` and the rest the game's AI reads -- or a script area's labels. Only a script area's can be changed.
+     */
+    labels: string[];
+
+    /**
+     * Whatever a script keeps on a script area: ownership, a type, rules. Stored as JSON, so read it, change it and assign it back. Always empty on a level area.
+     */
+    metadata: Record<string, unknown>;
+
+    /**
+     * Whether crossings are raised and the lookups find it. Switching it off raises `areaExit` for everyone inside on the next tick; switching it on, `areaEnter`. Works on level areas too.
+     */
+    enabled: boolean;
+
+    /**
+     * The one virtual world a script area belongs to, or null for all of them. A body in another world still crosses it, with `matchingVirtualWorld` false. A level area is in every world.
+     */
+    virtualWorld: number | null;
+
+    /**
+     * A script area's origin, which its shape is placed from; assignment moves it. A level area's is the centre of its bounds.
+     */
+    position: Vector3;
+
+    /**
+     * A script area's orientation; assignment turns it. A level area's shape is already in world space, so its rotation is the identity.
+     */
+    rotation: Quaternion;
+
+    /**
+     * How far above its lowest point a prism reaches, in metres; 0 for a shape with no ceiling. A TriggerArea's comes from the level's baked prism.
+     */
+    readonly height: number;
+
+    /**
+     * For a SmartAreaShape bound to one of the game's map locations, that location's English name, e.g. a settlement. Empty otherwise.
+     */
+    readonly location: string;
+
+    /**
+     * The world box around the area. An area with no ceiling reaches far above and below.
+     */
+    readonly bounds: { min: Vector3; max: Vector3 };
+
+    /**
+     * For an AreaUnion, the TriggerAreas it joins; it contains whatever one of them does. Empty otherwise.
+     */
+    readonly members: Area[];
+
+    /**
+     * The doors the level itself links to this area as its `crime_door`s, which is how the game knows a house's doors. Only native links: nothing is inferred from where a door stands.
+     */
+    readonly doors: AreaDoor[];
+
+    /**
+     * Every player inside as of the last tick, in any world.
+     */
+    readonly players: Player[];
+
+    /**
+     * Every body inside as of the last tick: players, horses, carts and server NPCs.
+     */
+    readonly occupants: (Player | Horse | Cart | Npc)[];
+
+    /**
+     * Formats this area for logging and debugging.
+     * @returns Its id, kind, type and name.
+     */
+    toString(): string;
+
+    /**
+     * Tests a position the way the game tests its own areas, whether or not the area is enabled and in whatever world.
+     * @param position The world position to test.
+     * @returns True when the position is inside.
+     */
+    contains(position: Vector3): boolean;
+
+    /**
+     * Tests where a body stands right now, and in which world: an area bound to another virtual world does not contain it. This is containment only -- whether the game considers the player to be trespassing is decided by its own crime system on the player's client.
+     * @param player The body to test; a player who has not reported a pose yet is never inside.
+     * @returns True when the body is inside.
+     */
+    containsPlayer(player: Player | Horse | Cart | Npc): boolean;
+
+    /**
+     * Moves, turns or reshapes a script area. Bodies standing where it now is, or was, get their `areaEnter` and `areaExit` on the next tick. A level area cannot be reshaped.
+     * @param definition The shape fields to change; any left out keep their value. `id`, `labels`, `metadata` and the rest are ignored here.
+     * @returns False for a level area, a gone one, or a shape the engine could not build.
+     */
+    setShape(definition: Partial<AreaDefinition>): boolean;
+
+    /**
+     * Removes a script area. Every body still inside gets its `areaExit` first, while the handle still resolves.
+     * @returns False for a level area or one already gone.
+     */
+    destroy(): boolean;
+
+    /**
+     * The definition `Area.create` takes to build this area again, which is what a script saves: the server keeps nothing past a restart. It is the format the World Builder exports too.
+     * @returns Null for a level area, which the level always builds.
+     */
+    toJSON(): AreaDefinition | null;
+
+    /**
+     * Builds a script area. Bodies already standing in it get `areaEnter` on the next tick. Kept in memory only: save `area.toJSON()` wherever the resource keeps its data, and create it again on boot.
+     * @param definition The area to build, in the format `area.toJSON()` and the World Builder export write.
+     * @returns The new area. Throws for an id already taken or a shape the engine could not build.
+     */
+    static create(definition: AreaDefinition): Area;
+
+    /**
+     * Looks an area up by its stable identity.
+     * @param id A script area's id, or a level area's GUID in hex as `area.definition.id` prints it.
+     * @returns The area, or null when there is none.
+     */
+    static getById(id: string): Area | null;
+
+    /**
+     * Every enabled area containing a position, level and script alike.
+     * @param position The world position to test.
+     * @param virtualWorld Optional world; when given, a script area bound to another world is left out.
+     * @returns The areas, in no particular order.
+     */
+    static getAt(position: Vector3, virtualWorld?: number): Area[];
+
+    /**
+     * Every enabled area the body stands in right now, in its own world.
+     * @param player The body whose position and world to test.
+     * @returns The areas; empty for a player who has not reported a pose yet.
+     */
+    static getAtPlayer(player: Player | Horse | Cart | Npc): Area[];
+
+    /**
+     * Every area whose bounds come within a radius of a position, enabled or not.
+     * @param position Where to look from.
+     * @param radius How far, in metres, from the area's bounds.
+     * @param virtualWorld Optional world; when given, a script area bound to another world is left out.
+     * @returns The areas, nearest first.
+     */
+    static nearby(position: Vector3, radius: number, virtualWorld?: number): Area[];
+
+    /**
+     * Every area carrying a label, such as `private` or `castle`.
+     * @param label The label, compared without regard to case.
+     * @returns The areas, level ones first.
+     */
+    static withLabel(label: string): Area[];
+
+    /**
+     * Every area the server knows.
+     * @param kind Optional: only the level's areas, or only script ones.
+     * @returns The areas, level ones first.
+     */
+    static all(kind?: 'level' | 'script'): Area[];
+  }
+
   /**
    * Replicated container handle: one a script spawned, or one the level places.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingdomsconnected/types",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "TypeScript declarations for the Kingdoms Connected scripting API, one entry per side: @kingdomsconnected/types/server and @kingdomsconnected/types/client",
   "license": "UNLICENSED",
   "keywords": [