@kingdomsconnected/types 1.5.0 → 1.5.2

package/{server/index.d.ts → generated/server-api.d.ts}

@@ -50,21 +50,76 @@ declare global {
      */
     playerSpawning: [player: Player];
 
+    /**
+     * Dispatched once when the animation a `playAnimation` request started is over. `fragment` is the request's. `reason` says how: `finished` when a one-shot played to its end, `interrupted` when it was playing and something cut it short (a hit, a weapon drawn, a teleport), `refused` when the game would not start it at all, `stopped` for `stopAnimation`, `replaced` for another `playAnimation`.
+     * 
+     * The first three come from the player's own client, sent from the moment the game's animation system ended it, so this is the place to chain the next animation. A `loop` never finishes by itself and only ends `stopped` or `replaced`. A request with no fragment -- one that only holds a prop or a tag -- raises nothing.
+     */
+    playerAnimationEnd: [player: Player, fragment: string, reason: 'finished' | 'interrupted' | 'refused' | 'stopped' | 'replaced'];
+
+    /**
+     * Dispatched when a player has picked up another player's body, before the server accepts it -- the place to decide who may carry whom. Return `false` from a handler and the carry is refused: the carrier's client is told to let go at once, and no `playerCarry` follows. Handlers run synchronously, so the decision cannot wait on anything awaited.
+     * 
+     * The pick-up is the game's own "grab" prompt, which it offers only over a body that is down -- dead or unconscious -- so a player a script revives at once is never there to carry. The carrier's game has already started the pick-up when this runs.
+     */
+    playerCarrying: [carrier: Player, carried: Player];
+
+    /**
+     * Dispatched once a carry is accepted: the carried body is on the carrier's shoulder on every client, and `carrier.carrying` names it. It rides there until `playerPutDown`.
+     */
+    playerCarry: [carrier: Player, carried: Player];
+
+    /**
+     * Dispatched once a carry is over, however it ended: the carrier dropped the body, `putDown` asked them to, the carried player was revived, or either of them left. A player who is leaving is still readable here; the event comes before their body is destroyed.
+     */
+    playerPutDown: [carrier: Player, carried: Player];
+
     /**
      * Dispatched once a joining player is really standing in the world: their level is up, their body is where `playerSpawning` put it, and the ground under it has loaded. Anything that acts on an arriving player -- kit, a welcome line, a marker -- belongs here rather than in `playerConnect`, which fires while they are still loading the level, or in `playerSpawning`, where the body is still mid-placement.
+     * 
+     * The player may still be looking at the game's loading screen; `playerReady` follows once they are not.
      */
     playerSpawned: [player: Player];
 
+    /**
+     * Dispatched once per connection, after `playerSpawned`, when the player can play: their own client reports that the game has taken its loading screen down. The game raises that moment itself -- it is its own gameplay-start signal, not a guess from timing.
+     * 
+     * That player's client resources were already running at `playerSpawned`, so this is not needed to make sure a `player.emit` is received. It is for what the player should actually see on arrival -- a welcome, a first page, a camera shot -- which shown earlier would play behind the loading screen. A client that never gets that far, or disconnects first, never raises it.
+     */
+    playerReady: [player: Player];
+
+    /**
+     * An inventory changed. Raised on the next server tick in the order the changes happened, once per inventory an operation touched: a transfer raises it for both players. A handler may change inventories; those changes arrive on a later tick. Every change of a player who disconnects is raised before `playerDisconnect`. Save from here to keep inventories across sessions -- the server keeps nothing itself.
+     */
+    playerInventoryChanged: [player: Player, change: InventoryChange];
+
+    /**
+     * The player's game spent items: ate, drank, applied or fired them. Raised after the `playerInventoryChanged` that removed them. `item` is the class GUID.
+     * 
+     * This is the player's own game saying so: the server checked that the units existed and were of a kind that can be spent that way, and took them, but did not see the meal or the shot. A handler that rewards a use -- a heal, a buff -- can be had for the price of the item.
+     */
+    playerItemUsed: [player: Player, item: string, kind: "food" | "potion" | "ointment" | "shot", amount: number];
+
+    /**
+     * A player's game shows their inventory for the first time this session. Their inventory exists from `playerConnect`; restore a saved one there with `Inventory.set`, and it is what they load in with.
+     */
+    playerInventoryReady: [player: Player];
+
     /**
      * Dispatched immediately after a horse is created and replicated, whether by `Horse.spawn`, the `/horse` command, or anything else.
      */
     horseSpawn: [horse: Horse];
 
     /**
-     * Dispatched while a horse is being despawned. The handle still resolves, so its rider and name can be read one last time.
+     * Dispatched while a horse is being despawned, including the despawn its owner's disconnect implies. The handle still resolves, so its owner and name can be read one last time.
      */
     horseDestroy: [horse: Horse];
 
+    /**
+     * Dispatched after a horse is handed to another player, or left ownerless -- by `giveTo`, or by its owner disconnecting while `destroyWithOwner` is false.
+     */
+    horseOwnerChanged: [horse: Horse, player: Player | null];
+
     /**
      * Dispatched after a player climbs into a saddle and the horse's authority has been handed to their client.
      */
@@ -139,6 +194,31 @@ 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.
+     */
+    craftingStarting: [player: Player, proposal: CraftStartProposal];
+
+    /**
+     * A batch is brewing.
+     */
+    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.
+     */
+    craftingCompleting: [player: Player, proposal: CraftCompletionProposal];
+
+    /**
+     * A batch's 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.
+     */
+    craftingEnded: [player: Player, event: CraftEndedEvent];
+
     /**
      * Dispatched immediately after a dog is created and replicated, whether by `Dog.spawn` or anything else.
      */
@@ -229,6 +309,11 @@ declare global {
      */
     npcRevive: [npc: Npc];
 
+    /**
+     * Dispatched once when the animation a `playAnimation` request started is over; `fragment` is the request's. `reason` is `finished`, `interrupted`, `refused`, `stopped` or `replaced`, as for `playerAnimationEnd`. The first three come from the client simulating the NPC. One that nobody simulates plays nothing, so its one-shot ends `refused` as soon as it is asked for, and one cut off by a change of simulator ends `interrupted`: the new simulator does not replay what it did not see start.
+     */
+    npcAnimationEnd: [npc: Npc, fragment: string, reason: 'finished' | 'interrupted' | 'refused' | 'stopped' | 'replaced'];
+
     /**
      * Dispatched when a player presses use on an NPC whose `interactable` is on. The client reports the press and the server confirms the distance against the position it already replicates, so a claim it does not agree with never reaches here.
      */
@@ -259,6 +344,16 @@ declare global {
      */
     groundItemPickup: [groundItem: GroundItem, player: Player | null];
 
+    /**
+     * A player picked a plant within their reach, and the server is about to give them the herb. Return false to refuse it: nothing is given and the plants stay. The proposal is frozen; every handler runs whatever an earlier one returned, and an async handler cannot refuse.
+     */
+    gatheringHarvest: [player: Player, proposal: GatheringProposal];
+
+    /**
+     * A player was given a herb, after the `playerInventoryChanged` it caused. The plant and the same-kind plants harvested with it are picked for everyone in the virtual world until they regrow; nothing about them survives a restart.
+     */
+    gatheringHarvested: [player: Player, event: GatheringHarvestedEvent];
+
     /**
      * Dispatched when a player's client reports working a door, before the server applies it. `action` is `open`, `close`, `lock`, `unlock` or `lockpick`; a key turned in the same use as the push arrives as `unlock` and then `open`. `keySide` says whether the player stood on the side with the keyhole, which is where an unlock needs a key.
      * 
@@ -266,6 +361,38 @@ declare global {
      */
     doorInteract: [player: Player, door: Door, action: "open" | "close" | "lock" | "unlock" | "lockpick", keySide: 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()`.
+     */
+    stashSpawn: [stash: Stash];
+
+    /**
+     * A player opened a container and sees what it holds.
+     */
+    stashOpen: [stash: Stash, player: Player];
+
+    /**
+     * A player no longer has a container open: they closed it, walked away, died or changed world (`lostAccess`), sent nothing for two minutes, left, or the container went.
+     */
+    stashClose: [stash: Stash, player: Player, reason: "closed" | "lostAccess" | "timeout" | "disconnected" | "destroyed"];
+
+    /**
+     * What a container holds changed. `player` moved the units -- `change.reason` is `deposit` or `withdraw`, and their inventory raises `playerInventoryChanged` too -- or is null for a script's `addItem`, `removeItem` or `setInventory`, or `destroy` when the container went with something in it. Save from here to keep contents across restarts: the server keeps nothing itself. A linked child's `stash` is the one the player used; its stock is its master's.
+     */
+    stashInventoryChanged: [stash: Stash, player: Player | null, change: InventoryChange];
+
+    /**
+     * A container is about to go. Raised after its close and its contents' removal, while it can still be read.
+     */
+    stashDestroy: [stash: Stash];
+
+    /**
+     * Dispatched when a player presses a container's prompt, before anything happens: the player's client holds the game's own handler until the server answers. `action` is `open`, `unlock` -- a key turned, which opens it in the same use -- or `lockpick`, the minigame starting; a successful pick then opens it without asking again.
+     * 
+     * Return false to refuse it: the prompt does nothing, and no transfer screen, key or minigame ever appears. Every handler runs whatever an earlier one returned, and an async handler cannot refuse. The server has already refused what the game's own rules forbid -- a player out of reach, a container another player has open, opening a locked one, picking one that cannot be -- so this only sees what the game would allow. Closing is never asked.
+     */
+    stashInteract: [player: Player, stash: Stash, action: "open" | "unlock" | "lockpick"];
+
     /**
      * Dispatched when a player submits a plain chat line. Turn `Chat.setDefaultRelay(false)` off to own delivery yourself.
      */
@@ -301,6 +428,41 @@ declare global {
      */
     playerBuffBlocked: [player: Player, buff: string];
 
+    /**
+     * Dispatched when a player's own game produced XP -- a hit landed, a lock picked, a page read -- and asks for it. Return `false` to refuse it; the gain then never happens. `xp` is before this server's rate and the player's own multipliers. `source` is the game's name for what caused it: `Attack`, `LockpickingResult` and so on, or empty. Nothing is asked while `Progression.setNativeXp(false)` is in force.
+     */
+    playerXpGaining: [player: Player, track: string, xp: number, source: string];
+
+    /**
+     * Dispatched when XP landed on a player's character, from their game or from this server, after every multiplier.
+     */
+    playerXpGained: [player: Player, track: string, xp: number];
+
+    /**
+     * Dispatched when one of a player's tracks reaches a new level. `perkPoints` is what that track's tree now has unspent.
+     */
+    playerLevelUp: [player: Player, track: string, level: number, perkPoints: number];
+
+    /**
+     * Dispatched when a player confirmed a perk on the perk screen and every rule of the game allows it: the tree's level, the parent perk, the exclusive partner, a point to spend, and this server's block list. Return `false` to refuse it; the point is not spent and their client raises `progressionPerkRefused`.
+     */
+    playerPerkLearning: [player: Player, perk: string];
+
+    /**
+     * Dispatched when a perk appeared on a player's character: learnt on the perk screen, given by this server, or granted by the game on its own -- a codex entry, a recipe, a combat move it teaches.
+     */
+    playerPerkAdded: [player: Player, perk: string, source: "learned" | "server" | "native"];
+
+    /**
+     * Dispatched when a perk left a player's character: taken or respecced by this server, or removed by the game.
+     */
+    playerPerkRemoved: [player: Player, perk: string, source: "server" | "native"];
+
+    /**
+     * Dispatched when a player's client reported progression this server never ordered: a track that rose further than any gain it granted could take it, or a perk-screen perk nobody learnt. The report is kept -- the game has no way to take a level back -- so what happens to the player is the handler's call; a kick is the usual answer.
+     */
+    playerProgressionRejected: [player: Player, reason: string];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -315,6 +477,16 @@ declare global {
      * Dispatched when one key of an entity's state changes: on the server when a script writes it, on a client when the write arrives. `value` is undefined when the key was removed and `previous` is undefined when it held nothing before, so a stored null stays distinguishable from an absent key. The entity is whatever the game's WrapScriptEntity answers, and the base Entity handle by default.
      */
     entityStateChange: [entity: Entity, key: string, value: any, previous: any];
+
+    /**
+     * Dispatched for a line typed into the server console that no built-in command (help, ensure, refresh, ...) claimed. `args` is the rest of the line, split on whitespace. The console is the operator's, so this is the place for commands no player may run.
+     */
+    consoleCommand: [command: string, args: string[]];
+
+    /**
+     * Dispatched when a player asks to join, before the connection exists: they hold no player slot, are not counted as online, and are sent nothing -- no resource list, no download, no body. The request waits until every handler has returned and every Promise a handler returned has settled, then it is let in if a player slot is free (otherwise it is refused as full). `connection.reject()` turns it away instead, and so does a handler that throws or rejects, or handlers that have not settled within the server's admission timeout (30 seconds by default, restarted by every `connection.update()`). With no handler at all, every request is let in at once.
+     */
+    playerConnecting: [connection: PendingConnection];
   }
 
   /** Names of native events available in this scripting environment. */
@@ -449,6 +621,231 @@ declare global {
     unarmed: number;
   }
 
+  /**
+   * One skill or stat a player levels, as the game's own tables describe it.
+   */
+  interface TrackInfo {
+    /**
+     * The name every progression verb takes, as the game's tables spell it: `weapon_sword`, `thievery`, `strength`.
+     */
+    name: string;
+
+    /**
+     * Whether it is a skill or one of the stats the skills sit on.
+     */
+    kind: "skill" | "stat";
+
+    /**
+     * The highest level the game lets it reach.
+     */
+    cap: number;
+
+    /**
+     * True for fencing alone: it is never earned, the game derives it from the five weapon skills, so XP handed to it is refused.
+     */
+    induced: boolean;
+  }
+
+  /**
+   * One perk, as the game's own perk tables describe it.
+   */
+  interface PerkInfo {
+    /**
+     * The perk's `perk_name`, unique across the tables, and the spelling every perk verb takes alongside its GUID.
+     */
+    name: string;
+
+    /**
+     * The perk's GUID.
+     */
+    id: string;
+
+    /**
+     * The localisation key the perk screen shows, or empty for a perk it never shows.
+     */
+    uiName: string;
+
+    /**
+     * The track whose points pay for it: a track name, `main` for the main-level bank, or null for a perk no player's tree carries.
+     */
+    track: string | null;
+
+    /**
+     * The level that track has to reach before the perk can be learnt. 0 for none.
+     */
+    level: number;
+
+    /**
+     * The perk that has to be owned first, or null.
+     */
+    parent: string | null;
+
+    /**
+     * `visible` perks are the ones on the perk screen and the only ones a player can learn; `hidden` ones appear once something grants them; `system` ones implement game features and are never shown.
+     */
+    visibility: "system" | "hidden" | "visible" | "obsolete";
+
+    /**
+     * What the perk does when owned, from the game's side tables: `buff` (a real status effect), `script`, `technique` (a combat move), `ability`, `param` (rewrites a game rule), `companion` (the dog), `recipe`, `codex`. Empty for a perk that only gates others.
+     */
+    kinds: string[];
+
+    /**
+     * Whether the game grants it on its own once its requirements are met, rather than on the perk screen.
+     */
+    autolearnable: boolean;
+  }
+
+  /**
+   * Where a player stands on one track.
+   */
+  interface TrackProgress {
+    /**
+     * The level reached.
+     */
+    level: number;
+
+    /**
+     * XP earned towards the next level, in the game's own units.
+     */
+    xp: number;
+
+    /**
+     * XP the next level costs in total, from the start of this one. `xp / xpToNext` is the bar the character sheet draws.
+     */
+    xpToNext: number;
+
+    /**
+     * Unspent perk points in this track's tree.
+     */
+    perkPoints: number;
+  }
+
+  /**
+   * A player's level on every track, keyed by track name.
+   */
+  interface TrackLevels {
+    /**
+     * The level reached.
+     */
+    stealth: number;
+
+    /**
+     * The level reached.
+     */
+    horse_riding: number;
+
+    /**
+     * The level reached.
+     */
+    fencing: number;
+
+    /**
+     * The level reached.
+     */
+    thievery: number;
+
+    /**
+     * The level reached.
+     */
+    alchemy: number;
+
+    /**
+     * The level reached.
+     */
+    craftsmanship: number;
+
+    /**
+     * The level reached.
+     */
+    drinking: number;
+
+    /**
+     * The level reached.
+     */
+    survival: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_sword: number;
+
+    /**
+     * The level reached.
+     */
+    heavy_weapons: number;
+
+    /**
+     * The level reached.
+     */
+    marksmanship: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_large: number;
+
+    /**
+     * The level reached.
+     */
+    weapon_unarmed: number;
+
+    /**
+     * The level reached.
+     */
+    scholarship: number;
+
+    /**
+     * The level reached.
+     */
+    houndmaster: number;
+
+    /**
+     * The level reached.
+     */
+    strength: number;
+
+    /**
+     * The level reached.
+     */
+    agility: number;
+
+    /**
+     * The level reached.
+     */
+    vitality: number;
+
+    /**
+     * The level reached.
+     */
+    speech: number;
+
+    /**
+     * The level reached.
+     */
+    prestige: number;
+  }
+
+  /**
+   * Everything a server needs to put a player's progression back: plain JSON a resource can store however it likes. A player starts every session with a fresh character, so this is how progression outlives a disconnect.
+   */
+  interface ProgressionSnapshot {
+    /**
+     * Level and XP into the next level, per track name.
+     */
+    tracks: Record<string, { level: number; xp: number }>;
+
+    /**
+     * Every perk owned, by name.
+     */
+    perks: string[];
+
+    /**
+     * Unspent points per tree: track names, and `main`.
+     */
+    perkPoints: Record<string, number>;
+  }
+
   /**
    * The pace rule a server puts on one player. Both halves default to off, and a call to `setMovementMode` states both of them.
    */
@@ -717,25 +1114,55 @@ declare global {
     readonly equipment: string[];
 
     /**
-     * Whether this player is in a saddle.
+     * The player's main level, the one the game derives from the stats, as their client last reported it. 0 until the first report.
      */
-    readonly mounted: boolean;
+    readonly level: number;
 
     /**
-     * The horse this player is riding, or null when they are on foot.
+     * The level of every skill and stat, keyed by track name, as this server last accepted it. All zero until the first report.
      */
-    readonly horse: Horse | null;
+    readonly levels: TrackLevels;
 
     /**
-     * The dog companion this player has, or null when they have none. One dog per player, as in the game.
+     * Every perk the player owns, by name.
      */
-    readonly dog: Dog | null;
+    readonly perks: string[];
 
     /**
-     * The status effects on this player's body, as their own client last reported them: potions, poison, injury, drunkenness, illness, unconsciousness, and anything this server added. Perks and equipment effects are not in here -- they follow state that already replicates.
-     * 
-     * This is the list of *named effects*. For how drunk, poisoned, hurt or tired someone actually is, read `drunkenness`, `poisoning`, `bleeding`, `consciousness`, `hunger` and `exhaust` instead: those are live numbers and need no name to look up.
-     * 
+     * Everything about this player's progression, as plain JSON to store however the resource likes. A player starts every session with a fresh character, so `restoreProgression` with a stored snapshot is how progression outlives a disconnect. Null until their client's first report.
+     */
+    readonly progression: ProgressionSnapshot | null;
+
+    /**
+     * Whether this player is in a saddle.
+     */
+    readonly mounted: boolean;
+
+    /**
+     * The player whose body this one carries on their shoulder, or null. Set once `playerCarry` has fired, cleared once `playerPutDown` has.
+     */
+    readonly carrying: Player | null;
+
+    /**
+     * The player carrying this one's body, or null.
+     */
+    readonly carriedBy: Player | null;
+
+    /**
+     * The horse this player is riding, or null when they are on foot.
+     */
+    readonly horse: Horse | null;
+
+    /**
+     * The dog companion this player has, or null when they have none. One dog per player, as in the game.
+     */
+    readonly dog: Dog | null;
+
+    /**
+     * The status effects on this player's body, as their own client last reported them: potions, poison, injury, drunkenness, illness, unconsciousness, and anything this server added. Perks and equipment effects are not in here -- they follow state that already replicates.
+     * 
+     * This is the list of *named effects*. For how drunk, poisoned, hurt or tired someone actually is, read `drunkenness`, `poisoning`, `bleeding`, `consciousness`, `hunger` and `exhaust` instead: those are live numbers and need no name to look up.
+     * 
      * Empty until the player's client sends its first report, shortly after they connect; `playerBuffAdded` fires for whatever it was already carrying.
      */
     readonly buffs: BuffState[];
@@ -753,6 +1180,71 @@ declare global {
      */
     toString(): string;
 
+    /**
+     * Where this player stands on one track: level, XP towards the next one, and unspent perk points.
+     * @param track A track name, from `Progression.tracks()`.
+     * @returns The progress, or null before their client's first report. Throws for a track name the tables do not carry.
+     */
+    getTrack(track: string): TrackProgress | null;
+
+    /**
+     * Whether this player owns a perk.
+     * @param perk A perk's name or GUID.
+     * @returns True when their last report carried it.
+     */
+    hasPerk(perk: string): boolean;
+
+    /**
+     * Grants XP on one track, through the game's own path on the player's client -- so their perks' XP multipliers apply, a level crossed pops the game's own level-up, and a level grants its perk points. Rates, budgets and caps do not apply: those rule over what a player earns, and this is the server giving.
+     * @param track A track name. Not `fencing`: the game derives it from the weapon skills.
+     * @param xp XP, in the game's own units.
+     * @returns True when the order went out. Throws for an unknown track or an xp that is not positive.
+     */
+    addXp(track: string, xp: number): boolean;
+
+    /**
+     * Raises one track to a level, as the game's own `AdvanceToSkillLevel` does: exactly the XP between the two levels, with the level-ups and perk points on the way. The game has no way to lower a level, so asking for one below the current level throws.
+     * @param track A track name. Not `fencing`.
+     * @param level The level to raise it to, at most the game's cap of 30.
+     * @returns True when the order went out; false for a level past the cap.
+     */
+    setLevel(track: string, level: number): boolean;
+
+    /**
+     * Gives this player a perk outright, spending no point and skipping the perk screen's requirements. It still has to be one the game can add: an owned or blocked perk is turned down by the game itself.
+     * @param perk A perk's name or GUID.
+     * @returns True when the order went out. Throws for an unknown perk.
+     */
+    addPerk(perk: string): boolean;
+
+    /**
+     * Takes a perk away. The point it cost is not refunded; `respecPerks` is the way to hand points back.
+     * @param perk A perk's name or GUID.
+     * @returns True when the order went out. Throws for an unknown perk.
+     */
+    removePerk(perk: string): boolean;
+
+    /**
+     * Gives this player unspent perk points in one tree, on top of what their levels earned.
+     * @param track The tree to add to: a track name, or `main` for the main-level bank.
+     * @param count How many, from 1 to 65535.
+     * @returns True when the order went out.
+     */
+    addPerkPoints(track: string, count: number): boolean;
+
+    /**
+     * The game's own respec: every perk learnt on the perk screen is taken away and every tree's points are rebuilt from the player's current levels. Perks the game granted on its own stay.
+     * @returns True when the order went out.
+     */
+    respecPerks(): boolean;
+
+    /**
+     * Puts a stored progression back: levels, XP, perks and unspent points, through the game's own paths. Only ever raises -- a track already past the snapshot keeps its level -- so call it as the player arrives, from `playerReady`, on the fresh character every session starts with.
+     * @param snapshot What `player.progression` returned, as the resource stored it.
+     * @returns True when every order went out.
+     */
+    restoreProgression(snapshot: ProgressionSnapshot): boolean;
+
     /**
      * Requests revival of this player after playerDied.
      * @returns True when sent; false when disconnected, no death was reported, or revival was already requested.
@@ -782,7 +1274,9 @@ declare global {
     /**
      * Makes this player's body play one of the game's animations, on their own screen and on everybody else's -- a wave, a bow, a woodcutter's swing with the axe in hand. It is state rather than a one-off: a player who streams in or joins while it plays sees it too, and it lasts until `stopAnimation` or the next `playAnimation`, even after a one-shot has finished.
      * 
-     * The animation is the game's own, so the game can cut it short: a hit, a fall or drawing a weapon ends it, and so can the player walking off from one that leaves the legs free. `loop` starts it again when that happens.
+     * A new `playAnimation`, `stopAnimation` and `teleport` cut a running animation at once rather than waiting for it to finish. The game can cut it short too: a hit, a fall or drawing a weapon ends it, and so can the player walking off from one that leaves the legs free. `loop` starts it again when that happens, and keeps a one-shot going pass after pass with no gap between them.
+     * 
+     * `playerAnimationEnd` fires once when the animation this request started is over, and says how. A loop ends only by being stopped or replaced.
      * 
      * A hand tag is only half of holding something. `r_bucket` makes the body move as if it carried a bucket, but the bucket itself is a `props` entry.
      * @param fragment A Mannequin fragment, as `Animations.list` names it. `""` plays none and only puts the props and tags on, which with a hand tag like `r_bucket` makes the player carry something while they walk.
@@ -792,10 +1286,35 @@ declare global {
     playAnimation(fragment: string, options?: { tags?: string; loop?: boolean; lockMovement?: boolean; props?: { item?: string; model?: string; hand?: 'right' | 'left'; joint?: string; position?: Vector3 | Partial<Vector3>; rotation?: Quaternion | Vector3 | Partial<Vector3> } | { item?: string; model?: string; hand?: 'right' | 'left'; joint?: string; position?: Vector3 | Partial<Vector3>; rotation?: Quaternion | Vector3 | Partial<Vector3> }[] }): boolean;
 
     /**
-     * Ends what `playAnimation` started, takes its props away and hands the body back to the game.
+     * Ends what `playAnimation` started at once, takes its props away and hands the body back to the game. A stance tag the animation set goes with it, so without `standUp` a seated player pops upright.
+     * 
+     * The stand-up is an animation of its own: it raises its own `playerAnimationEnd`, fragment `StandUp` or `GetUp`, once the player is on their feet, and a `playAnimation` during it replaces it.
+     * @param options `standUp` plays the game's own way back to standing when the animation held the body in a sitting or lying stance tag (`sittingNoTable`, `lyingGround`): `StandUp` or `GetUp`, in the variant that fits that stance. Without it, or for a stance the game authors no way out of (`beggarKneel`), the body goes straight back to standing.
      * @returns True when the request went out; false for a player with no body yet.
      */
-    stopAnimation(): boolean;
+    stopAnimation(options?: { standUp?: boolean }): boolean;
+
+    /**
+     * Sets this player's facial expression, on their own screen and on everybody else's, alongside whatever their body plays. It is state: a player who streams in sees it, and it lasts until the next call.
+     * 
+     * The expression is the eyes, brows and mood. It never moves the mouth -- the game's own `FE_DialogueSpeaking` animates only the eyes and leaves the mouth to the voice line being spoken. `setTalking` is the mouth.
+     * 
+     * A mood tag is one of the body's own tags, so it can change the mood of the body's idle too, for as long as the expression holds.
+     * @param fragment A fragment on the face's own scope: `FE_Default`, `FE_DialogueIdle` or `FE_DialogueSpeaking` for a held mood, or an `ADLG_FA_*` gesture (`ADLG_FA_Smile`, `ADLG_FA_Wink`, `ADLG_FA_Laugh`, `ADLG_FA_Surprise`...) that plays once. `""` hands the face back to the game.
+     * @param options `tags` pick the variant: for the `FE_*` fragments the mood, `happy`, `angry`, `sad`, `nervous`, `pensive`, `arogant` or `drunk`, as `Animations.list("FE_")` spells them.
+     * @returns True when the request went out; false for a player with no body yet. Throws for an argument it cannot use.
+     */
+    setFacialExpression(fragment: string, options?: { tags?: string }): boolean;
+
+    /**
+     * Moves this player's mouth as if they were talking, on their own screen and on everybody else's, until told to stop -- for text chat, voice chat or a scene. It is a looping talk animation, not lip-sync: it follows no words.
+     * 
+     * The game's own lip-sync wins while it plays a voice line on the same body, and the loop comes back after it.
+     * @param talking Whether the mouth moves.
+     * @param style How: `neutral` (the default), `happy`, `drunk` or `chew`.
+     * @returns True when the request went out; false for a player with no body yet. Throws for a style it does not know.
+     */
+    setTalking(talking: boolean, style?: 'neutral' | 'happy' | 'drunk' | 'chew'): boolean;
 
     /**
      * Asks this player's own client to wear a different body -- face, hair, beard and skin. The owning client is authoritative for its body, so this is a request that lands on their next frame rather than a write; read `player.appearance` back to see what they actually put on.
@@ -824,25 +1343,34 @@ declare global {
     setMovementMode(mode: Partial<MovementMode>): boolean;
 
     /**
-     * Grants items into this player's inventory on their own client. The server holds no inventory of its own, so this is an instruction rather than a transfer.
+     * Grants items into this player's inventory, which the server holds; their game shows them on the next tick. `Inventory.add` does the same and can also set the items' properties.
      * @param item Item class GUID, or the exact name the game's own item tables use.
      * @param amount How many to grant; defaults to 1, and at most 10000.
-     * @returns True when the grant went out; false for an unknown item or an amount the wire refuses.
+     * @returns True when the items were added; false for an unknown item, an amount outside 1..10000, or a player with no inventory.
      */
     giveItem(item: string, amount?: number): boolean;
 
     /**
-     * Takes items back out of this player's inventory, on their own client -- the mirror of `giveItem`, and what makes a trade or a theft able to move in both directions.
-     * 
-     * It is a promise rather than a boolean because a grant always lands and a take may not. The server holds no inventory of its own, so it cannot know what the player is carrying: it asks their client, and the answer is a round trip away. Await it, and read `ok` before crediting the other side of a trade -- a player who has only one of the three you asked for gives back `removed: 1, ok: false`, and their client is already one short.
-     * 
-     * Across stacks of the same class, oldest first, and an item counts even while it is in the player's hand. Nothing else of theirs is touched.
+     * Takes items of a class out of this player's inventory, across its rows, all of them or none. The server holds the inventory, so the promise is already settled when it is returned; it stays a promise so existing scripts keep working. To move items between players use `Inventory.transfer`, which cannot lose them half way.
      * @param item Item class GUID, or the exact name the game's own item tables use. The same spelling `giveItem` takes.
      * @param amount How many units to take; defaults to 1, and at most 10000. Zero is refused rather than read as "all of them".
-     * @returns An object carrying `removed` (units that actually went), `requested` (what was asked for), `ok` (true only when the client answered and removed every unit), and `reason` (empty when it answered, otherwise what went wrong).
+     * @returns An object carrying `removed` (the amount when it happened, otherwise 0), `requested`, `ok`, and `reason` (empty on success, otherwise the inventory code, such as `insufficientItems`).
      */
     takeItem(item: string, amount?: number): Promise<{ removed: number; requested: number; ok: boolean; reason: string }>;
 
+    /**
+     * Moves this player's items into a container spawned at their body, as a death drop: `playerInventoryChanged` (reason `drop`) and `stashInventoryChanged` follow, then the container is anyone's to open. At most 128 rows go. What happens to it next -- who may loot it, when it goes -- is the script's.
+     * @param options `keepEquipped` keeps the units their body wears or holds.
+     * @returns The container, or null when there was nothing to drop or the player has no inventory.
+     */
+    dropInventory(options?: { keepEquipped?: boolean }): Stash | null;
+
+    /**
+     * Reads this player's inventory; the same as `Inventory.get(player)`.
+     * @returns A copy of it, or null for a player who is not connected.
+     */
+    getInventory(): InventoryState | null;
+
     /**
      * Puts a status effect on this player's body. The server runs no effects of its own, so this asks their client rather than writing anything, and it lands a moment later -- `hasBuff` right after this call still says false. Watch `playerBuffAdded` for the moment it is really on.
      * 
@@ -888,6 +1416,12 @@ declare global {
      */
     dismount(): Horse | null;
 
+    /**
+     * Has this player put down the body on their shoulder, with the game's own put-down. It is an instruction to their client, so the carry ends when that put-down lands: `playerPutDown` follows then, and `carrying` reads null from that moment.
+     * @returns True when the order went out; false when they carry nobody or have no connection.
+     */
+    putDown(): boolean;
+
     /**
      * Puts this player in a horse's saddle, the way the game's own forced mount does -- their client plays the climb. It is an instruction to their client, so the seat is reported back like any other mount: `horseMounting` can still refuse it, and `horseMount` and `player.horse` follow once it lands. The player has to be standing near the horse; teleport them beside it first.
      * @param horse The horse to climb onto.
@@ -911,6 +1445,172 @@ declare global {
 
   interface Player extends BasePlayer {}
 
+  /**
+   * A count of units from one row.
+   */
+  interface InventoryUnit {
+    /**
+     * The row.
+     */
+    id: string;
+
+    /**
+     * How many of its units.
+     */
+    amount: number;
+  }
+
+  /**
+   * A stack of one item class with one set of properties. Two rows never hold the same class with equal properties unless a restore put them there.
+   */
+  interface InventoryRow {
+    /**
+     * The row's identity within this player's inventory. Stable while the row exists; save it with the row and pass it back to `Inventory.set`.
+     */
+    id: string;
+
+    /**
+     * Item class GUID.
+     */
+    item: string;
+
+    /**
+     * The item's name in the game's own tables; not localized text.
+     */
+    name: string;
+
+    /**
+     * Units in the row.
+     */
+    amount: number;
+
+    /**
+     * Quality, from 1 up to the class's maximum. Same as `metadata.quality`.
+     */
+    quality: number;
+
+    /**
+     * Absolute item health. Same as `metadata.health`.
+     */
+    health: number;
+
+    /**
+     * Health as a fraction of what this quality allows, 0 to 1. Same as `metadata.condition`.
+     */
+    condition: number;
+
+    /**
+     * Units of the row the player's body wears or holds, as their game last reported it. Only in `Inventory.get` and `player.getInventory()`; give it back to `Inventory.set` to dress a restored body.
+     */
+    equipped: number;
+
+    /**
+     * Every property the server keeps: `quality`, `health`, `condition`, and on missiles `poison` (a buff GUID) and `poisonCharges`, and `onEquipBuffs` (buff GUIDs). A default is left out. Pass it back as it is to keep an item exactly.
+     */
+    metadata: Record<string, unknown>;
+  }
+
+  /**
+   * One player's inventory as the server holds it.
+   */
+  interface InventoryState {
+    /**
+     * The player's game shows this revision. False for a moment after every change, and until `playerInventoryReady`.
+     */
+    ready: boolean;
+
+    /**
+     * Advances by one with every change. Pass it as a request's `revision` to refuse the request if anything changed in between.
+     */
+    revision: number;
+
+    /**
+     * Every row.
+     */
+    items: InventoryRow[];
+  }
+
+  /**
+   * What one operation did to one player's inventory.
+   */
+  interface InventoryChange {
+    /**
+     * The revision the operation produced.
+     */
+    revision: number;
+
+    /**
+     * `add`, `remove`, `properties`, `set`, `transfer`, `wear` when the player's game wore an item down in use, `use` for food, potions and ointments, `shot` for a fired round, `pickpocket`, `drop` for `player.dropInventory`, or the ground, stash and gathering reasons.
+     */
+    reason: string;
+
+    /**
+     * Only the rows that changed. `before: null` is a new row and `after: null` an emptied one.
+     */
+    items: { id: string; before: InventoryRow | null; after: InventoryRow | null }[];
+  }
+
+  /**
+   * What an inventory operation did.
+   */
+  interface InventoryResult {
+    /**
+     * It happened. Nothing changes when it did not.
+     */
+    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`).
+     */
+    code: string;
+
+    /**
+     * The revision after the operation; for a transfer, the source's. 0 when refused.
+     */
+    revision: number;
+
+    /**
+     * The rows that received units: the row an `add` merged into or created, a transfer's rows in the target, every row a `set` wrote. Empty for `remove`.
+     */
+    items: InventoryUnit[];
+  }
+
+  /**
+   * Player inventories. The server holds each connected player's items and their game shows them; nothing a player's game does adds an item. Every operation happens at once and in full, or not at all. `revision` is optional everywhere: give the one you read to refuse the operation when the inventory changed since.
+   */
+  const Inventory: {
+    /**
+     * Reads a player's inventory.
+     * @returns A copy of it, or null for a player who is not connected.
+     */
+    get(player: Player): InventoryState | null;
+
+    /**
+     * Gives a player items of a class, 1 to 10000 at a time. Left-out properties mean quality 1 at full condition. The units join the row that already holds this class with these properties, if there is one.
+     */
+    add(player: Player, request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+
+    /**
+     * Takes exact units from named rows, every one of them or none.
+     */
+    remove(player: Player, request: { units: InventoryUnit[]; revision?: number }): InventoryResult;
+
+    /**
+     * Replaces a row's properties. The row keeps its identity and amount. It replaces rather than merges: carry over anything you want to keep, and give `health` or `condition`, not two that disagree.
+     */
+    setProperties(player: Player, request: { id: string; metadata: Record<string, unknown>; revision?: number }): InventoryResult;
+
+    /**
+     * Replaces a player's whole inventory, which is how a saved one comes back. Rows keep the ids they are given (letters, digits and `-_:.`, up to 64) and get new ones when they have none. `equipped` is how many units of a gear row the body wears, up to 48 in all; their game dresses in them. An empty list clears the inventory.
+     */
+    set(player: Player, request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown>; equipped?: number }[]; revision?: number }): InventoryResult;
+
+    /**
+     * 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;
+  };
+
   /**
    * Replicated KCD2 horse handle.
    */
@@ -961,6 +1661,21 @@ declare global {
      */
     readonly mounted: boolean;
 
+    /**
+     * Network ID of the player this horse belongs to, or 0 when it is nobody's. Not necessarily its rider.
+     */
+    readonly ownerId: number;
+
+    /**
+     * The player this horse belongs to, or null when it is nobody's. Set with `giveTo`.
+     */
+    readonly owner: Player | null;
+
+    /**
+     * Whether this horse is despawned when its owner disconnects. True by default. Set it to false to keep the horse in the world: it is left ownerless instead (`horseOwnerChanged` with a null player) until `giveTo` hands it to someone. Saving it across server restarts is the script's own business.
+     */
+    destroyWithOwner: boolean;
+
     /**
      * Health, as the client running this horse last reported it off the animal's own soul -- 0 before any client has. Assigning sets it on that client, clamped to `maxHealth`; 0 kills. A dead horse ignores the write: `revive` is what brings one back.
      */
@@ -997,6 +1712,12 @@ declare global {
      */
     destroy(): void;
 
+    /**
+     * Makes this horse another player's. Every client makes it that player's horse in the game's own terms -- theirs is never a stolen horse -- and `horseOwnerChanged` follows. Ownership decides nothing about who may ride it: that is `horseMounting`'s to refuse. Throws when `player` is not a connected player.
+     * @param player The horse's new owner, or null to leave it ownerless.
+     */
+    giveTo(player: Player | null): void;
+
     /**
      * Rears the horse on every client so it throws its rider off. The game's own animation, not a pose.
      * @returns True when the request went out; false when nobody is riding it.
@@ -1288,73 +2009,518 @@ declare global {
      * @param rows Everything it buys, at most 128 rows and each item class once. Replaces the old list.
      * @returns False when there is no such vendor.
      */
-    setBuyPrices(vendor: number, rows: VendorBuyRow[]): boolean;
+    setBuyPrices(vendor: number, rows: VendorBuyRow[]): boolean;
+
+    /**
+     * Sets what a vendor can pay out. Deals keep it current: what players pay goes in, what they are paid comes out.
+     * @param vendor The vendor to change.
+     * @param purse Money units it holds, or null for a purse that never runs out.
+     * @returns False when there is no such vendor.
+     */
+    setPurse(vendor: number, purse: number | null): boolean;
+
+    /**
+     * What a vendor holds.
+     * @param vendor The vendor to ask about.
+     * @returns Money units, or null for a purse that never runs out or a vendor that does not exist.
+     */
+    getPurse(vendor: number): number | null;
+
+    /**
+     * Opens the game's own trade screen on a player. A player already trading has that session closed with reason 2 first, because the game has one trade screen.
+     * @param vendor The vendor to trade with.
+     * @param player NetworkID of the player to show it to.
+     * @param npc NetworkID of the NPC who keeps the shop. The screen shows that NPC as the trader; omit it to trade with nobody in particular.
+     * @returns The session id, or 0 when the vendor or the player is gone.
+     */
+    open(vendor: number, player: number, npc?: number): number;
+
+    /**
+     * Takes the trade screen off that player.
+     * @param session The session to end.
+     * @returns False when the session had already ended.
+     */
+    close(session: number): boolean;
+
+    /**
+     * The trading session a player is in.
+     * @param player NetworkID of the player to ask about.
+     * @returns The session id, or 0 when they are not trading.
+     */
+    sessionOf(player: number): number;
+
+    /**
+     * The vendor a session trades with.
+     * @param session The session to ask about.
+     * @returns The vendor id, or 0 when the session has ended.
+     */
+    vendorOf(session: number): number;
+  };
+
+  /**
+   * One item class that left a victim's pockets for a thief's.
+   */
+  interface PickpocketLine {
+    /**
+     * The item class GUID.
+     */
+    item: string;
+
+    /**
+     * The game's own name for the item class.
+     */
+    name: string;
+
+    /**
+     * How many moved.
+     */
+    amount: number;
+  }
+
+  /**
+   * A table a player is about to open. Frozen: a handler can refuse it, not change it.
+   */
+  interface CraftStartProposal {
+    /**
+     * Station id, as `Crafting.stations` names it.
+     */
+    station: string;
+
+    /**
+     * The player's virtual world; each world has its own tables.
+     */
+    virtualWorld: number;
+
+    /**
+     * The batch this one follows at a table the player kept, or empty for a fresh entry.
+     */
+    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.
+   */
+  interface CraftStartedEvent {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * The previous batch at this table, or empty for the first.
+     */
+    continuationOf: string;
+  }
+
+  /**
+   * What a finished batch is about to grant, computed by the server. Frozen: a handler can refuse it, not change it.
+   */
+  interface CraftCompletionProposal {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * `failed` brews the game's failed potion.
+     */
+    outcome: 'success' | 'failed';
+
+    /**
+     * The recipe the brew matched, or empty when it matched none.
+     */
+    recipe: string;
+
+    /**
+     * The product's native rank.
+     */
+    grade: number;
+
+    /**
+     * Item class GUID of what would be granted, or empty when the yield came out at zero.
+     */
+    product: string;
+
+    /**
+     * How many.
+     */
+    amount: number;
+
+    /**
+     * Brewing quality, 0 to 1, after perks and the table-entry bonus.
+     */
+    quality: number;
+
+    /**
+     * Base alchemy XP; the player's own multipliers apply on top.
+     */
+    xp: number;
+  }
+
+  /**
+   * A batch whose result was granted: the output is in the inventory and the XP was ordered.
+   */
+  interface CraftCompletedEvent {
+    /**
+     * The batch's session id.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * `failed` granted the game's failed potion.
+     */
+    outcome: 'success' | 'failed';
+
+    /**
+     * The recipe matched, or empty.
+     */
+    recipe: string;
+
+    /**
+     * The product's native rank.
+     */
+    grade: number;
+
+    /**
+     * Brewing quality, 0 to 1.
+     */
+    quality: number;
+
+    /**
+     * Base alchemy XP ordered.
+     */
+    xp: number;
+
+    /**
+     * The inventory rows that received the output. Do not grant it again.
+     */
+    outputs: InventoryUnit[];
+
+    /**
+     * The player's recipe knowledge after this batch, as `Crafting.knowledge` returns it.
+     */
+    knowledge: Record<string, number>;
+  }
+
+  /**
+   * A batch 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.
+     */
+    session: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * How it ended.
+     */
+    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.
+     */
+    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.
+     */
+    refunded: InventoryUnit[];
+  }
+
+  /**
+   * Units required by a shipped recipe.
+   */
+  interface CraftMaterialRequirement {
+    /**
+     * Item class GUID.
+     */
+    item: string;
+
+    /**
+     * Native item name, useful with Player.giveItem.
+     */
+    name: string;
+
+    /**
+     * Units required for one attempt.
+     */
+    amount: number;
+  }
+
+  /**
+   * One possible product row. These are alternatives, not a reward list.
+   */
+  interface CraftProductInfo {
+    /**
+     * Product class GUID.
+     */
+    item: string;
+
+    /**
+     * Alchemy product rank or smithing minimum quality percent.
+     */
+    threshold: number;
+
+    /**
+     * Alchemy base maximum yield before modifiers; one for smithing.
+     */
+    maxYield: number;
+  }
+
+  /**
+   * Shipped recipe data allowed by server DLC policy. Presence is not proof of player knowledge, skill, quest eligibility or materials.
+   */
+  interface CraftRecipeInfo {
+    /**
+     * Tagged native recipe identity.
+     */
+    key: { kind: 'alchemy'; id: number } | { kind: 'smithing'; id: string };
+
+    /**
+     * Localization key from the native table.
+     */
+    name: string;
+
+    /**
+     * Native DLC id; zero for untagged content.
+     */
+    dlcId: number;
+
+    /**
+     * Minimum craftsmanship skill, or zero for alchemy.
+     */
+    minSkill: number;
+
+    /**
+     * Smithing recipe unlock perk GUID, empty for alchemy.
+     */
+    perk: string;
+
+    /**
+     * Alchemy base liquid, empty for smithing. Supplied by the station.
+     */
+    base: string;
+
+    /**
+     * Required ingredient quantities.
+     */
+    ingredients: CraftMaterialRequirement[];
+
+    /**
+     * Possible products by native rank or threshold.
+     */
+    products: CraftProductInfo[];
+  }
+
+  /**
+   * An authored station in the configured level. The catalog does not guarantee that its quest layer is loaded or that native use is currently permitted.
+   */
+  interface CraftStationInfo {
+    /**
+     * Level and stable placement GUID.
+     */
+    id: string;
+
+    /**
+     * The station's recipe family.
+     */
+    kind: 'alchemy' | 'smithing';
+
+    /**
+     * Level directory name.
+     */
+    level: string;
+
+    /**
+     * Authored editor layer, for identifying the location.
+     */
+    layer: string;
+
+    /**
+     * World position of the station.
+     */
+    position: { x: number; y: number; z: number };
+
+    /**
+     * Horizontal facing direction.
+     */
+    forward: { x: number; y: number };
+  }
+
+  /**
+   * Who holds an alchemy table. A player keeps it between batches until they leave it.
+   */
+  interface CraftStationOccupant {
+    /**
+     * The player's id.
+     */
+    playerId: number;
+
+    /**
+     * The first batch of this visit; the same across every batch of it.
+     */
+    entryId: string;
+
+    /**
+     * The batch now running, or the last one to finish.
+     */
+    sessionId: string;
+
+    /**
+     * `entering` until the opening animation finishes; `finishing` while a finished batch waits to settle.
+     */
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
+
+    /**
+     * Milliseconds until the table is taken back. Each batch has 30 minutes.
+     */
+    expiresInMs: number;
+  }
+
+  /**
+   * One table in one virtual world. A free table may still be unusable in the game, for instance behind a quest layer.
+   */
+  interface CraftStationOccupancy {
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The virtual world asked about.
+     */
+    virtualWorld: number;
+
+    /**
+     * Someone holds it, brewing or between batches.
+     */
+    occupied: boolean;
+
+    /**
+     * Who, or null when free.
+     */
+    occupant: CraftStationOccupant | null;
+  }
+
+  /**
+   * A player's alchemy session, or the table they kept between batches. A copy: changing it changes nothing.
+   */
+  interface CraftSessionInfo {
+    /**
+     * The batch's session id.
+     */
+    id: string;
+
+    /**
+     * Station id.
+     */
+    station: string;
+
+    /**
+     * The table's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * Where the batch is.
+     */
+    phase: 'entering' | 'brewing' | 'finishing' | 'betweenBatches';
+
+    /**
+     * Native actions accepted so far.
+     */
+    sequence: number;
+
+    /**
+     * What is on the table: item class, the inventory row it came from (empty for a base liquid), and the native table position.
+     */
+    resources: { id: number; item: string; itemId: string; position: number; base: boolean; milled: boolean; distilled: boolean }[];
 
     /**
-     * Sets what a vendor can pay out. Deals keep it current: what players pay goes in, what they are paid comes out.
-     * @param vendor The vendor to change.
-     * @param purse Money units it holds, or null for a purse that never runs out.
-     * @returns False when there is no such vendor.
+     * Milliseconds until the session times out.
      */
-    setPurse(vendor: number, purse: number | null): boolean;
+    expiresInMs: number;
+  }
 
+  /**
+   * Crafting catalogs, alchemy table occupancy, sessions and recipe knowledge. Held in memory for each connection; nothing is saved.
+   */
+  const Crafting: {
     /**
-     * What a vendor holds.
-     * @param vendor The vendor to ask about.
-     * @returns Money units, or null for a purse that never runs out or a vendor that does not exist.
+     * True for alchemy, false for smithing, which is not synchronized yet. Omitted kind checks alchemy.
      */
-    getPurse(vendor: number): number | null;
+    isAvailable(kind?: 'alchemy' | 'smithing'): boolean;
 
     /**
-     * Opens the game's own trade screen on a player. A player already trading has that session closed with reason 2 first, because the game has one trade screen.
-     * @param vendor The vendor to trade with.
-     * @param player NetworkID of the player to show it to.
-     * @param npc NetworkID of the NPC who keeps the shop. The screen shows that NPC as the trader; omit it to trade with nobody in particular.
-     * @returns The session id, or 0 when the vendor or the player is gone.
+     * Placed stations in this server's level. Does not load deferred layers or bypass quests.
      */
-    open(vendor: number, player: number, npc?: number): number;
+    stations(kind?: 'alchemy' | 'smithing'): readonly CraftStationInfo[];
 
     /**
-     * Takes the trade screen off that player.
-     * @param session The session to end.
-     * @returns False when the session had already ended.
+     * Production recipes enabled by server DLC policy. The player must be connected but does not change the list. Catalog presence does not establish knowledge or skill.
      */
-    close(session: number): boolean;
+    recipes(player: Player, kind?: 'alchemy' | 'smithing'): readonly CraftRecipeInfo[];
 
     /**
-     * The trading session a player is in.
-     * @param player NetworkID of the player to ask about.
-     * @returns The session id, or 0 when they are not trading.
+     * The player's alchemy session or the table they kept between batches, or null.
      */
-    sessionOf(player: number): number;
+    session(player: Player): CraftSessionInfo | null;
 
     /**
-     * The vendor a session trades with.
-     * @param session The session to ask about.
-     * @returns The vendor id, or 0 when the session has ended.
+     * Who holds a table. World defaults to 0. Null for an unknown or non-alchemy station.
      */
-    vendorOf(session: number): number;
-  };
+    occupancy(stationId: string, virtualWorld?: number): CraftStationOccupancy | null;
 
-  /**
-   * One item class that left a victim's pockets for a thief's.
-   */
-  interface PickpocketLine {
     /**
-     * The item class GUID.
+     * 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.
      */
-    item: string;
+    cancel(player: Player): boolean;
 
     /**
-     * The game's own name for the item class.
+     * The player's recipe knowledge: recipe id to a mask of its 29 authored steps, 536870911 when the whole recipe is known. A recipe not listed is unknown. Starts empty every session; save it from `craftingCompleted` or here and restore it with `setKnowledge`.
      */
-    name: string;
+    knowledge(player: Player): Record<string, number>;
 
     /**
-     * How many moved.
+     * Sets which steps of one recipe the player knows, and sends it to their game's recipe book. 0 forgets the recipe. False for an unknown recipe, a mask above 536870911, or a player who is not connected.
      */
-    amount: number;
-  }
+    setKnowledge(player: Player, recipeId: string | number, mask: number): boolean;
+  };
 
   /**
    * Replicated KCD2 dog companion handle.
@@ -1386,6 +2552,11 @@ declare global {
      */
     readonly owner: Player | null;
 
+    /**
+     * Whether this dog is despawned when its owner disconnects. True by default. Set it to false to keep the dog in the world: it is left masterless instead (`dogOwnerChanged` with a null player), and with nobody's game running its brain it stands where it was until `giveTo` hands it to someone. Saving it across server restarts is the script's own business.
+     */
+    destroyWithOwner: boolean;
+
     /**
      * The dog's companion mode: 0 Wait, 1 Follow, 2 Free, 3 Aggressive, 4 Search, 5 Hunt, 6 Guard, 7 Ambush. Assignment applies it on every client.
      */
@@ -1413,7 +2584,7 @@ declare global {
     destroy(): void;
 
     /**
-     * Hands this dog to another player. Every client re-possesses the body onto the new master's soul, and authority over its pose moves with it.
+     * Hands this dog to another player. Every client re-possesses the body onto the new master's soul, and authority over its pose moves with it. Throws when `player` is not a connected player.
      * @param player The dog's new master, or null to leave it masterless.
      */
     giveTo(player: Player | null): void;
@@ -2013,9 +3184,11 @@ declare global {
     teleport(position: Vector3 | Partial<Vector3>, rotation?: Quaternion | Vector3 | Partial<Vector3>): boolean;
 
     /**
-     * Makes the NPC play one of the game's animations -- chopping wood with an axe in hand, drawing water, sitting, drinking -- on every client, the one simulating it included. It is state rather than a one-off: a client that streams the NPC in, and the next one to simulate it, play it too, until `stopAnimation` or the next `playAnimation`.
+     * Makes the NPC play one of the game's animations -- chopping wood with an axe in hand, drawing water, sitting, drinking -- on every client, the one simulating it included. It is state rather than a one-off: a client that streams the NPC in, and the next one to simulate it, play it too, until `stopAnimation` or the next `playAnimation`, which both cut it at once.
+     * 
+     * Give it something to do that keeps it in place, `hold` or `lookAt`: an order to walk makes the legs fight a full-body animation. A hit or a fall can cut the animation short; `loop` starts it again, and keeps a one-shot going pass after pass with no gap.
      * 
-     * Give it something to do that keeps it in place, `hold` or `lookAt`: an order to walk makes the legs fight a full-body animation. A hit or a fall can cut the animation short; `loop` starts it again.
+     * `npcAnimationEnd` fires once when the animation this request started is over, and says how.
      * @param fragment A Mannequin fragment, as `Animations.list` names it -- or, as before, a row of the shipped emote catalog, which plays that gesture once and is not remembered.
      * @param options `tags` pick the variant, `loop` repeats it until stopped, `props` puts up to two models in its hands. `lockMovement` does nothing here: an NPC standing still is its intent's business.
      * @returns True when the request went out; false for a dead NPC. Throws for a prop or option it cannot use.
@@ -2023,10 +3196,29 @@ declare global {
     playAnimation(fragment: string | number, options?: { tags?: string; loop?: boolean; lockMovement?: boolean; props?: { item?: string; model?: string; hand?: 'right' | 'left'; joint?: string; position?: Vector3 | Partial<Vector3>; rotation?: Quaternion | Vector3 | Partial<Vector3> } | { item?: string; model?: string; hand?: 'right' | 'left'; joint?: string; position?: Vector3 | Partial<Vector3>; rotation?: Quaternion | Vector3 | Partial<Vector3> }[] }): boolean;
 
     /**
-     * Ends what `playAnimation` started, takes its props away and hands the body back to its intent.
+     * Ends what `playAnimation` started at once, takes its props away and hands the body back to its intent. The stand-up `standUp` asks for is an animation of its own and raises its own `npcAnimationEnd`.
+     * @param options `standUp` plays the game's own way back to standing when the animation held the body in a sitting or lying stance tag: `StandUp` or `GetUp`, in the variant that fits. Without it the body goes straight back to standing.
      * @returns True when the request went out.
      */
-    stopAnimation(): boolean;
+    stopAnimation(options?: { standUp?: boolean }): boolean;
+
+    /**
+     * Sets the NPC's facial expression on every client, alongside whatever its body plays. It is state: a client that streams the NPC in, and the next one to simulate it, show it too, until the next call.
+     * 
+     * The expression is the eyes, brows and mood; it never moves the mouth, which is `setTalking`. A mood tag is one of the body's own tags, so it can change the mood of its idle too.
+     * @param fragment A fragment on the face's own scope: `FE_Default`, `FE_DialogueIdle` or `FE_DialogueSpeaking` for a held mood, or an `ADLG_FA_*` gesture (`ADLG_FA_Smile`, `ADLG_FA_Wink`, `ADLG_FA_Laugh`, `ADLG_FA_Surprise`...) that plays once. `""` hands the face back to the game.
+     * @param options `tags` pick the variant: for the `FE_*` fragments the mood, `happy`, `angry`, `sad`, `nervous`, `pensive`, `arogant` or `drunk`, as `Animations.list("FE_")` spells them.
+     * @returns True when the request went out; false for a dead NPC. Throws for an argument it cannot use.
+     */
+    setFacialExpression(fragment: string, options?: { tags?: string }): boolean;
+
+    /**
+     * Moves the NPC's mouth as if it were talking, on every client, until told to stop. Pair it with `say` for a line of text. It is a looping talk animation, not lip-sync: it follows no words, and the game's own lip-sync wins while the NPC speaks a voice line of its own.
+     * @param talking Whether the mouth moves.
+     * @param style How: `neutral` (the default), `happy`, `drunk` or `chew`.
+     * @returns True when the request went out; false for a dead NPC. Throws for a style it does not know.
+     */
+    setTalking(talking: boolean, style?: 'neutral' | 'happy' | 'drunk' | 'chew'): boolean;
 
     /**
      * Puts a line of speech over the body on every client that can see it.
@@ -2290,7 +3482,7 @@ declare global {
     readonly condition: number;
 
     /**
-     * Whether the stack has settled where it will stay. A stack a script spawned is resting from the start; one a player threw down is false until that player's own physics stops it and publishes the final pose, and its position moves until then.
+     * Whether the stack has settled where it will stay. A stack a script spawned is resting from the start; one a player dropped is false while the nearest client simulates its fall, and its position moves until then. A resting stack's pose is the server's and does not move again.
      */
     readonly resting: boolean;
 
@@ -2350,6 +3542,71 @@ declare global {
 
   interface GroundItem extends Entity {}
 
+  /**
+   * A plant a player picked and what it is about to give them.
+   */
+  interface GatheringProposal {
+    /**
+     * Item class GUID of the herb.
+     */
+    item: string;
+
+    /**
+     * How many, as the game computes it from the player's survival level and the plants harvested together.
+     */
+    amount: number;
+
+    /**
+     * The game's pickable area id for the plant.
+     */
+    kind: number;
+
+    /**
+     * Where the plant grows, as the player's game reported it.
+     */
+    position: number[];
+
+    /**
+     * The player's virtual world.
+     */
+    virtualWorld: number;
+  }
+
+  /**
+   * A plant a player picked, and what they were given.
+   */
+  interface GatheringHarvestedEvent {
+    /**
+     * Item class GUID of the herb.
+     */
+    item: string;
+
+    /**
+     * How many.
+     */
+    amount: number;
+
+    /**
+     * The game's pickable area id for the plant.
+     */
+    kind: number;
+
+    /**
+     * Where the plant grows.
+     */
+    position: number[];
+
+    /**
+     * The player's virtual world.
+     */
+    virtualWorld: number;
+
+    /**
+     * The inventory rows that received the herb.
+     */
+    items: InventoryUnit[];
+  }
+
   /** */
   interface NearestDoor {
     /**
@@ -2615,43 +3872,114 @@ declare global {
   interface Gate extends Entity {}
 
   /**
-   * Replicated container handle.
+   * Replicated container handle: one a script spawned, or one the level places.
    */
   class Stash {
     /**
-     * Creates a script wrapper for an existing container with this ID; use Stash.spawn() to spawn one.
+     * Creates a script wrapper for an existing container with this ID; use Stash.spawn() to spawn one, or Stash.find() for one the level places.
      * @param id Network entity identifier.
      */
     constructor(id: number);
 
     /**
-     * The identity every client turns into the same native container. Minted by the server from 1, and not `id`, which is the replication entity's.
+     * The identity every client turns into the same native container, for one a script spawned. Minted by the server from 1, and not `id`, which is the replication entity's. 0 for a container the level places.
      */
     readonly stashId: number;
 
     /**
-     * How many stacks the server is holding. Contents are not replicated -- they are pulled when a player opens the container and pushed back when they close it -- so this is the only view of what is in one.
+     * The EntityGuid every client finds this container under, as sixteen lowercase hex digits: the level's own for a container the level places, the one minted when a script spawned it otherwise. Every container has one, and `Stash.find` takes it back.
+     */
+    readonly guid: string;
+
+    /**
+     * The level's own EntityGuid for a container the level places, as sixteen lowercase hex digits; empty for one a script spawned. The same on every machine, so it is the identity to store a container under; `Stash.find` takes it back.
+     */
+    readonly levelGuid: string;
+
+    /**
+     * The entity name the level gives the container, or `spawned_stash_<stashId>` for one a script spawned.
+     */
+    readonly name: string;
+
+    /**
+     * How many rows the server is holding. A container linked to another in the level opens that one's contents, and reads them here too.
      */
     readonly itemCount: number;
 
     /**
-     * The network ID of the player who has it open, or 0. While it is held, the game's own lock keeps every other client out.
+     * Whether a player has it open. Every client animates the lid by it.
+     */
+    readonly isOpen: boolean;
+
+    /**
+     * The network ID of the player who has its contents open, or 0. While it is held, every other player's open is refused before their transfer screen appears.
      */
     readonly holderId: number;
 
+    /**
+     * Whether the container is locked. Assignment reaches every client that has it streamed in. A locked container offers only its key and its lockpick; a script locking one marks it `lockedByServer`, which the generated home or shop key does not open. Unlocking it by any route the server accepted clears both.
+     */
+    locked: boolean;
+
+    /**
+     * Whether the lock was set by a script rather than by the level. The generated home or shop key does not open a container locked from here.
+     */
+    readonly lockedByServer: boolean;
+
+    /**
+     * Whether the container offers the lockpick while locked. Starts as the level authored it; assignment reaches every client, and a pick on one that cannot be is refused.
+     */
+    lockpickable: boolean;
+
+    /**
+     * The item class GUID of the key that unlocks the container, as `player.giveItem` takes it. Reads the level's own key until a script assigns one; empty when it has none. Assigning a class makes every client ask for that class instead, so a player holding it is offered "unlock and open"; assigning an empty string restores the level's. An unknown class is refused and logged. The server does not see inventories: which key a player holds is their client's to say, and `stashInteract` is where a script checks its own record.
+     */
+    keyItem: string;
+
+    /**
+     * The horizontal unit direction a player has to face the container along to be offered it: the game's own use check only offers a chest to a body standing behind this axis and looking along it. Stand at `position - useDirection * distance` to face it.
+     */
+    readonly useDirection: Vector3;
+
+    /**
+     * Whether the level builds this container locked, which is the state it has at boot. False for one a script spawned.
+     */
+    readonly startsLocked: boolean;
+
     /**
      * Formats this container handle for logging and debugging.
-     * @returns The stash ID, its shared identity, how much is in it and who has it open.
+     * @returns The stash ID, its level GUID, how much is in it, who has it open and whether it is locked.
      */
     toString(): string;
 
     /**
-     * Despawns this container on every client and forgets what was in it. Anything inside goes with it.
+     * Despawns this container on every client and forgets what was in it. Anything inside goes with it. Does nothing to a container the level places.
      */
     destroy(): void;
 
     /**
-     * Spawns and replicates an empty container. Empty by design: an item class is a 16-byte engine GUID only the game's own parser turns from text, and the server has no game to ask. Fill one by having a player put things in it.
+     * Reads what the container holds. A linked child reads its master's.
+     * @returns A copy of its rows, or null once the container is gone.
+     */
+    getInventory(): { revision: number; items: InventoryRow[] } | null;
+
+    /**
+     * Puts items in the container, as `Inventory.add` gives them to a player.
+     */
+    addItem(request: { item: string; amount: number; metadata?: Record<string, unknown>; revision?: number }): InventoryResult;
+
+    /**
+     * Takes exact units out of named rows, every one of them or none.
+     */
+    removeItem(request: { units: InventoryUnit[]; revision?: number }): InventoryResult;
+
+    /**
+     * Replaces everything in the container, which is how saved contents come back. At most 128 rows. An empty list empties it.
+     */
+    setInventory(request: { items: { id?: string; item: string; amount: number; metadata?: Record<string, unknown> }[]; revision?: number }): InventoryResult;
+
+    /**
+     * Spawns and replicates an empty container. Fill it with `addItem` or `setInventory`, or let players put things in it.
      * @param position Optional world-space spawn position; omitted components default to zero.
      * @param rotation Optional initial orientation: a Quaternion, or a Vector3 of Euler angles in degrees.
      * @param virtualWorld Optional virtual world the container belongs to; omitted puts it in the global one.
@@ -2660,7 +3988,7 @@ declare global {
     static spawn(position?: Vector3 | Partial<Vector3>, rotation?: Vector3 | Quaternion, virtualWorld?: number): Stash;
 
     /**
-     * Lists every container the server currently has.
+     * Lists every container the server currently has: every one the level places, which exist from boot in the global world, and every one a script spawned. In another virtual world a level container is built the first time anything there reaches it, so this lists only those.
      * @returns One handle per live container, in no particular order.
      */
     static all(): Stash[];
@@ -2673,7 +4001,24 @@ declare global {
     static getById(id: number): Stash | null;
 
     /**
-     * Despawns containers, and everything in them with them.
+     * Looks a container up by its EntityGuid: one the level places, by the level's own identity for it, which survives a restart and is the same on every machine, and is found in any virtual world; or one a script spawned, in the virtual world it was spawned in, for as long as it exists.
+     * @param guid The container's EntityGuid as hex, with or without an `0x` prefix, as `stash.guid` prints it.
+     * @param virtualWorld Optional virtual world to look in; omitted looks in the global one, where every body starts.
+     * @returns The container's handle, or null when no container has that GUID there.
+     */
+    static find(guid: string, virtualWorld?: number): Stash | null;
+
+    /**
+     * Finds the container nearest a point, level or spawned. The server knows where every container the level places stands, so this answers at once, without asking a client.
+     * @param position The point to measure from, usually a player's position.
+     * @param maxDistance How far to look, in metres; omitted looks 5 m, about the reach the game gives a chest.
+     * @param virtualWorld Optional virtual world to look in; omitted looks in the global one.
+     * @returns The nearest container's handle, or null when none is that close.
+     */
+    static nearest(position: Vector3 | Partial<Vector3>, maxDistance?: number, virtualWorld?: number): Stash | null;
+
+    /**
+     * Despawns containers a script spawned, and everything in them with them. The level's own stay.
      * @param virtualWorld Optional virtual world to clear; omitted clears every one of them.
      * @returns How many containers were removed.
      */
@@ -3077,6 +4422,94 @@ declare global {
     claim(classNames: string[]): string[];
   };
 
+  /**
+   * The game's skills, stats and perks, and the rules this server puts on how players move along them.
+   */
+  const Progression: {
+    /**
+     * Whether players' own games may earn XP. See `setNativeXp`.
+     */
+    readonly nativeXp: boolean;
+
+    /**
+     * The perks this server blocks.
+     */
+    readonly blockedPerks: string[];
+
+    /**
+     * Every skill and stat a player levels: the fifteen skills the character sheet shows, then strength, agility, vitality, speech and prestige.
+     * @returns The tracks, in that order.
+     */
+    tracks(): TrackInfo[];
+
+    /**
+     * Looks a perk up.
+     * @param query A perk's name, as the game's perk tables spell it, or its GUID.
+     * @returns What the tables say about it, or null for a name they do not carry.
+     */
+    findPerk(query: string): PerkInfo | null;
+
+    /**
+     * Lists the game's perks: 945 of them, most of them hidden system perks. `Progression.perks({ visibleOnly: true })` is the perk screen.
+     * @param filter `track` keeps the perks one tree pays for -- a track name, or `main`; `visibleOnly` keeps the perks the perk screen shows.
+     * @returns The perks, sorted by name.
+     */
+    perks(filter?: { track?: string; visibleOnly?: boolean }): PerkInfo[];
+
+    /**
+     * The total XP a track costs from level 0 to `level`, on the game's own curve: each level costs `base + diff * level`, with base and diff from the game's RPG tables.
+     * @param track A track name.
+     * @param level The level to reach.
+     * @returns The XP. Throws for a track name the tables do not carry.
+     */
+    xpForLevel(track: string, level: number): number;
+
+    /**
+     * Switches off XP from play. Every gain the game produces is dropped on the player's own client, and only `player.addXp` and `player.setLevel` move a track -- for servers where progression comes from jobs, trainers or quests a resource runs.
+     * @param enabled False to stop players' own games from earning XP at all.
+     * @returns Nothing.
+     */
+    setNativeXp(enabled: boolean): void;
+
+    /**
+     * Scales the XP players earn by playing. Applied before the player's own perk multipliers, which still work as they do in single player. `player.addXp` is not scaled.
+     * @param track A track name, or `*` for every track.
+     * @param rate What a gain is multiplied by before it is granted: 1 is the game's own pace, 0.5 half, 0 none at all.
+     * @returns Nothing.
+     */
+    setXpRate(track: string, rate: number): void;
+
+    /**
+     * Limits how fast a track can be ground. The budget holds a minute's worth and refills steadily, so a burst after a quiet spell goes through and a loop -- two players sparring for sword XP, a lock picked over and over -- runs dry. `player.addXp` is not limited.
+     * @param track A track name, or `*` for every track.
+     * @param xpPerMinute How much XP a player may earn on the track per minute, before multipliers. 0 is unlimited.
+     * @returns Nothing.
+     */
+    setXpBudget(track: string, xpPerMinute: number): void;
+
+    /**
+     * Stops a track at a level. Gains close to it are granted exactly what is left, so no multiplier carries the track past it. `player.setLevel` and `player.addXp` can still go beyond: the cap rules over what is earned.
+     * @param track A track name, or `*` for every track.
+     * @param level The highest level XP from play may reach, at most the game's own 30.
+     * @returns Nothing.
+     */
+    setLevelCap(track: string, level: number): void;
+
+    /**
+     * Makes perks unobtainable: the perk screen's learn is refused, the game's own grants are turned down on every client, and a report carrying one is rejected. `player.addPerk` still works.
+     * @param perks Perk names or GUIDs.
+     * @returns Nothing. Throws for an unknown perk.
+     */
+    blockPerks(perks: string[]): void;
+
+    /**
+     * Lifts `blockPerks`.
+     * @param perks Perk names or GUIDs.
+     * @returns Nothing. Throws for an unknown perk.
+     */
+    unblockPerks(perks: string[]): void;
+  };
+
   /**
    * The game's own character-component catalog: every face, hairstyle, beard and skin a player's body can be given.
    * 
@@ -3174,6 +4607,26 @@ declare global {
      * Whether the game has it for a woman's body.
      */
     female: boolean;
+
+    /**
+     * The in/loop/out sequence this fragment is a part of, shared by every fragment in it (`BakerMill` for `BakerMillIn`, `BakerMillLoop` and `BakerMillOut`), or empty when it is not part of one. The game does not record sequences; this is read from the fragment names, so treat it as a strong hint rather than a guarantee.
+     */
+    sequence: string;
+
+    /**
+     * Which part of its `sequence` this is: the way in, the middle part the body stays in, the way out, or a variation played in place of the middle. `loop` is the middle whether or not it ends by itself -- `oneShot` says that, and `playAnimation`'s `loop` repeats it. Empty when `sequence` is.
+     */
+    phase: "in" | "loop" | "out" | "variation" | "";
+
+    /**
+     * The fragment a second actor plays against this one, for the game's two-person animations (`TiedUpOut_Master` for `TiedUpOut_Slave`), or empty. Each actor plays its own fragment; read from the fragment names, like `sequence`.
+     */
+    partner: string;
+
+    /**
+     * Whether, with these tags, the fragment also animates a second character the game binds to the body -- a corpse carried, a horse groomed, a smith's workpiece. `playAnimation` binds none, so only this body moves.
+     */
+    slaveBody: boolean;
   }
 
   /**
@@ -4245,9 +5698,9 @@ declare global {
     getRange(): number;
 
     /**
-     * Overrides how far one player's voice carries, for whisper and shout modes.
+     * Overrides how far one player's voice carries, whichever voice tier they chose.
      * @param player Player whose voice carries the given distance.
-     * @param range Audibility radius in world units; values <= 0 return them to the server-wide range.
+     * @param range Audibility radius in world units; values <= 0 return them to the radius of their voice tier.
      */
     setPlayerRange(player: Entity, range: number): void;
 
@@ -4258,6 +5711,34 @@ declare global {
      */
     getPlayerRange(player: Entity): number;
 
+    /**
+     * Sets how far a voice tier carries. Players switch tier themselves; whisper starts at 8, shout at 60, and normal carries the server-wide range. Set a tier to 0 to make it carry the server-wide range, which takes it away. Connected clients are told.
+     * @param tier Voice tier: 0 whisper, 1 normal, 2 shout.
+     * @param range Audibility radius in world units; values <= 0 make the tier carry the server-wide range.
+     */
+    setTierRange(tier: number, range: number): void;
+
+    /**
+     * Reads how far a voice tier carries, with the server-wide range already resolved.
+     * @param tier Voice tier: 0 whisper, 1 normal, 2 shout.
+     * @returns Radius in world units.
+     */
+    getTierRange(tier: number): number;
+
+    /**
+     * Puts a player on a voice tier, as if they had switched to it. Their own indicator follows, and the playerVoiceTierChange event is not raised.
+     * @param player Player to move.
+     * @param tier Voice tier: 0 whisper, 1 normal, 2 shout.
+     */
+    setPlayerTier(player: Entity, tier: number): void;
+
+    /**
+     * Reads the voice tier a player is on. A player switching tier raises the playerVoiceTierChange event with the player and the new tier.
+     * @param player Player to query.
+     * @returns 0 whisper, 1 normal, 2 shout.
+     */
+    getPlayerTier(player: Entity): number;
+
     /**
      * Server-wide mute: a muted player's voice reaches nobody.
      * @param player Player to mute or unmute.
@@ -4317,6 +5798,59 @@ declare global {
     isPlayerTalking(player: Entity): boolean;
   };
 
+  /**
+   * A player asking to join, handed to `playerConnecting`. Every identifier is reported by the player's own client and is not verified by the server.
+   */
+  interface PendingConnection {
+    /**
+     * The name the player asked to join under.
+     */
+    readonly nickname: string;
+
+    /**
+     * Steam identifier the client reported, or an empty string when it had none.
+     */
+    readonly steamId: string;
+
+    /**
+     * Discord identifier the client reported, or an empty string when it had none.
+     */
+    readonly discordId: string;
+
+    /**
+     * Framework hardware identifier the client reported, or an empty string when it had none.
+     */
+    readonly hardwareId: string;
+
+    /**
+     * The string the client was launched with, as the `ticket` of its launch link, or an empty string. The framework passes it through untouched; checking it -- against a one-time join ticket your own launcher or website issued, typically -- is the script's job.
+     */
+    readonly ticket: string;
+
+    /**
+     * The remote address the connection comes from, without its port.
+     */
+    readonly ip: string;
+
+    /**
+     * Turns the player away before they receive anything. Takes effect on the next server tick, whatever other handlers are still doing. Does nothing once the connection is decided or the player has left.
+     * @param reason Shown to the player as written, up to 512 bytes. Omitted, they read that the server refused the connection.
+     */
+    reject(reason?: string): void;
+
+    /**
+     * Shows the waiting player a line of status and restarts the admission timeout, so a queue that keeps updating its players is never timed out. Does nothing once the connection is decided or the player has left.
+     * @param message One line for the player's connecting screen, up to 256 bytes: 'Checking the whitelist', 'You are 4th in the queue'.
+     */
+    update(message: string): void;
+
+    /**
+     * Checks whether this connection is still waiting on a decision.
+     * @returns False once it was let in or turned away, or the player gave up and left; a queue drops such entries.
+     */
+    isPending(): boolean;
+  }
+
   /**
    * Base handle for a live replicated network entity.
    */