@modlock/modlock 0.0.0-stage → 0.1.64

package/host.gen.d.ts

@@ -0,0 +1,1927 @@
+/** Vector is a position or direction in the world, in game units. */
+export interface Vector {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Angles is a rotation in degrees. */
+export interface Angles {
+    pitch: number;
+    yaw: number;
+    roll: number;
+}
+/** ScreenEffect is a stock full-screen view effect. */
+export type ScreenEffect = 'killed' | 'black' | 'blinded' | 'darkness' | 'matchIntro';
+/** FieldType is how ReadField and WriteField interpret a field's storage. */
+export type FieldType = 'bool' | 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'int64' | 'uint64' | 'float32' | 'float64' | 'vector' | 'handle' | 'string';
+/** PickupKind is a kind of item players collect by walking over it. */
+export type PickupKind = 'urn' | 'movementBuff';
+/** MovementAction is a movement fact the game announced for a hero. */
+export type MovementAction = 'landed' | 'ziplineAttached' | 'groundDash' | 'slide' | 'bouncePad' | 'dashJump' | 'airJump' | 'wallJump' | 'airDash' | 'meleeStarted' | 'abilityExecuted';
+/** TextAlign places text across its position. */
+export type TextAlign = 'left' | 'center' | 'right';
+/** TextVerticalAlign places text up and down its position. */
+export type TextVerticalAlign = 'bottom' | 'center' | 'top';
+/** ModRole is what a player is to the running mods. */
+export type ModRole = 'unspecified' | 'developer' | 'tester';
+/**
+ * CameraParam is one value of the camera that follows a hero, which the
+ * game's abilities move as Mirage's Tornado pulls the camera back.
+ */
+export type CameraParam = 'distance' | 'fieldOfView' | 'target' | 'verticalOffset' | 'horizontalOffset';
+/** Ability is one ability a hero owns. */
+export interface Ability {
+    /** name is the ability's name, such as citadel_ability_hornet_snipe. */
+    readonly name: string;
+    /** slot is the ability's place on the hero: 0 to 3 are the ability keys. */
+    readonly slot: number;
+    /**
+     * entity is the ability's entity handle, as DamageEvent.ability reports
+     * it.
+     */
+    readonly entity: number;
+    /**
+     * upgrades holds the bought tiers: bit 0 unlocks it and bits 1 to 3 are
+     * its upgrades.
+     */
+    readonly upgrades: number;
+    /** charges is the charges the ability holds. */
+    readonly charges: number;
+    /** cooldownEnd is the game time its cooldown ends, or zero without one. */
+    readonly cooldownEnd: number;
+    /** id identifies the ability's definition, as replays record it. */
+    readonly id: number;
+    /** state is the packed upgrade word; its high half is upgrades. */
+    readonly state: number;
+    /** cooldownStart is the game time its cooldown began. */
+    readonly cooldownStart: number;
+    /** rechargeStart is the game time its next charge began recovering. */
+    readonly rechargeStart: number;
+    /**
+     * rechargeEnd is the game time its next charge returns, or zero without
+     * one.
+     */
+    readonly rechargeEnd: number;
+}
+/** AbilityOptions changes one ability of a player's hero. */
+export interface AbilityOptions {
+    /** ability is the ability's name. */
+    ability: string;
+    /**
+     * upgrades replaces the bought tiers, as ability.upgrades: 0b1111 unlocks
+     * it with all three upgrades.
+     */
+    upgrades?: number;
+    /** charges replaces the charges the ability holds, keeping its timers. */
+    charges?: number;
+    /** cooldownEnd replaces the game time its cooldown ends. */
+    cooldownEnd?: number;
+    /** rechargeEnd replaces the game time its next charge returns. */
+    rechargeEnd?: number;
+    /**
+     * maxCharges replaces the most charges the ability can hold, from 1 to 100;
+     * 0 returns it to the game's own. The server applies it, so the hero's
+     * screen can still show the game's maximum. charges above the new maximum
+     * are not removed; set them with charges.
+     */
+    maxCharges?: number;
+}
+/** BuildCategory is one named group of a build's items. */
+export interface BuildCategory {
+    /** name is the category's title. */
+    readonly name: string;
+    /** description is the author's note on the category. */
+    readonly description: string;
+    /**
+     * items lists the category's items in buying order. An item this game
+     * version does not define is left out.
+     */
+    readonly items: BuildItem[];
+}
+/** BuildItem is one item of a build. */
+export interface BuildItem {
+    /** item is the item's name, as GiveItem takes it. */
+    readonly item: string;
+    /** annotation is the author's note on the item. */
+    readonly annotation: string;
+}
+/**
+ * DamageEvent is one hit before the game applies it. Handles are zero when
+ * the game names no such entity.
+ */
+export interface DamageEvent {
+    /** victim is the entity taking the hit. */
+    readonly victim: number;
+    /**
+     * attacker is the entity credited with the hit. Zero makes the hit a
+     * hazard, such as poison gas, which credits no one and ignores the
+     * inflictor and hit group.
+     */
+    readonly attacker: number;
+    /** inflictor is what delivered the hit, such as a projectile. */
+    readonly inflictor: number;
+    /** ability is the ability that dealt the hit. */
+    readonly ability: number;
+    /** flags are the game's damage flags. */
+    readonly flags: bigint;
+    /** hitGroup is the body part hit; 1 is the head and -1 means none. */
+    readonly hitGroup: number;
+    /** amount is the hit's damage before resistances. */
+    readonly amount: number;
+}
+/**
+ * DamageResult answers a DamageEvent. An empty result lets the hit through.
+ */
+export interface DamageResult {
+    /** block cancels the hit's health loss, force, effects and procs. */
+    block?: boolean;
+    /** amount replaces the hit's damage when present. */
+    amount?: number;
+}
+/** DamagedEvent reports one hit the game applied. */
+export interface DamagedEvent {
+    /** victim is the entity that took the hit. */
+    readonly victim: number;
+    /** attacker is the entity credited with the hit, or zero for a hazard. */
+    readonly attacker: number;
+    /** ability is the ability that dealt the hit. */
+    readonly ability: number;
+    /** healthLost is the health the hit removed, after resistances. */
+    readonly healthLost: number;
+    /**
+     * healthBefore is the victim's health before the hit; a hit that removes
+     * all of it kills.
+     */
+    readonly healthBefore: number;
+    /**
+     * dealt is the hit's damage after resistances, before the victim's health
+     * capped it.
+     */
+    readonly dealt: number;
+}
+/** LaunchEvent is a watched projectile's first frame. */
+export interface LaunchEvent {
+    /** entity is the projectile's entity handle. */
+    readonly entity: number;
+    /** name is the projectile's designer name. */
+    readonly name: string;
+    /** owner is the entity that fired it, or zero. */
+    readonly owner: number;
+    /** player is the slot of the player whose hero fired it, or -1. */
+    readonly player: Player;
+    /** position is where the projectile is. */
+    readonly position: Vector;
+}
+/** ImpactEvent is a watched projectile striking something. */
+export interface ImpactEvent {
+    /** entity is the projectile's entity handle. */
+    readonly entity: number;
+    /** name is the projectile's designer name. */
+    readonly name: string;
+    /** owner is the entity that fired it, or zero. */
+    readonly owner: number;
+    /** player is the slot of the player whose hero fired it, or -1. */
+    readonly player: Player;
+    /**
+     * start and end are the projectile's movement this frame, which ended in
+     * the strike.
+     */
+    readonly start: Vector;
+    readonly end: Vector;
+    /** position is where it struck. */
+    readonly position: Vector;
+    /** hit is the entity struck, or zero for the world. */
+    readonly hit: number;
+}
+/** ProjectileOptions selects the projectiles a mod watches. */
+export interface ProjectileOptions {
+    /** names lists designer names, such as rocket_launcher_rocket_projectile. */
+    names?: readonly string[];
+    /**
+     * keepMomentum gives each live hero back the motion it had before a
+     * watched projectile's explosion, so the mod's Impact handler sets the
+     * push.
+     */
+    keepMomentum?: boolean;
+}
+/** HitOptions describes damage the mod deals. */
+export interface HitOptions {
+    /**
+     * victim is the hero or unit to hurt. The world, props and buildings are
+     * refused: the client crashes on their damage events.
+     */
+    victim: number;
+    /**
+     * attacker is the entity credited with the hit. Without one the hit is a
+     * hazard, such as poison gas, which credits no one and ignores the
+     * inflictor and hit group.
+     */
+    attacker?: number;
+    /** inflictor is what delivered the hit; the default is the attacker. */
+    inflictor?: number;
+    /** amount is the damage before resistances. */
+    amount: number;
+    /**
+     * hitGroup is the body part hit; 1 is the head. The default is the game's
+     * choice.
+     */
+    hitGroup?: number;
+    /**
+     * ability is the entity handle of the ability that dealt the hit, as
+     * ability.entity reports it.
+     */
+    ability?: number;
+}
+/**
+ * TraceOptions describes a line to test against the world. Layers are bits
+ * of the game's collision layers: bit 0 is solid, 2 trigger, 4 player clip,
+ * 18 player and 19 NPC.
+ */
+export interface TraceOptions {
+    /** start is where the line begins. */
+    start: Vector;
+    /** end is where the line ends. */
+    end: Vector;
+    /**
+     * layers selects what the line can hit; the default is solid and
+     * hitboxes.
+     */
+    layers?: bigint;
+    /** exclude removes things in these layers from the hits. */
+    exclude?: bigint;
+    /** ignore lists entity handles the line passes through. */
+    ignore?: readonly number[];
+}
+/** TraceHit is where a traced line first hit something. */
+export interface TraceHit {
+    /** position is the hit point. */
+    readonly position: Vector;
+    /** normal is the surface's direction at the hit point. */
+    readonly normal: Vector;
+    /** startSolid is true when the line began inside something solid. */
+    readonly startSolid: boolean;
+    /** entity is the entity hit, or zero for the world. */
+    readonly entity: number;
+}
+/** ScreenTiming is a screen effect's timing in seconds. */
+export interface ScreenTiming {
+    /** delay is the time before the effect starts. */
+    delay?: number;
+    /** fadeIn is the time the effect takes to reach full strength. */
+    fadeIn?: number;
+    /** hold is the time the effect stays at full strength. */
+    hold?: number;
+    /** fadeOut is the time the effect takes to end. */
+    fadeOut?: number;
+}
+/**
+ * FieldValue is one field's value. The host accepts any numeric case for a
+ * numeric type and answers with the case its type reads as: a boolean, a
+ * number for a type of 32 bits or less and a handle, an integer for a 64-bit
+ * type, a vector or text.
+ */
+export type FieldValue = boolean | number | bigint | string | Vector;
+/** FieldWrite writes one schema field of an entity the host creates. */
+export interface FieldWrite {
+    /** className is the server class that declares the field, or a subclass. */
+    className: string;
+    /**
+     * field is the field's schema name, such as m_iLane. A dotted path, such as
+     * m_Collision.m_CollisionGroup, names a field inside an embedded structure.
+     */
+    field: string;
+    /** type is how to write the field. */
+    type: FieldType;
+    /** value is the field's value. */
+    value: FieldValue;
+}
+/** EntityClassName names one entity's class two ways. */
+export interface EntityClassName {
+    /** className is the server schema class, such as CCitadelPlayerPawn. */
+    readonly className: string;
+    /** designerName is the name maps and spawns use, such as npc_trooper. */
+    readonly designerName: string;
+}
+/** EntityPlacement is an entity's place in the world. */
+export interface EntityPlacement {
+    /** position is the entity's absolute origin. */
+    readonly position: Vector;
+    /** facing is the entity's absolute angles. */
+    readonly facing: Angles;
+    /**
+     * velocity is the entity's motion in units per second. For a body the
+     * physics simulates, such as a prop_physics, it is the body's.
+     */
+    readonly velocity?: Vector;
+}
+/** EntityOptions describes an entity to create. */
+export interface EntityOptions {
+    /** designerName is the entity's designer name, such as npc_trooper_boss. */
+    designerName: string;
+    /**
+     * subclass names the entity's game data entry, such as npc_boss_tier1 for
+     * the lane Guardian, for an entity that reads one while spawning. Without
+     * one, the entity uses the entry named for its class when the game has one,
+     * and a class whose entries all have other names, such as npc_trooper, is
+     * refused.
+     */
+    subclass: string;
+    /** team is the entity's team number; 4 is neutral. */
+    team: number;
+    /** position is the entity's origin. */
+    position: Vector;
+    /** facing is where the entity faces. */
+    facing?: Angles;
+    /**
+     * keyValues are the entity's spawn key values, as a map sets them, such as
+     * model or rendercolor.
+     */
+    keyValues?: readonly KeyValue[];
+    /**
+     * fields are schema fields the host writes after it creates the entity and
+     * before the entity spawns. A write that fails cancels the creation.
+     */
+    fields?: readonly FieldWrite[];
+    /**
+     * transmitAlways sends the entity to every client, past the game's own
+     * rule, which never sends one without a model, such as a
+     * point_clientui_dialog.
+     */
+    transmitAlways?: boolean;
+}
+/** KeyValue is one spawn key value. */
+export interface KeyValue {
+    /** key is the key value's name, such as skin. */
+    key: string;
+    /** value is the key value's value. */
+    value: EntityValue;
+}
+/**
+ * EntityValue is a value a map gives an entity: a spawn key value or an
+ * input's parameter. An input reads its parameter as the type it takes, such
+ * as an integer for Skin or a color, as 0xRRGGBBAA, for Color, and does not
+ * convert text.
+ */
+export type EntityValue = {
+    readonly boolean: boolean;
+} | {
+    readonly integer: number;
+} | {
+    readonly number: number;
+} | {
+    readonly text: string;
+} | {
+    readonly vector: Vector;
+} | {
+    readonly color: number;
+};
+/** InputEvent is one player's watched buttons that went down or up. */
+export interface InputEvent {
+    /** player is the player who pressed. */
+    readonly player: Player;
+    /** pressed holds one bit per button that went down. */
+    readonly pressed: bigint;
+    /** released holds one bit per button that went up. */
+    readonly released: bigint;
+}
+/**
+ * RiftState is the Rift objective's timing as the game holds it. Times are
+ * game times in seconds, or zero when unset.
+ */
+export interface RiftState {
+    /** scoringTeam is the team holding the Rift, or zero. */
+    readonly scoringTeam: number;
+    readonly scoringTime: number;
+    readonly cashInStarted: number;
+    readonly giveUpTime: number;
+    /** nextSpawn is when the Rift next opens. */
+    readonly nextSpawn: number;
+    readonly spawnWindow: number;
+}
+/**
+ * MovementSample is one watched hero's movement on one tick, as the game keeps
+ * it. A hero whose position, velocity or ground the game does not provide has
+ * no sample; another field the game did not provide is absent or zero.
+ */
+export interface MovementSample {
+    /** player is the hero's player slot. */
+    readonly player: Player;
+    /** pawn is the hero's entity handle. */
+    readonly pawn: number;
+    /** position is the hero's origin, at its feet. */
+    readonly position: Vector;
+    /** velocity is the hero's motion in units per second. */
+    readonly velocity: Vector;
+    /**
+     * grounded is true while the hero stands on something. sliding, mantling,
+     * climbing and dashing are the game's movement states.
+     */
+    readonly grounded: boolean;
+    readonly sliding: boolean;
+    readonly mantling: boolean;
+    readonly climbing: boolean;
+    readonly dashing: boolean;
+    /**
+     * jumpAbility is the hero's jump ability, and wallJumps the game's count of
+     * consecutive wall jumps on it.
+     */
+    readonly jumpAbility: number;
+    readonly wallJumps: number;
+    /**
+     * mantleAbility is the hero's mantle ability, and mantleStart the game time
+     * its latest mantle began.
+     */
+    readonly mantleAbility: number;
+    readonly mantleStart: number;
+    /**
+     * wallContact is where the hero was when the jump ability last found a wall
+     * to jump off; it holds still once no wall qualifies.
+     */
+    readonly wallContact: Vector;
+    /** wallNormal is the last wall touched, never cleared. */
+    readonly wallNormal: Vector;
+    /** wallJumpNormal is the normal the latest wall jump used. */
+    readonly wallJumpNormal: Vector;
+    /** wallJumpFacing is the game's EWallJumpFacing, zero when not on a wall. */
+    readonly wallJumpFacing: number;
+    /**
+     * ziplineTime is the game time the hero last rode a zipline; it advances on
+     * every tick of a ride.
+     */
+    readonly ziplineTime?: number;
+    /** actions are the movement facts the game announced since the last tick. */
+    readonly actions: MovementAction[];
+    /**
+     * casts are the abilities the hero cast since the last tick, one per
+     * MOVEMENT_ACTION_ABILITY_EXECUTED, by entity handle as Ability.entity
+     * reports it; Abilities names each one's slot.
+     */
+    readonly casts: number[];
+    /**
+     * command is the movement the hero's player commanded since the last
+     * sample, absent before the game ran any of it.
+     */
+    readonly command?: MovementCommand;
+}
+/**
+ * MovementCommand is the movement a player commanded over one tick. The
+ * server runs a player's commands as they arrive, so a tick may run several
+ * or none: every press among them is kept once, and a tick that ran none
+ * holds the last buttons without pressing them again.
+ */
+export interface MovementCommand {
+    /**
+     * held, changed and scroll are the game's InButtonState masks as Buttons
+     * bits: the buttons down, the buttons that went down or up, and the
+     * presses of scroll-wheel buttons.
+     */
+    held: bigint;
+    changed: bigint;
+    scroll: bigint;
+    /** forward, left and up are the movement axes, from -1 to 1. */
+    forward: number;
+    left: number;
+    up: number;
+    /** grounded is true when the hero stood on something as the tick began. */
+    grounded: boolean;
+}
+/** LandedEvent is one hero landing. */
+export interface LandedEvent {
+    /** player is the slot of the player who landed. */
+    readonly player: Player;
+    /** on is the slot of the player landed on, or -1 for the world. */
+    readonly on: number;
+    /** speed is the downward speed just before landing, in units per second. */
+    readonly speed: number;
+}
+/** Steering is one recorded movement command and the pose its step ends on. */
+export interface Steering {
+    command: MovementCommand;
+    /**
+     * position, velocity and grounded are the pose the next step ends on; the
+     * steps after it move on from there.
+     */
+    position: Vector;
+    velocity: Vector;
+    grounded: boolean;
+    /**
+     * facing is where the command looks, which aims the hero and its animation.
+     */
+    facing: Angles;
+}
+/** DriveCommand is a player's controls for one tick and the ticks after it. */
+export interface DriveCommand {
+    /**
+     * facing is where the hero looks and aims; its yaw turns the body, as the
+     * camera turns a player's hero.
+     */
+    facing: Angles;
+    /**
+     * forward and left are the movement axes, from -1 to 1, relative to the
+     * facing's yaw.
+     */
+    forward: number;
+    left: number;
+    /** held holds down these buttons on every tick. */
+    held: bigint;
+    /** pressed presses these buttons on the next tick only, as a tap. */
+    pressed: bigint;
+}
+/** NpcsRestoredEvent reports how a RestoreNpcs ended. */
+export interface NpcsRestoredEvent {
+    /**
+     * error describes the unit that does not match its target, or is empty
+     * when every target was found in place.
+     */
+    readonly error: string;
+}
+/** NpcOptions describes a unit that is not a player, such as a trooper. */
+export interface NpcOptions {
+    /**
+     * className is the unit's entity class, such as npc_trooper or
+     * npc_trooper_boss.
+     */
+    className: string;
+    /**
+     * unit names the unit's game data entry, such as trooper_melee, or is empty
+     * for a unit that needs none.
+     */
+    unit: string;
+    /** team is the unit's team number; 4 is neutral. */
+    team: number;
+    /** position is the unit's origin, at its feet. */
+    position: Vector;
+    /** facing is where the unit faces. */
+    facing?: Angles;
+    /** health is the unit's health; the default is the unit's own. */
+    health?: number;
+    /** maxHealth is the unit's maximum health; the default is health. */
+    maxHealth?: number;
+    /**
+     * lane is the lane the unit walks. A unit whose class walks none, unlike a
+     * trooper, refuses it.
+     */
+    lane?: number;
+    /**
+     * fields are schema fields the host writes after it creates the unit and
+     * before the unit spawns, such as m_iInitialTeamNum, which the game reads
+     * only while spawning. A write that fails cancels the spawn.
+     */
+    fields?: readonly FieldWrite[];
+}
+/** NpcState is a unit's state this frame. */
+export interface NpcState {
+    /** position is the unit's origin. */
+    readonly position: Vector;
+    /** facing is where the unit faces. */
+    readonly facing: Angles;
+    /** health is the unit's health. */
+    readonly health: number;
+    /** maxHealth is the unit's maximum health. */
+    readonly maxHealth: number;
+    /** team is the unit's team number. */
+    readonly team: number;
+}
+/**
+ * NpcTarget is one unit or objective RestoreNpcs places, as replays record
+ * it.
+ */
+export interface NpcTarget {
+    /**
+     * className is the unit's entity class: npc_trooper, npc_trooper_neutral,
+     * npc_boss_tier2, npc_boss_tier3, npc_barrack_boss,
+     * npc_base_defense_sentry, npc_super_neutral or
+     * npc_neutral_sinners_sacrifice.
+     */
+    className: string;
+    /** id identifies the unit's game data entry. */
+    id: number;
+    /** team is the unit's team number; 4 is neutral. */
+    team: number;
+    /** position is the unit's origin, at its feet. */
+    position: Vector;
+    /** facing is where the unit faces. */
+    facing: Angles;
+    /** velocity is the unit's motion in units per second. */
+    velocity?: Vector;
+    /** health and maxHealth are the unit's health. */
+    health: number;
+    maxHealth: number;
+    /** lane is the lane a trooper walks; troopers need one. */
+    lane?: number;
+}
+/** ModelOptions describes a model placed in the world. */
+export interface ModelOptions {
+    /**
+     * resource is the model's path, which the mod precached, with {addon} for
+     * the mod's content addon, as in models/{addon}/pawn.vmdl.
+     */
+    resource: string;
+    /** position is the model's origin. */
+    position: Vector;
+    /** facing is the model's rotation. */
+    facing?: Angles;
+    /** scale multiplies the model's size; the default is 1. */
+    scale?: number;
+    /**
+     * color tints the model as 0xRRGGBBAA; an alpha below 0xff draws it
+     * translucent.
+     */
+    color?: number;
+    /** glow outlines the model through walls. */
+    glow?: boolean;
+    /**
+     * solid makes heroes and traces collide with the model's physics shape,
+     * scaled with the model. Without it, everything passes through.
+     */
+    solid?: boolean;
+}
+/** TextOptions describes text that floats in the world. */
+export interface TextOptions {
+    /** text is the words to show; a newline starts a second line. */
+    text: string;
+    /** position is the text's origin. */
+    position: Vector;
+    /**
+     * facing is the text's rotation. When the text faces the camera it stands
+     * upright and ignores this; otherwise it lies flat, face up, at zero angles
+     * and stands with roll 90.
+     */
+    facing?: Angles;
+    /** fontSize is the text's size; the default is 100. */
+    fontSize?: number;
+    /** color is the text's color as 0xRRGGBBAA; the default is white. */
+    color?: number;
+    /** faceCamera turns the text toward each viewer. */
+    faceCamera?: boolean;
+    /** scale multiplies the text's size in the world; the default is 1. */
+    scale?: number;
+    /**
+     * align is where the text sits across its position; the default is left,
+     * with the text starting there.
+     */
+    align?: TextAlign;
+    /**
+     * verticalAlign is where the text sits up and down its position; the
+     * default is bottom, with the text standing on it.
+     */
+    verticalAlign?: TextVerticalAlign;
+}
+/** ParticleOptions describes a particle effect. */
+export interface ParticleOptions {
+    /**
+     * resource is the particle system's path, which the mod precached, such
+     * as particles/abilities/assassinate_laser_targetting.vpcf, with {addon}
+     * for the mod's content addon, as in particles/{addon}/glow.vpcf.
+     */
+    resource: string;
+    /** position is the effect's origin. */
+    position: Vector;
+    /** facing is the effect's rotation. */
+    facing?: Angles;
+    /** color tints the effect as 0xRRGGBBAA. */
+    color?: number;
+    /** tintPoint is the control point the color sets. */
+    tintPoint?: number;
+    /** point sets one control point to a position, such as a beam's far end. */
+    point?: ParticlePoint;
+    /**
+     * parent is the handle of an entity the effect follows, such as a hero's.
+     */
+    parent?: number;
+    /**
+     * anchors tie control points to entities, which the points follow as the
+     * entities move, such as both ends of a beam.
+     */
+    anchors?: readonly ParticleAnchor[];
+    /**
+     * inactive spawns the effect without starting it: it draws nothing, but
+     * other effects' anchors can follow it as it moves.
+     */
+    inactive?: boolean;
+}
+/** ParticleAnchor ties one control point of a particle effect to an entity. */
+export interface ParticleAnchor {
+    /** index is the control point's number. */
+    index: number;
+    /** entity is the handle of the entity the control point follows. */
+    entity: number;
+}
+/** ParticlePoint places one control point of a particle effect. */
+export interface ParticlePoint {
+    /** index is the control point's number. */
+    index: number;
+    /** position is the control point's value. */
+    position: Vector;
+}
+/** FogOptions describes an oriented box of tinted fog. */
+export interface FogOptions {
+    /** position is the box's origin. */
+    position: Vector;
+    /** facing is the box's rotation. */
+    facing?: Angles;
+    /** mins is the box's lower corner, relative to position. */
+    mins: Vector;
+    /** maxs is the box's upper corner, relative to position. */
+    maxs: Vector;
+    /** strength is the fog's density. */
+    strength: number;
+    /** color tints the fog as 0xRRGGBBAA; alpha is ignored. */
+    color: number;
+}
+/** RestoredEvent reports how a RestoreHero ended. */
+export interface RestoredEvent {
+    /** player is the player whose hero was restored. */
+    readonly player: Player;
+    /**
+     * error describes why the hero does not match its target, or is empty when
+     * it held the target for a second.
+     */
+    readonly error: string;
+}
+/**
+ * PlayersChangedEvent holds every occupied player slot, as Players lists them.
+ */
+export interface PlayersChangedEvent {
+    readonly players: Connection[];
+}
+/** Connection is one occupied player slot. */
+export interface Connection {
+    /** player is the connection's server slot. */
+    readonly player: Player;
+    /** steamId identifies a human's account, or is zero for a bot. */
+    readonly steamId: bigint;
+    /** name is the player's name. */
+    readonly name: string;
+    /** bot is true for a bot player. */
+    readonly bot: boolean;
+    /**
+     * ready is true once a human has finished joining; bots are always ready.
+     */
+    readonly ready: boolean;
+    /** generation changes each time a new connection takes the slot. */
+    readonly generation: number;
+    /**
+     * roles are what the player is to the running mods, as the program that
+     * runs the host grants them. A role decides what a mod shows, such as an
+     * unfinished feature for its testers; the platform that keeps a mod's
+     * shared data checks its own writers.
+     */
+    readonly roles: ModRole[];
+}
+/** Pawn is one player's hero this frame. */
+export interface Pawn {
+    /** entity is the hero's entity handle, which ReadField reads. */
+    readonly entity: number;
+    /** hero identifies the hero, as SelectHero returns it. */
+    readonly hero: number;
+    /** team is the hero's team number. */
+    readonly team: number;
+    /** health is the hero's health; zero or less is dead. */
+    readonly health: number;
+    /**
+     * maxHealth is the hero's networked maximum health, which leaves out
+     * health from items until the hero respawns.
+     */
+    readonly maxHealth: number;
+    /** position is the hero's origin, at its feet. */
+    readonly position: Vector;
+    /** eyeAngles is where the hero aims. */
+    readonly eyeAngles: Angles;
+    /** cameraAngles is where the player's camera looks. */
+    readonly cameraAngles: Angles;
+    /** stamina is the hero's stamina, absent until it has spawned fully. */
+    readonly stamina?: number;
+    /** maxStamina is the hero's maximum stamina, present with stamina. */
+    readonly maxStamina?: number;
+    /** generation is the connection generation the hero belongs to. */
+    readonly generation: number;
+    /** souls is the souls the player holds. */
+    readonly souls: number;
+    /** eyePosition is where the hero's view starts, for aiming traces. */
+    readonly eyePosition: Vector;
+    /** velocity is the hero's motion in units per second. */
+    readonly velocity: Vector;
+    /**
+     * carryingUrn is whether the hero carries the soul urn, absent when the
+     * game's modifier states cannot be read.
+     */
+    readonly carryingUrn?: boolean;
+    /**
+     * score is the player's scoreboard, absent when the game's scoreboard
+     * cannot be read.
+     */
+    readonly score?: Score;
+    /**
+     * cameraPosition is where the player's camera was in their latest command,
+     * shoulder offset included; a ray from it along camera_angles passes
+     * through the reticle. Absent for a bot and on hosts that cannot read
+     * commands.
+     */
+    readonly cameraPosition?: Vector;
+    /**
+     * effectiveMaxHealth is the maximum the hero's health bar shows, health
+     * from items included. Absent when the game's own reading is unavailable.
+     */
+    readonly effectiveMaxHealth?: number;
+}
+/**
+ * Score is one player's scoreboard counters since the match began, as the
+ * game counts them.
+ */
+export interface Score {
+    readonly kills: number;
+    readonly deaths: number;
+    readonly assists: number;
+    /** lastHits counts enemy troopers and neutrals the player finished. */
+    readonly lastHits: number;
+    /**
+     * denies counts allied troopers the player finished before an enemy could.
+     */
+    readonly denies: number;
+    /** heroDamage is the damage the player dealt to enemy heroes. */
+    readonly heroDamage: number;
+    /** heroHealing is the healing the player gave other heroes. */
+    readonly heroHealing: number;
+    /** netWorth is the souls the player has earned, spent or not. */
+    readonly netWorth: number;
+}
+/**
+ * CameraValue is a value for a camera param: a number for every param but
+ * the target, which takes a position.
+ */
+export type CameraValue = number | Vector;
+/** CameraMotion is how an operation moves its param. */
+export type CameraMotion = {
+    readonly hold: CameraHold;
+} | {
+    readonly approach: CameraApproach;
+} | {
+    readonly spring: CameraSpring;
+} | {
+    readonly lerp: CameraLerp;
+} | {
+    readonly lag: CameraLag;
+};
+/** CameraHold keeps a param where it is. */
+export interface CameraHold {
+    /** duration is how long it holds, in seconds. */
+    duration?: number;
+}
+/** CameraApproach moves a param toward a value. */
+export interface CameraApproach {
+    /** value is the value it approaches. */
+    value?: CameraValue;
+    /** speed is the most the param moves each second; omitted, 600. */
+    speed?: number;
+    /**
+     * defaultSpeed is the speed of the return to the usual value; omitted, 600.
+     */
+    defaultSpeed?: number;
+    /** acceleration is how fast the speed builds each second; omitted, 1000. */
+    acceleration?: number;
+    /** minDuration is the least time it runs, in seconds. */
+    minDuration?: number;
+    /** chaseDefault approaches the param's usual value instead of value. */
+    chaseDefault?: boolean;
+}
+/** CameraSpring pulls a param toward a value. */
+export interface CameraSpring {
+    /** value is the value the spring pulls toward. */
+    value?: CameraValue;
+    /** strength is the spring's strength; omitted, 10. */
+    strength?: number;
+    /** minSpeed is the least the param moves each second. */
+    minSpeed?: number;
+    /**
+     * maxDuration ends the spring after this many seconds, or never when zero.
+     */
+    maxDuration?: number;
+}
+/** CameraLerp moves a param from one value to another over a time. */
+export interface CameraLerp {
+    /** start is the value it starts from. */
+    start: CameraValue;
+    /** end is the value it ends at. */
+    end: CameraValue;
+    /** bias and gain shape the curve between them. */
+    bias?: number;
+    gain?: number;
+    /** duration is the time it takes, in seconds; omitted, 1. */
+    duration?: number;
+}
+/** CameraLag lets a param trail its usual value. */
+export interface CameraLag {
+    /** minDuration is the least time it runs, in seconds. */
+    minDuration?: number;
+    /** lagTime is how far behind the param trails, in seconds. */
+    lagTime?: number;
+    /** maxSpeed is the most the param moves each second. */
+    maxSpeed?: number;
+    /** springStrength is the strength of the pull back to the usual value. */
+    springStrength?: number;
+    /**
+     * keepTargetOnScreen strengthens the pull when the target would leave the
+     * screen; omitted, true.
+     */
+    keepTargetOnScreen?: boolean;
+}
+/** CameraOptions adds one operation to a player's camera. */
+export interface CameraOptions {
+    /**
+     * context names a group of operations, which ClearCamera removes together.
+     * Operations on one param in one context run in order, each after the one
+     * before it ends, so a mod sends a whole sequence at once.
+     */
+    context?: string;
+    /** param is the camera value the operation moves. */
+    param: CameraParam;
+    /**
+     * motion is how it moves. Each motion ends once it reaches its value or
+     * its duration, and the param returns to its usual value unless another
+     * operation follows.
+     */
+    motion: CameraMotion;
+    /** delay starts the operation after this many seconds. */
+    delay?: number;
+    /**
+     * relative adds the operation's values to the param's usual value instead
+     * of replacing it.
+     */
+    relative?: boolean;
+    /**
+     * priority decides between contexts moving one param: a higher operation
+     * takes over from a running lower one, which resumes when it ends, and a
+     * lower one does not show while a higher one runs. Omitted, 1.
+     */
+    priority?: number;
+    /**
+     * shared lets operations of other contexts move the param at the same time.
+     */
+    shared?: boolean;
+    /**
+     * target is the entity handle of the hero whose camera moves, as
+     * Pawn.entity reports it; omitted, the player's own hero.
+     */
+    target?: number;
+}
+/**
+ * HeroTarget is the state RestoreHero gives one hero. Omitted parts keep the
+ * hero's own.
+ */
+export interface HeroTarget {
+    /** position is the hero's origin. */
+    position: Vector;
+    /** facing is where the camera faces; a bot's hero faces it. */
+    facing: Angles;
+    /**
+     * fresh gives full health and stamina and readies every ability, in place
+     * of health, max health, upgrade bonuses and timers. A bot's ability
+     * upgrades may grow while the restore runs.
+     */
+    fresh?: boolean;
+    /** level sets the hero's level. */
+    level?: number;
+    /**
+     * health and maxHealth set the hero's health and its base maximum. Both
+     * are required unless the target is fresh.
+     */
+    health?: number;
+    maxHealth?: number;
+    /**
+     * upgradeBonuses are the three stat bonuses purchases add, as replays
+     * record them.
+     */
+    upgradeBonuses?: readonly number[];
+    /** abilities sets the hero's abilities in their slots. */
+    abilities?: readonly EquipmentTarget[];
+    /**
+     * items lists the items that replace the hero's when replaceItems is set.
+     */
+    items?: readonly EquipmentTarget[];
+    /**
+     * replaceItems replaces every item the hero owns with items; an empty list
+     * removes them.
+     */
+    replaceItems?: boolean;
+    /** timers sets the charges and cooldowns of owned abilities and items. */
+    timers?: readonly TimerTarget[];
+}
+/** EquipmentTarget is one ability or item a HeroTarget gives the hero. */
+export interface EquipmentTarget {
+    /** id identifies the definition, as Ability.id. */
+    id: number;
+    /**
+     * slot is its place on the hero, as Ability.slot; abilities need one, and
+     * an item without one goes where the game puts it.
+     */
+    slot?: number;
+    /** state is the packed upgrade word, as Ability.state. */
+    state: number;
+}
+/**
+ * TimerTarget sets one owned ability's or item's charges and cooldowns.
+ * Times are seconds from the moment the host writes them; an omitted start
+ * and end mean no timer.
+ */
+export interface TimerTarget {
+    /** id identifies the ability, as Ability.id. */
+    id: number;
+    /** charges is the charges it holds. */
+    charges: number;
+    /** cooldownStart and cooldownEnd bound its cooldown. */
+    cooldownStart?: number;
+    cooldownEnd?: number;
+    /** rechargeStart and rechargeEnd bound the recovery of its next charge. */
+    rechargeStart?: number;
+    rechargeEnd?: number;
+}
+/** BotOptions describes a bot player. */
+export interface BotOptions {
+    /** name is the bot's player name. */
+    name: string;
+    /** team is the team number to join: 2 or 3. */
+    team: number;
+    /**
+     * hero names the bot's hero, such as hero_wraith, or gives its identifier
+     * as Pawn.hero reports it.
+     */
+    hero?: string | number;
+    /** position is where the bot appears. */
+    position?: Vector;
+}
+/** SettingChangedEvent is one player's new value of one setting. */
+export interface SettingChangedEvent {
+    /** player is the player's server slot. */
+    readonly player: Player;
+    /** key names the setting. */
+    readonly key: string;
+    /** value is the new value. */
+    readonly value: string;
+}
+/** UiPressEvent reports a press on a button in a player's interface. */
+export interface UiPressEvent {
+    /** player is the player who pressed. */
+    readonly player: Player;
+    /** node is the id of the pressed button. */
+    readonly node: string;
+}
+/**
+ * UiInputEvent reports a change the player made to an input in their
+ * interface, with the value as the host checked it.
+ */
+export interface UiInputEvent {
+    /** player is the player who changed it. */
+    readonly player: Player;
+    /** node is the id of the input. */
+    readonly node: string;
+    /** value is the input's new value, in the kind its control holds. */
+    readonly value?: string | number | boolean | number;
+}
+/** StartEvent describes the server the mod starts in. */
+export interface StartEvent {
+    /** args holds the arguments that follow -- on the host command line. */
+    readonly args: string[];
+    /**
+     * checkOnly is true when the host checks the mod without starting a game.
+     * The mod then hears no game events, and a call that needs the game fails;
+     * logging, the host's services, settings, metrics, files, interfaces and
+     * the reload hold still answer.
+     */
+    readonly checkOnly: boolean;
+    /**
+     * source holds an interpreted mod's entry, which the interpreter module
+     * evaluates during start. It is empty for a compiled mod.
+     */
+    readonly source: Uint8Array;
+}
+/** StartResult declares which events the mod consumes. */
+export interface StartResult {
+    /** frames asks for a Frame event every server frame. */
+    frames: boolean;
+    /** damage asks for a damage event before each hit. */
+    damage: boolean;
+    /** damaged asks for a damaged event after each hit. */
+    damaged: boolean;
+    /** chat asks for a chat event for each chat line. */
+    chat: boolean;
+}
+/** FrameEvent identifies one server frame. */
+export interface FrameEvent {
+    /** tick is the server tick, or zero when the clock is unavailable. */
+    readonly tick: bigint;
+    /** timeSeconds is the game clock at this frame, in seconds. */
+    readonly timeSeconds: number;
+    /**
+     * movement holds one sample per watched, live hero when this frame starts a
+     * new tick, and is empty otherwise.
+     */
+    readonly movement: MovementSample[];
+}
+/**
+ * CommandEvent carries one command line from a player: a chat line that
+ * starts with a slash (or ".", "+" or "-"), without that prefix, or a console
+ * command the server received.
+ */
+export interface CommandEvent {
+    /** player is the player who typed the command. */
+    readonly player: Player;
+    /** line is the complete command line, starting with the command name. */
+    readonly line: string;
+}
+/**
+ * ChatEvent carries one chat line as the server accepted it, commands
+ * included.
+ */
+export interface ChatEvent {
+    /** player is the player who wrote the line. */
+    readonly player: Player;
+    /** text is the line as written. */
+    readonly text: string;
+    /** all is true for chat every player reads, false for team chat. */
+    readonly all: boolean;
+    /**
+     * lane is the CMsgLaneColor of the lane the line pings: 1 yellow, 3
+     * green, 4 blue, 6 purple, or 0 for none.
+     */
+    readonly lane: number;
+}
+/** CommandResult answers whether the mod handled a command. */
+export interface CommandResult {
+    /**
+     * claimed ends the command's dispatch; the game and later mods do not see
+     * it.
+     */
+    claimed: boolean;
+}
+/** WorldEvent announces a loaded world. */
+export interface WorldEvent {
+    /** map names the world's map. */
+    readonly map: string;
+}
+/**
+ * ServiceCall calls one method of a service outside Modlock. A host that
+ * embeds Modlock provides services of its own, such as a game mode's match,
+ * and a mod may serve one to the host. The service and its caller agree on
+ * the payload's encoding.
+ */
+export interface ServiceCall {
+    /** service names the service, such as "arena.match". */
+    readonly service: string;
+    /** method names the method within the service. */
+    readonly method: string;
+    /** payload is the call's argument. */
+    readonly payload: Uint8Array;
+}
+/** ServiceReply is a service's answer. */
+export interface ServiceReply {
+    /** payload is the answer. */
+    payload: Uint8Array;
+}
+/** PrecacheOptions names what the next world loads ahead of use. */
+export interface PrecacheOptions {
+    /** heroes are hero names, such as hero_wraith. */
+    heroes?: readonly string[];
+    /**
+     * resources are model and particle paths, such as models/props/crate.vmdl,
+     * with {addon} for the mod's content addon, as in models/{addon}/pawn.vmdl.
+     */
+    resources?: readonly string[];
+}
+/** Player addresses one connected player by their server slot. */
+export declare class Player {
+    /** slot identifies the player on the server. */
+    readonly slot: number;
+    constructor(slot: number);
+    /** chat sends a server chat line to the player. */
+    chat(text: string): boolean;
+    /**
+     * centerText shows text in the middle of the player's screen until it is
+     * replaced. Empty text clears it.
+     */
+    centerText(text: string): boolean;
+    /** announce shows a game announcement with a title to the player. */
+    announce(title: string, text: string): boolean;
+    /** pawn returns the player's hero this frame, or nothing without one. */
+    pawn(): Pawn | undefined;
+    /**
+     * setting returns the player's value of a setting the manifest
+     * declares: the value they chose, or the setting's default. A bot has the
+     * defaults.
+     */
+    setting(key: string): string | undefined;
+    /**
+     * setSetting changes the player's value of a setting the manifest
+     * declares. The value follows the player to later games and other mods'
+     * servers of the same mod; a bot keeps the defaults.
+     */
+    setSetting(key: string, value: string): boolean;
+    /**
+     * addMetric adds to the player's total of a metric the manifest declares.
+     * The host keeps each player's totals in memory and hands them on once,
+     * when the player leaves or the mod stops; a bot keeps none.
+     */
+    addMetric(name: string, value: number, label?: string): boolean;
+    /**
+     * handoff replaces the handoff state for the player, such as the
+     * panels their HUD shows. It lasts only through a reload of the mod in the
+     * same game, in memory, as the game's does, and ends early when the player
+     * leaves; only that player reads it back, and a bot keeps none.
+     */
+    handoff(text: string): boolean;
+    /** handedOff returns the player's handoff state, or empty. */
+    handedOff(): string | undefined;
+    /**
+     * selectHero gives the player a hero on a team, 2 or 3, and returns the
+     * hero's identifier as Pawn.hero reports it. The hero appears on a later
+     * frame.
+     */
+    selectHero(hero: string | number, team: number): number | undefined;
+    /**
+     * spectate moves the player to the spectators, without a hero. The player
+     * watches until a hero selection seats them again.
+     */
+    spectate(): boolean;
+    /**
+     * watch points the player's camera at a hero, through the hero's own view
+     * or chasing it, as the game's spectator camera follows it. A spectator watches through
+     * their spectator camera, once it exists. A player with a hero watches
+     * while the hero stays where it stands, keeping its level, souls and items,
+     * until Unwatch returns them to it.
+     */
+    watch(target: number, chase?: boolean): boolean;
+    /**
+     * freeCamera lets the player fly their camera from a position, with the
+     * movement keys and the mouse, as the game's roaming spectator camera does.
+     * A player with a hero leaves it where it stands, as Watch does, until
+     * Unwatch returns them to it; Watch follows a hero again.
+     */
+    freeCamera(position: Vector, facing: Angles): boolean;
+    /**
+     * moveCamera adds one operation to the player's camera, as the game's
+     * abilities pull it back, widen its view or swing it to a point. Operations
+     * run alongside the game's own until they end or ClearCamera removes them.
+     */
+    moveCamera(options: CameraOptions): boolean;
+    /**
+     * clearCamera removes a context's camera operations from the player's
+     * camera, or every operation, and the camera returns to its usual place.
+     */
+    clearCamera(context?: string): boolean;
+    /**
+     * unwatch returns a player watching or flying the free camera from their
+     * hero back to it. Stopping the mod returns every such player.
+     */
+    unwatch(): boolean;
+    /** respawn revives the player's dead hero. */
+    respawn(): boolean;
+    /**
+     * changeTeam moves the player's hero, living or dead, to team 2 or 3 where
+     * it stands, for a human or a bot alike. The hero keeps its hero,
+     * abilities, items and health, and the player keeps their connection; a
+     * dead hero respawns on its new team, on its timer or through Respawn. A
+     * living hero moved inside the other team's base dies to the base's
+     * defense. A player without a hero joins a team through SelectHero
+     * instead.
+     */
+    changeTeam(team: number): boolean;
+    /** clearItems removes every item the player's hero owns. */
+    clearItems(): boolean;
+    /**
+     * freeze holds the player's hero in place, without input or damage, until
+     * it is released. Stopping the mod releases it.
+     */
+    freeze(frozen?: boolean): boolean;
+    /** restoreStamina refills the player's stamina. */
+    restoreStamina(): boolean;
+    /**
+     * setStamina sets the player's stamina, as Pawn.stamina reads it. The game
+     * regenerates it as usual afterwards.
+     */
+    setStamina(stamina: number): boolean;
+    /**
+     * refreshAbility ends the cooldown of the hero's ability named ability,
+     * such as citadel_ability_melee_parry.
+     */
+    refreshAbility(ability: string): boolean;
+    /**
+     * abilities lists the abilities of the player's hero in the hero's order,
+     * or none without a live hero.
+     */
+    abilities(): Ability[];
+    /**
+     * setAbility changes the upgrades, charges or timers of one of the hero's
+     * abilities. An omitted option stays as it is.
+     */
+    setAbility(options: AbilityOptions): boolean;
+    /**
+     * giveItem gives the hero an item, enabled and free. A hero that owns it
+     * keeps its one copy.
+     */
+    giveItem(item: string): boolean;
+    /**
+     * replaceAbility puts the ability named ability, untrained, in the hero's
+     * ability slot index, as Ability.slot, removing the ability there. An
+     * ability from another hero loads its models and particles only if
+     * Precache named that hero and those resources before the world loaded;
+     * otherwise its first effect stalls the game on a blocking load and the
+     * game reports an assertion.
+     */
+    replaceAbility(index: number, ability: string): boolean;
+    /**
+     * holdModifier keeps an ability's modifier, named "<ability>/<modifier>",
+     * on the hero with no expiry, giving it back whenever the game removes it
+     * or the hero returns. The hero must own the ability or item. Every hero
+     * that gains the modifier from the same ability keeps it until the hold
+     * ends. Releasing leaves the hero's current modifier until it dies.
+     */
+    holdModifier(modifier: string, active?: boolean): boolean;
+    /**
+     * giveModifier gives the hero an ability's modifier, named
+     * "<ability>/<modifier>", for seconds, as if the hero's own ability applied
+     * it; a hero without that ability applies it with its first ability. The
+     * game may end it sooner, as invisibility ends on a shot.
+     */
+    giveModifier(modifier: string, seconds: number): boolean;
+    /**
+     * teleport moves the player's hero and turns it and the camera. With a
+     * velocity it also sets the hero's motion, as a launch, and the camera
+     * follows the hero.
+     */
+    teleport(position: Vector, facing: Angles, velocity?: Vector): boolean;
+    /**
+     * move carries the player's hero to a position as continuous motion,
+     * as a recording plays back. Unlike Teleport it keeps the hero's animated
+     * model drawn when repeated every tick, and leaves the camera alone.
+     */
+    move(position: Vector, facing: Angles, velocity?: Vector): boolean;
+    /**
+     * steer replays a recorded movement command on the player's hero, usually a
+     * bot: the game runs the command's buttons and axes, so the hero crouches,
+     * slides, jumps and mantles with its own animation, and the step then ends
+     * on the recorded pose. The steering stays until the next Steer replaces
+     * it, its presses and its pose counting once: on the ticks between, the
+     * game's own movement carries the held command on from the pose. A Steer
+     * without one releases the hero.
+     */
+    steer(steering?: Steering): boolean;
+    /**
+     * drive gives a bot the controls a player has, where it looks, the
+     * movement axes and the buttons, as its input on every tick until the next
+     * Drive replaces it. The game runs that input as a player's own, so the
+     * hero accelerates, turns, jumps, dashes, slides and casts with its own
+     * movement and animation; the bot's own brain no longer moves it. Presses
+     * count once. A Drive without a command returns the bot to its brain.
+     */
+    drive(command?: DriveCommand): boolean;
+    /**
+     * adjustSouls gives the player delta souls, or takes them when delta is
+     * negative. A spend larger than the player's souls fails and spends
+     * nothing. Silent skips the pickup's sound and number.
+     */
+    adjustSouls(delta: number, silent?: boolean): boolean;
+    /** startingSouls sets the souls the player's hero spawns with. */
+    startingSouls(souls: number): boolean;
+    /**
+     * resetHero rebuilds the player's hero as it first spawned, without items,
+     * ability upgrades, levels or ability points, holding souls.
+     */
+    resetHero(souls: number): boolean;
+    /** heal restores health to the player's hero, up to its maximum. */
+    heal(amount: number): boolean;
+    /**
+     * sound plays a game sound event, such as Damage.Send.Crit, on the
+     * player's hero.
+     */
+    sound(sound: string): boolean;
+    /**
+     * restoreHero gives the player's live hero target over the next few
+     * seconds: the build first, then health, stamina and pose once it settles,
+     * then charges and cooldowns. A Restored event reports when the result has
+     * held for a second, or why it could not. A new call replaces the running
+     * one.
+     */
+    restoreHero(target: HeroTarget): boolean;
+    /**
+     * screenEffect plays a full-screen effect on the player's view. Effects of
+     * one kind stack. The player's hero must be alive.
+     */
+    screenEffect(effect: ScreenEffect, timing?: ScreenTiming): boolean;
+    /**
+     * clearScreenEffect ends every running instance of effect on the player's
+     * view.
+     */
+    clearScreenEffect(effect: ScreenEffect): boolean;
+    /** removeBot removes a bot the mod added. */
+    removeBot(): boolean;
+    /**
+     * blockInput withholds buttons from the player's hero until called
+     * again, on top of the block on everyone. Zero releases the player.
+     */
+    blockInput(buttons: bigint): boolean;
+    /**
+     * press presses buttons at the player's next input, even through a block.
+     * A bot presses them as a player would.
+     */
+    press(buttons: bigint): boolean;
+    /** kill kills a player's hero, crediting no one. */
+    kill(): boolean;
+    /** setVelocity replaces the motion of a player's hero without moving it. */
+    setVelocity(velocity: Vector): boolean;
+    /**
+     * buttons returns the buttons a player holds, as Buttons bits, while the
+     * player is alive or dead.
+     */
+    buttons(): bigint | undefined;
+    /**
+     * watchMovement adds a player's hero to the movement samples of each Frame
+     * event on a new tick, or removes it.
+     */
+    watchMovement(watch: boolean): boolean;
+}
+/** WorldObject is one object the mod placed in the world. */
+export declare class WorldObject {
+    /** id identifies the object among the mod's objects. */
+    readonly id: number;
+    constructor(id: number);
+    /**
+     * move places the object at position, turning it to facing. The
+     * physics step pulls a solid model to its new place over one tick, so a
+     * model moved each frame strikes physics props such as the Hideout ball
+     * with its speed instead of passing through them.
+     */
+    move(position: Vector, facing?: Angles): boolean;
+    /** setText replaces a text object's words. */
+    setText(text: string): boolean;
+    /**
+     * setHidden hides the object from one player or shows it again.
+     * Other players still see it. A player who leaves sees every object when
+     * they return.
+     */
+    setHidden(player: Player, hidden: boolean): boolean;
+    /**
+     * showOnlyTo sends the object only to the players with the listed
+     * server slots; every other client drops it, or never receives it when the
+     * call follows its creation in the same frame. With no players no client
+     * receives it. The list replaces any earlier one and follows the object
+     * when its entity changes. A player who leaves is taken off every list, so
+     * whoever joins in their slot does not receive the object. A removed object
+     * reaches no client while the engine retires its entity.
+     */
+    showOnlyTo(players?: readonly number[]): boolean;
+    /**
+     * showToAll sends the object to every player again, undoing
+     * ShowObjectOnlyTo.
+     */
+    showToAll(): boolean;
+    /** remove takes the object out of the world. */
+    remove(): boolean;
+    /**
+     * entity returns the entity handle of a model or particle, as traces
+     * report it and particle anchors take it.
+     */
+    entity(): number | undefined;
+}
+/** Npc is one unit the mod spawned. */
+export declare class Npc {
+    /** entity is the unit's entity handle, as damage events report it. */
+    readonly entity: number;
+    constructor(entity: number);
+    /** read returns the unit's state, or nothing once it is gone. */
+    read(): NpcState | undefined;
+    /**
+     * move places the unit and sets its velocity, which drives its walk
+     * animation. It reports false once the unit is gone.
+     */
+    move(position: Vector, facing?: Angles, velocity?: Vector): boolean;
+    /**
+     * setHealth sets the unit's health, and its maximum when given. It
+     * reports false once the unit is gone.
+     */
+    setHealth(health: number, maxHealth?: number): boolean;
+    /**
+     * remove takes a unit the mod spawned out of the world without rewards.
+     * It reports false when the unit was already gone.
+     */
+    remove(): boolean;
+}
+/** Pickup is one pickup the mod placed. */
+export declare class Pickup {
+    /** entity is the pickup's entity handle. */
+    readonly entity: number;
+    constructor(entity: number);
+    /**
+     * present reports whether the pickup still lies in the world,
+     * uncollected.
+     */
+    present(): boolean;
+    /**
+     * remove takes the pickup out of the world. It reports false when a
+     * player had collected it.
+     */
+    remove(): boolean;
+}
+/** log writes one line to the server log under the mod's name. */
+export declare function log(message: string): boolean;
+/**
+ * serverCommand runs one line at the server console, as if typed there. A
+ * line that sets a variable may set a development-only or cheat-protected
+ * one. A line that reaches the engine's controls for files, logging, the
+ * network or the process, or stores a command to run later, is refused with
+ * the name of the command.
+ */
+export declare function serverCommand(command: string): boolean;
+/**
+ * precache loads heroes and resources with the next world. Call it during
+ * start, before the first world loads; a call after that, such as from a
+ * reload, prepares only the world after the next map change. Name every
+ * hero whose abilities ReplaceAbility gives, with their particles.
+ */
+export declare function precache(options: PrecacheOptions): boolean;
+/**
+ * readFile reads one of the mod's files: the host's copy, which the mod
+ * wrote or the server's operator placed, else the one the mod ships under
+ * data/. A file in neither reads as unset. Names that leave the mod's
+ * directories are refused.
+ */
+export declare function readFile(name: string): string | undefined;
+/**
+ * writeFile replaces one of the mod's files in the host's copy, which
+ * outlives a restart and an update of the mod; the files the mod ships stay
+ * as they are. The write is whole or not at all, and the host refuses one
+ * past its quota of 4 MiB per mod. A host that keeps no files refuses every
+ * write.
+ */
+export declare function writeFile(name: string, text: string): boolean;
+/**
+ * holdReload keeps the running build through a reload while held is true,
+ * such as while a player is partway through something a new build would
+ * lose. A reload that arrives meanwhile waits, and the newest one applies
+ * on the first frame after the mod releases the hold. A new build starts
+ * without a hold.
+ */
+export declare function holdReload(held: boolean): boolean;
+/**
+ * handoff replaces the handoff state for the game: what the running build
+ * hands the next build when the mod reloads, such as which round it plays.
+ * It lasts only through a reload of the mod in the same game, such as an
+ * update, whose new build reads it back with HandedOff. The host holds it
+ * in memory and never writes it to disk, so it ends when the mod stops or
+ * the server restarts. The host refuses state past 64 KiB.
+ */
+export declare function handoff(text: string): boolean;
+/** handedOff returns the game's handoff state, or empty. */
+export declare function handedOff(): string | undefined;
+/**
+ * heroBuild reads a hero's recommended build from the host's game data:
+ * its categories of items in buying order. Items the game does not define
+ * are left out, so every item returned is one GiveItem accepts. A hero
+ * without a build answers with no categories. The call needs a loaded
+ * world.
+ */
+export declare function heroBuild(hero: string): BuildCategory[];
+/**
+ * readField reads one schema field of a live entity, such as the int32
+ * m_iHealth of CBaseEntity. The host finds the field by name, so it
+ * survives game updates that move it, and refuses an entity that is not of
+ * the named class or a subclass. The match's state, such as the gold of each
+ * team or the winning team, is a field of CCitadelGameRules, which the
+ * citadel_gamerules entity reads. The parts of an entity's model that its
+ * body component holds read through the entity too: CGameSceneNode, and for
+ * a model entity CSkeletonInstance and CModelState, such as the uint64
+ * m_MeshGroupMask of CModelState that chooses which mesh groups draw.
+ */
+export declare function readField(entity: number, className: string, field: string, type: FieldType): FieldValue | undefined;
+/**
+ * readModifierField reads one schema field of a modifier the entity holds,
+ * such as the int32 m_nCameraLevel of CCitadel_Modifier_OrbitCamera on a
+ * pawn holding modifier_citadel_orbit_camera. The answer holds no value
+ * while the entity lacks the modifier. The host cannot check the modifier's
+ * class, so a wrong class reads the wrong bytes, though never past readable
+ * memory.
+ */
+export declare function readModifierField(entity: number, modifier: string, className: string, field: string, type: FieldType): FieldValue | undefined;
+/**
+ * writeField writes one schema field of a live entity and sends the change
+ * to the players. The value takes the form ReadField returns for the type.
+ * Text goes only to a symbol field (string_t, such as the m_DialogXMLName of
+ * a point_clientui_world_panel), with {addon} replaced by the mod's content
+ * addon as in an entity's key values; a CUtlString field owns its text and
+ * cannot be written. A write to the match's state sends all of it, so
+ * players already in the match see the change, and a write to a model part,
+ * as ReadField names them, sends the entity. A client builds a client UI
+ * entity's panel only when it creates the entity, so a write to
+ * m_DialogXMLName sends every client a full update on the next frame, which
+ * creates every entity again; the players' game stalls briefly, so write a
+ * layout when it changes, not every frame.
+ */
+export declare function writeField(entity: number, className: string, field: string, type: FieldType, value: FieldValue): boolean;
+/**
+ * readFieldList reads a field that holds a list, such as the m_vecBannedHeroes
+ * of CCitadelGameRules. The type is the type of one element: a number, a
+ * handle, a boolean or a vector. A list of structures cannot be read.
+ */
+export declare function readFieldList(entity: number, className: string, field: string, type: FieldType): FieldValue[];
+/**
+ * writeFieldList replaces the elements of a list field and sends the change
+ * to the players, growing the list when it holds fewer elements than the
+ * new ones.
+ */
+export declare function writeFieldList(entity: number, className: string, field: string, type: FieldType, values?: readonly FieldValue[]): boolean;
+/**
+ * entityClass returns a live entity's schema class, such as
+ * CCitadelPlayerPawn, whose fields ReadField reads, and its designer name.
+ */
+export declare function entityClass(entity: number): EntityClassName | undefined;
+/**
+ * entityName returns a live entity's name, the targetname a map or a spawn
+ * key value gave it, or an empty name for an unnamed entity.
+ */
+export declare function entityName(entity: number): string | undefined;
+/**
+ * entityPosition returns where a live entity stands, its absolute origin
+ * and angles, as MoveEntity places it, and its velocity. Any entity with a
+ * place in the world has one, such as one of the map's boxes.
+ */
+export declare function entityPosition(entity: number): EntityPlacement | undefined;
+/**
+ * modifierState reports whether an entity has a modifier state, such as
+ * MODIFIER_STATE_PARRY_ACTIVE.
+ */
+export declare function modifierState(entity: number, state: string): boolean;
+/**
+ * holdModifierState holds a modifier state, such as
+ * MODIFIER_STATE_FRIENDLY_FIRE_ENABLED, on an entity while the mod runs, or
+ * releases the hold. The hold ends with the entity.
+ */
+export declare function holdModifierState(entity: number, state: string, active?: boolean): boolean;
+/**
+ * setFreeForAll turns free-for-all on or off for the running mod, over the
+ * Manifest's free_for_all default. While on, the host seats each new player
+ * on the smaller team with no team screen, holds friendly fire on every
+ * hero, makes teammates enemies to abilities, projectiles and target
+ * checks, and ignores changeteam commands. The stock hero picker does not
+ * open for a seated player, so the mod gives each seated player whose pawn
+ * has hero 0 a hero with SelectHero. Turning it off releases the friendly
+ * fire holds and restores stock team relations; players keep their teams.
+ * Clients still draw teammates as allies.
+ */
+export declare function setFreeForAll(enabled: boolean): boolean;
+/**
+ * setTeamSeating turns team seating on or off for the running mod. While
+ * on, the host seats each player who joins with no team on the smaller
+ * team with no team screen; friendly fire and changeteam stay as the game
+ * has them. The stock hero picker does not open for a seated player, so
+ * the mod gives each seated player whose pawn has hero 0 a hero with
+ * SelectHero. Free-for-all seats players this
+ * way whatever this says. Turning it off leaves players on their teams.
+ */
+export declare function setTeamSeating(enabled: boolean): boolean;
+/**
+ * createModel places a model in the world, solid when the options ask.
+ * The world removes it when the world ends; stopping the mod removes it
+ * too.
+ */
+export declare function createModel(options: ModelOptions): WorldObject | undefined;
+/** createText places text that floats in the world. */
+export declare function createText(options: TextOptions): WorldObject | undefined;
+/**
+ * createParticle starts a particle effect. Removing the object stops it
+ * and lets its end cap play out, unless the mod already stopped it, such as
+ * with the DestroyImmediately input; moving it moves the effect.
+ */
+export declare function createParticle(options: ParticleOptions): WorldObject | undefined;
+/**
+ * createFog fills a box with tinted fog whose density fades across the
+ * box's boundary. Removing the object clears it; moving it moves the box.
+ */
+export declare function createFog(options: FogOptions): WorldObject | undefined;
+/**
+ * addBot adds a bot player and returns it. The bot leaves when the world
+ * ends or the mod stops.
+ */
+export declare function addBot(options: BotOptions): Player | undefined;
+/**
+ * blockInput withholds buttons from every player's hero until called
+ * again. Stopping the mod releases them.
+ */
+export declare function blockInput(buttons: bigint): boolean;
+/**
+ * watchInput replaces the buttons whose presses and releases arrive as
+ * Input events. Watching does not withhold a press; block it with
+ * BlockInput.
+ */
+export declare function watchInput(buttons: bigint): boolean;
+/**
+ * remapInput makes the from buttons act as the to buttons for every
+ * player's hero until called again; from reads as up. With repeat, a held
+ * from button uses the to ability again as soon as it is ready. A zero from
+ * stops remapping, and stopping the mod does too. BlockInput applies after
+ * the remap.
+ */
+export declare function remapInput(from: bigint, to: bigint, repeat?: boolean): boolean;
+/**
+ * callService calls method of a service the host provides outside Modlock,
+ * such as a game mode's match, and returns the service's answer. The
+ * service defines the payload's encoding.
+ */
+export declare function callService(service: string, method: string, payload: Uint8Array): Uint8Array | undefined;
+/**
+ * createEntity creates any entity the server knows by its designer name,
+ * such as npc_trooper_boss or prop_dynamic, with spawn key values and fields
+ * written before it spawns. The world removes it when the world ends;
+ * stopping the mod removes it too. It refuses an ability, item or weapon,
+ * which only a hero holds: GiveItem and ReplaceAbility give one.
+ */
+export declare function createEntity(options: EntityOptions): number | undefined;
+/**
+ * fireInput sends an input to a live entity, as a map's output would, such
+ * as Skin with the integer 1. The value must have the type the input reads.
+ * It reports false once the entity is gone.
+ */
+export declare function fireInput(entity: number, input: string, value?: EntityValue, activator?: number): boolean;
+/**
+ * removeEntity takes an entity the mod created out of the world without
+ * rewards. It reports false when the entity was already gone.
+ */
+export declare function removeEntity(entity: number): boolean;
+/**
+ * showEntityOnlyTo sends an entity the mod created only to the players with
+ * the listed server slots; every other client drops it, or never receives
+ * it when the call follows its creation in the same frame. With no players
+ * no client receives it. The list replaces any earlier one. A player who
+ * leaves is taken off every list, so whoever joins in their slot does not
+ * receive the entity. The rule holds for an entity created with
+ * TransmitAlways too, but not for entities parented to it, which need their
+ * own call. Removing the entity, the world ending or the mod stopping drops
+ * the rule.
+ */
+export declare function showEntityOnlyTo(entity: number, players?: readonly number[]): boolean;
+/**
+ * showEntityToAll sends an entity the mod created to every player the game
+ * would send it to again, undoing ShowEntityOnlyTo.
+ */
+export declare function showEntityToAll(entity: number): boolean;
+/**
+ * spawnNpc adds a unit that is not a player, such as a trooper, as
+ * CreateEntity does, then sets its health and lane. It thinks from the next
+ * frame. The world removes it when the world ends; stopping
+ * the mod removes it too.
+ */
+export declare function spawnNpc(options: NpcOptions): Npc | undefined;
+/**
+ * createPickup places an urn, which a hero carries once collected, or a
+ * movement buff. Stopping the mod removes it.
+ */
+export declare function createPickup(kind: PickupKind, position: Vector): Pickup | undefined;
+/**
+ * findEntities returns the handle of every live entity of a class, such as
+ * zip_line_node.
+ */
+export declare function findEntities(className: string): number[];
+/**
+ * findEntitiesByName returns the handle of every live entity with a name,
+ * the targetname a map or the targetname key value of CreateEntity gave it.
+ */
+export declare function findEntitiesByName(name: string): number[];
+/**
+ * removeEntities removes every entity of a class, such as npc_trooper,
+ * without rewards, and returns how many it removed.
+ */
+export declare function removeEntities(className: string): number | undefined;
+/**
+ * clearMap removes the map's own units and objectives, such as troopers,
+ * guardians and walkers, so a mode can use the map as an arena.
+ */
+export declare function clearMap(): boolean;
+/**
+ * damage deals a hit as the game would. The mod's Damage events do not
+ * include its own hits.
+ */
+export declare function damage(options: HitOptions): boolean;
+/**
+ * trace returns where a line first hits something, or nothing when it hits
+ * nothing or the world's collision is not ready.
+ */
+export declare function trace(options: TraceOptions): TraceHit | undefined;
+/**
+ * restoreNpcs replaces the map's lane units and objectives with targets
+ * over the next frames. Units of these classes not in the list are
+ * removed, structures that match are kept, and moving units are spawned
+ * again in place. An NpcsRestored event reports when every target stands
+ * as its own unit, or why not. A new call replaces the running one.
+ */
+export declare function restoreNpcs(npcs?: readonly NpcTarget[]): boolean;
+/**
+ * pause stops or resumes the game clock, as the pause command would.
+ * Stopping the mod resumes it.
+ */
+export declare function pause(paused: boolean): boolean;
+/** matchClock returns the match time in seconds that the scoreboard shows. */
+export declare function matchClock(): number | undefined;
+/**
+ * holdMatchClock keeps the match time at seconds every frame until called
+ * again; omitted seconds let it run.
+ */
+export declare function holdMatchClock(seconds?: number): boolean;
+/** rift reads the Rift objective's state. */
+export declare function rift(): RiftState | undefined;
+/** startRift opens the Rift objective at position now. */
+export declare function startRift(position: Vector): boolean;
+/**
+ * moveEntity places any entity, such as a projectile, and replaces its
+ * facing and motion when given. Without a position it leaves the entity
+ * where it is, so a velocity alone steers a body the physics simulates, such
+ * as a prop_physics, which carries the motion on against the world.
+ */
+export declare function moveEntity(entity: number, position?: Vector, facing?: Angles, velocity?: Vector): boolean;
+/**
+ * pushEntity adds a velocity and an angular velocity to any entity. On a
+ * body the physics simulates, such as a prop_physics, it acts like an
+ * impulse that the simulation carries on.
+ */
+export declare function pushEntity(entity: number, velocity: Vector, spin?: Vector): boolean;
+/** emitSound plays one game sound on any entity, such as a projectile. */
+export declare function emitSound(entity: number, sound: string): boolean;
+/**
+ * watchProjectiles reports the projectiles with these designer names, such
+ * as rocket_launcher_rocket_projectile, in Launch and Impact events. A new
+ * call replaces the list; an empty list stops watching.
+ */
+export declare function watchProjectiles(options: ProjectileOptions): boolean;
+/** ModHandlers handles the events the game delivers to the mod. */
+export interface ModHandlers {
+    /** start begins the mod's active lifetime, once, before any other event. */
+    start(event: StartEvent): StartResult;
+    /** frame runs once per server frame while the mod asked for frames. */
+    frame(event: FrameEvent): void;
+    /** command offers one command a player typed. */
+    command(event: CommandEvent): CommandResult;
+    /**
+     * chat reports each chat line the server accepted from a player the mod
+     * serves, while the mod asked for chat, before the line's command.
+     */
+    chat(event: ChatEvent): void;
+    /**
+     * world follows each world load, and start when a world has already
+     * loaded. Objects and bots from an earlier world are gone by then.
+     */
+    world(event: WorldEvent): void;
+    /** uiPress reports a press on a button in a player's interface. */
+    uiPress(event: UiPressEvent): void;
+    /** uiInput reports a change to an input in a player's interface. */
+    uiInput(event: UiInputEvent): void;
+    /** serve calls a service the mod serves from the host. */
+    serve(event: ServiceCall): ServiceReply;
+    /**
+     * damage offers one hit before the game applies it, while the mod asked
+     * for damage. The mod's answer may block the hit or change its amount.
+     */
+    damage(event: DamageEvent): DamageResult;
+    /**
+     * damaged reports one hit the game applied, while the mod asked for
+     * damage reports. Hits arrive before the next frame.
+     */
+    damaged(event: DamagedEvent): void;
+    /**
+     * input reports one player's presses of watched buttons, before the next
+     * frame. A block in place still withholds them from the hero.
+     */
+    input(event: InputEvent): void;
+    /** restored ends one RestoreHero, before the next frame. */
+    restored(event: RestoredEvent): void;
+    /** npcsRestored ends one RestoreNpcs, before the next frame. */
+    npcsRestored(event: NpcsRestoredEvent): void;
+    /**
+     * launch reports a watched projectile's first frame, before the next frame.
+     */
+    launch(event: LaunchEvent): void;
+    /**
+     * impact reports a watched projectile striking something, inside the
+     * game's impact and after its own explosion. The mod's calls apply before
+     * the game continues.
+     */
+    impact(event: ImpactEvent): void;
+    /**
+     * landed reports a hero landing under the manifest's QuakeWorld movement,
+     * before the next frame.
+     */
+    landed(event: LandedEvent): void;
+    /**
+     * settingChanged reports a player's setting that changed outside the mod,
+     * such as on the player's profile. A mod's own SetPlayerSetting reports
+     * nothing.
+     */
+    settingChanged(event: SettingChangedEvent): void;
+    /**
+     * playersChanged reports the occupied player slots before the first event
+     * after Start, and again before the next event whenever a player joins,
+     * finishes joining or leaves, so a mod lists players without a call.
+     */
+    playersChanged(event: PlayersChangedEvent): void;
+}
+/**
+ * serveMod runs the encoded Call in bytes on handlers and returns the encoded
+ * Reply. A handler that throws answers with its error.
+ */
+export declare function serveMod(handlers: ModHandlers, bytes: Uint8Array): Uint8Array;