@kingdomsconnected/types 1.5.0 → 1.5.1

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

@@ -5,6 +5,13 @@ declare global {
    * Native events dispatched through `Events.on`. Each property is the exact callback argument tuple for that event.
    */
   interface EventMap {
+    /**
+     * Dispatched once per session, when the local player can play: the session is established and the game has taken its own loading screen down. The game raises that moment itself -- it is its own gameplay-start signal, not a guess from timing.
+     * 
+     * Resources are running long before this, so it is not the moment a resource may start listening; it is the moment the player is looking at the world. Put what the player should see on arrival here -- a welcome, a first page -- rather than in `resourceStart`, which runs behind the loading screen. The server raises its own `playerReady` for this player right after.
+     */
+    playerReady: [player: Player];
+
     /**
      * Dispatched when this player starts or stops following a server quest in the game's journal, whichever way it happened: the track button, the game auto-tracking a quest that turns active, or the untrack that follows finishing or failing one. Local to this machine and raised before the server is told; the server raises its own `questTrackingChanged` when the report arrives. Repeats are filtered, so it only fires on an actual change. Handler promises are not awaited.
      */
@@ -3555,7 +3562,7 @@ declare global {
     send(text: string): void;
 
     /**
-     * Changes visibility of the native chat overlay without opening its input field.
+     * Changes visibility of the native chat overlay without opening its input field. Hidden, the overlay also stops opening on its key. The choice holds for the rest of the session and resets to visible on disconnect, so a resource that replaces the chat calls this once at startup.
      * @param visible Whether the chat overlay is rendered.
      */
     setUIVisible(visible: boolean): void;
@@ -3797,6 +3804,18 @@ declare global {
      */
     getRange(): number;
 
+    /**
+     * Switches how far this player's voice carries. A request: the server paces it, decides the radius, and may move the player itself.
+     * @param tier Voice tier: 0 whisper, 1 normal, 2 shout.
+     */
+    setTier(tier: number): void;
+
+    /**
+     * Reads the voice tier this player is on.
+     * @returns 0 whisper, 1 normal, 2 shout.
+     */
+    getTier(): number;
+
     /**
      * Rebinds push-to-talk. Unknown key names throw.
      * @param key Case-insensitive key name, using the same names as Key.bind.

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

@@ -50,11 +50,44 @@ 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];
+
     /**
      * Dispatched immediately after a horse is created and replicated, whether by `Horse.spawn`, the `/horse` command, or anything else.
      */
@@ -229,6 +262,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.
      */
@@ -266,6 +304,13 @@ declare global {
      */
     doorInteract: [player: Player, door: Door, action: "open" | "close" | "lock" | "unlock" | "lockpick", keySide: boolean];
 
+    /**
+     * 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.
      */
@@ -721,6 +766,16 @@ declare global {
      */
     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.
      */
@@ -782,7 +837,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 +849,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.
@@ -888,6 +970,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.
@@ -2013,9 +2101,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 +2113,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.
@@ -2615,38 +2724,83 @@ 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 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. 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.
+     * 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;
 
@@ -2660,7 +2814,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 +2827,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.
      */
@@ -3174,6 +3345,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 +4436,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 +4449,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingdomsconnected/types",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "TypeScript declarations for the Kingdoms Connected scripting API, one entry per side: @kingdomsconnected/types/server and @kingdomsconnected/types/client",
   "license": "UNLICENSED",
   "keywords": [
@@ -12,17 +12,27 @@
   ],
   "exports": {
     "./server": {
-      "types": "./server/index.d.ts"
+      "types": "./generated/server-api.d.ts"
     },
     "./client": {
-      "types": "./client/index.d.ts"
+      "types": "./generated/client-api.d.ts"
     },
     "./package.json": "./package.json"
   },
+  "typesVersions": {
+    "*": {
+      "server": [
+        "generated/server-api.d.ts"
+      ],
+      "client": [
+        "generated/client-api.d.ts"
+      ]
+    }
+  },
   "files": [
     "shared.d.ts",
-    "server/index.d.ts",
-    "client/index.d.ts"
+    "generated/server-api.d.ts",
+    "generated/client-api.d.ts"
   ],
   "publishConfig": {
     "access": "public"