hytopia 0.2.11 → 0.3.0-dev.2

package/server.d.ts

@@ -1,4 +1,6 @@
 import type { AnyPacket } from '@hytopia.com/server-protocol';
+import type { ErrorEvent as ErrorEvent_2 } from 'ws';
+import EventEmitter from 'eventemitter3';
 import http from 'http';
 import type { IncomingMessage } from 'http';
 import type { InputSchema } from '@hytopia.com/server-protocol';
@@ -7,7 +9,7 @@ import type { LobbyMembershipDto } from '@hytopia.com/creative-lib/dist/impl/get
 import protocol from '@hytopia.com/server-protocol';
 import RAPIER from '@dimforge/rapier3d-compat-simd';
 import { SdpMatrix3 } from '@dimforge/rapier3d-compat-simd';
-import type { Socket as Socket_2 } from 'net';
+import type { Socket } from 'net';
 import { WebSocket as WebSocket_2 } from 'ws';
 
 /**
@@ -18,6 +20,11 @@ import { WebSocket as WebSocket_2 } from 'ws';
  * They support a variety of configuration options through
  * the {@link AudioOptions} constructor argument.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link AudioEventPayloads}
+ *
  * @example
  * ```typescript
  * (new Audio({
@@ -27,9 +34,11 @@ import { WebSocket as WebSocket_2 } from 'ws';
  * })).play(world);
  * ```
  *
+ * @eventProperty
+ *
  * @public
  */
-export declare class Audio implements protocol.Serializable {
+export declare class Audio extends EventRouter implements protocol.Serializable {
 
 
 
@@ -140,59 +149,69 @@ export declare class Audio implements protocol.Serializable {
 
 }
 
-/** Payloads for events an Audio instance can emit. @public */
-export declare namespace AudioEventPayload {
-    export interface Pause {
+/** Event types an Audio instance can emit. See {@link AudioEventPayloads} for the payloads. @public */
+export declare enum AudioEvent {
+    PAUSE = "AUDIO.PAUSE",
+    PLAY = "AUDIO.PLAY",
+    PLAY_RESTART = "AUDIO.PLAY_RESTART",
+    SET_ATTACHED_TO_ENTITY = "AUDIO.SET_ATTACHED_TO_ENTITY",
+    SET_DETUNE = "AUDIO.SET_DETUNE",
+    SET_DISTORTION = "AUDIO.SET_DISTORTION",
+    SET_POSITION = "AUDIO.SET_POSITION",
+    SET_PLAYBACK_RATE = "AUDIO.SET_PLAYBACK_RATE",
+    SET_REFERENCE_DISTANCE = "AUDIO.SET_REFERENCE_DISTANCE",
+    SET_VOLUME = "AUDIO.SET_VOLUME"
+}
+
+/** Event payloads for Audio emitted events. @public */
+export declare interface AudioEventPayloads {
+    /** Emitted when the audio is paused. */
+    [AudioEvent.PAUSE]: {
         audio: Audio;
-    }
-    export interface Play {
+    };
+    /** Emitted when the audio is played. */
+    [AudioEvent.PLAY]: {
         audio: Audio;
-    }
-    export interface PlayRestart {
+    };
+    /** Emitted when the audio is restarted. */
+    [AudioEvent.PLAY_RESTART]: {
         audio: Audio;
-    }
-    export interface SetAttachedToEntity {
+    };
+    /** Emitted when the audio is attached to an entity. */
+    [AudioEvent.SET_ATTACHED_TO_ENTITY]: {
         audio: Audio;
         entity: Entity | undefined;
-    }
-    export interface SetDetune {
+    };
+    /** Emitted when the audio's detune is set. */
+    [AudioEvent.SET_DETUNE]: {
         audio: Audio;
         detune: number;
-    }
-    export interface SetDistortion {
+    };
+    /** Emitted when the audio's distortion is set. */
+    [AudioEvent.SET_DISTORTION]: {
         audio: Audio;
         distortion: number;
-    }
-    export interface SetPosition {
+    };
+    /** Emitted when the audio's position is set. */
+    [AudioEvent.SET_POSITION]: {
         audio: Audio;
         position: Vector3Like;
-    }
-    export interface SetPlaybackRate {
+    };
+    /** Emitted when the audio's playback rate is set. */
+    [AudioEvent.SET_PLAYBACK_RATE]: {
         audio: Audio;
         playbackRate: number;
-    }
-    export interface SetReferenceDistance {
+    };
+    /** Emitted when the audio's reference distance is set. */
+    [AudioEvent.SET_REFERENCE_DISTANCE]: {
         audio: Audio;
         referenceDistance: number;
-    }
-    export interface SetVolume {
+    };
+    /** Emitted when the audio's volume is set. */
+    [AudioEvent.SET_VOLUME]: {
         audio: Audio;
         volume: number;
-    }
-}
-
-/** Event types an Audio instance can emit. @public */
-export declare enum AudioEventType {
-    PAUSE = "AUDIO.PAUSE",
-    PLAY = "AUDIO.PLAY",
-    PLAY_RESTART = "AUDIO.PLAY_RESTART",
-    SET_ATTACHED_TO_ENTITY = "AUDIO.SET_ATTACHED_TO_ENTITY",
-    SET_DETUNE = "AUDIO.SET_DETUNE",
-    SET_DISTORTION = "AUDIO.SET_DISTORTION",
-    SET_POSITION = "AUDIO.SET_POSITION",
-    SET_PLAYBACK_RATE = "AUDIO.SET_PLAYBACK_RATE",
-    SET_REFERENCE_DISTANCE = "AUDIO.SET_REFERENCE_DISTANCE",
-    SET_VOLUME = "AUDIO.SET_VOLUME"
+    };
 }
 
 /**
@@ -298,44 +317,14 @@ export declare interface AudioOptions {
  * niche behavior of one controller for many entities that
  * behave in unison.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link BaseEntityControllerEventPayloads}
+ *
  * @public
  */
-export declare abstract class BaseEntityController {
-    /**
-     * A function that is called every tick. Useful for implementing
-     * tick logic without writing a new entity controller class.
-     */
-    onTick?: (entity: Entity, deltaTimeMs: number) => void;
-    /**
-     * A function that is called every tick with player input by a
-     * PlayerEntity with this controller attached. Useful for implementing
-     * tick logic without writing a new entity controller class.
-     */
-    onTickWithPlayerInput?: (entity: PlayerEntity, input: PlayerInput, cameraOrientation: PlayerCameraOrientation, deltaTimeMs: number) => void;
-    /**
-     * A function that is called when the controller is attached to an entity.
-     * Useful for implementing attach logic without writing a
-     * new entity controller class.
-     */
-    onAttach?: (entity: Entity) => void;
-    /**
-     * A function that is called when the controlled entity is despawned.
-     * Useful for implementing despawn logic without writing a
-     * new entity controller class.
-     */
-    onDespawn?: (entity: Entity) => void;
-    /**
-     * A function that is called when the controller is detached from an entity.
-     * Useful for implementing detach logic without writing a
-     * new entity controller class.
-     */
-    onDetach?: (entity: Entity) => void;
-    /**
-     * A function that is called when the controlled entity is spawned.
-     * Useful for implementing spawn logic without writing a
-     * new entity controller class.
-     */
-    onSpawn?: (entity: Entity) => void;
+export declare abstract class BaseEntityController extends EventRouter {
     /**
      * Override this method to handle the attachment of an entity
      * to your entity controller.
@@ -379,6 +368,48 @@ export declare abstract class BaseEntityController {
     tick(entity: Entity, deltaTimeMs: number): void;
 }
 
+/** Event types a BaseEntityController instance can emit. See {@link BaseEntityControllerEventPayloads} for the payloads. @public */
+export declare enum BaseEntityControllerEvent {
+    ATTACH = "attach",
+    DESPAWN = "despawn",
+    DETACH = "detach",
+    SPAWN = "spawn",
+    TICK = "tick",
+    TICK_WITH_PLAYER_INPUT = "tickWithPlayerInput"
+}
+
+/** Event payloads for BaseEntityController emitted events. @public */
+export declare interface BaseEntityControllerEventPayloads {
+    /** Emitted when an entity is attached to the controller. */
+    [BaseEntityControllerEvent.ATTACH]: {
+        entity: Entity;
+    };
+    /** Emitted when an entity is despawned. */
+    [BaseEntityControllerEvent.DESPAWN]: {
+        entity: Entity;
+    };
+    /** Emitted when an entity is detached from the controller. */
+    [BaseEntityControllerEvent.DETACH]: {
+        entity: Entity;
+    };
+    /** Emitted when an entity is spawned. */
+    [BaseEntityControllerEvent.SPAWN]: {
+        entity: Entity;
+    };
+    /** Emitted when an entity is ticked. */
+    [BaseEntityControllerEvent.TICK]: {
+        entity: Entity;
+        deltaTimeMs: number;
+    };
+    /** Emitted when an entity is ticked with player input. */
+    [BaseEntityControllerEvent.TICK_WITH_PLAYER_INPUT]: {
+        entity: PlayerEntity;
+        input: PlayerInput;
+        cameraOrientation: PlayerCameraOrientation;
+        deltaTimeMs: number;
+    };
+}
+
 /**
  * Represents a block in a world.
  *
@@ -417,6 +448,11 @@ export declare class Block {
  * allowing you to create custom blocks with unique visual representations
  * and behaviors.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link BlockTypeEventPayloads}
+ *
  * @example
  * ```typescript
  * const stoneBlockTypeId = 10;
@@ -432,33 +468,7 @@ export declare class Block {
  *
  * @public
  */
-export declare class BlockType implements protocol.Serializable {
-    /**
-     * A callback function that is invoked when an entity collides with blocks of this type.
-     *
-     * @remarks
-     * This must be set before a block of this type is created.
-     * If it is set after a block is created, only future created
-     * blocks of this type will have the callback set.
-     *
-     * @param blockType - The block type the collision is for.
-     * @param entity - The entity that collided with the block type.
-     * @param started - Whether the collision started.
-     */
-    onEntityCollision?: ((blockType: BlockType, entity: Entity, started: boolean) => void) | ((blockType: BlockType, entity: Entity, started: boolean, colliderHandleA: number, colliderHandleB: number) => void);
-    /**
-     * A callback function that is invoked when an entity contacts a block of this type.
-     *
-     * @remarks
-     * This must be set before a block of this type is created.
-     * If it is set after a block is created, only future created
-     * blocks of this type will have the callback set.
-     *
-     * @param blockType - The block type the contact is for.
-     * @param entity - The entity that contacted the block type.
-     * @param contactForceData - The contact force data.
-     */
-    onEntityContactForce?: (blockType: BlockType, entity: Entity, contactForceData: ContactForceData) => void;
+export declare class BlockType extends EventRouter implements protocol.Serializable {
 
 
 
@@ -486,6 +496,30 @@ export declare class BlockType implements protocol.Serializable {
 
 }
 
+/** Event types a BlockType instance can emit. See {@link BlockTypeEventPayloads} for the payloads. @public */
+export declare enum BlockTypeEvent {
+    ENTITY_COLLISION = "BLOCK_TYPE.ENTITY_COLLISION",
+    ENTITY_CONTACT_FORCE = "BLOCK_TYPE.ENTITY_CONTACT_FORCE"
+}
+
+/** Event payloads for BlockType emitted events. @public */
+export declare interface BlockTypeEventPayloads {
+    /** Emitted when an entity collides with a block type. */
+    [BlockTypeEvent.ENTITY_COLLISION]: {
+        blockType: BlockType;
+        entity: Entity;
+        started: boolean;
+        colliderHandleA: number;
+        colliderHandleB: number;
+    };
+    /** Emitted when an entity's contact force is applied to a block type. */
+    [BlockTypeEvent.ENTITY_CONTACT_FORCE]: {
+        blockType: BlockType;
+        entity: Entity;
+        contactForceData: ContactForceData;
+    };
+}
+
 /** Options for creating a block type instance. @public */
 export declare interface BlockTypeOptions {
     /** The unique numeric identifier for the block type. */
@@ -509,6 +543,11 @@ export declare interface BlockTypeOptions {
  * type registry allows you to register and retrieve block
  * types by their unique id for a world.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link BlockTypeRegistryEventPayloads}
+ *
  * @example
  * ```typescript
  * world.blockTypeRegistry.registerGenericBlockType({
@@ -520,7 +559,7 @@ export declare interface BlockTypeOptions {
  *
  * @public
  */
-export declare class BlockTypeRegistry implements protocol.Serializable {
+export declare class BlockTypeRegistry extends EventRouter implements protocol.Serializable {
 
 
 
@@ -551,38 +590,41 @@ export declare class BlockTypeRegistry implements protocol.Serializable {
 
 }
 
-/** Payloads for events a BlockTypeRegistry instance can emit. @public */
-export declare namespace BlockTypeRegistryEventPayload {
-    export interface RegisterBlockType {
+/** Event types a BlockTypeRegistry instance can emit. See {@link BlockTypeRegistryEventPayloads} for the payloads. @public */
+export declare enum BlockTypeRegistryEvent {
+    REGISTER_BLOCK_TYPE = "BLOCK_TYPE_REGISTRY.REGISTER_BLOCK_TYPE"
+}
+
+/** Event payloads for BlockTypeRegistry emitted events. @public */
+export declare interface BlockTypeRegistryEventPayloads {
+    /** Emitted when a block type is registered. */
+    [BlockTypeRegistryEvent.REGISTER_BLOCK_TYPE]: {
         blockTypeRegistry: BlockTypeRegistry;
         id: number;
         blockType: BlockType;
-    }
+    };
 }
 
-/** Event types a BlockTypeRegistry instance can emit. @public */
-export declare enum BlockTypeRegistryEventType {
-    REGISTER_BLOCK_TYPE = "BLOCK_TYPE_REGISTRY.REGISTER_BLOCK_TYPE"
+/** Event types a ChatManager instance can emit. See {@link ChatEventPayloads} for the payloads. @public */
+export declare enum ChatEvent {
+    BROADCAST_MESSAGE = "CHAT.BROADCAST_MESSAGE",
+    PLAYER_MESSAGE = "CHAT.PLAYER_MESSAGE"
 }
 
-/** Payloads for events a ChatManager instance can emit. @public */
-export declare namespace ChatEventPayload {
-    export interface SendBroadcastMessage {
+/** Event payloads for ChatManager emitted events. @public */
+export declare interface ChatEventPayloads {
+    /** Emitted when a broadcast message is sent. */
+    [ChatEvent.BROADCAST_MESSAGE]: {
+        player: Player | undefined;
         message: string;
         color?: string;
-        playerId?: string;
-    }
-    export interface SendPlayerMessage {
+    };
+    /** Emitted when a message is sent to a specific player. */
+    [ChatEvent.PLAYER_MESSAGE]: {
         player: Player;
         message: string;
         color?: string;
-    }
-}
-
-/** Event types a ChatManager instance can emit. @public */
-export declare enum ChatEventType {
-    SEND_BROADCAST_MESSAGE = "CHAT.SEND_BROADCAST_MESSAGE",
-    SEND_PLAYER_MESSAGE = "CHAT.SEND_PLAYER_MESSAGE"
+    };
 }
 
 /**
@@ -596,6 +638,11 @@ export declare enum ChatEventType {
  * commands that can be used in chat to execute game
  * logic.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link ChatEventPayloads}
+ *
  * @example
  * ```typescript
  * world.chatManager.registerCommand('/kick', (player, args, message) => {
@@ -613,16 +660,7 @@ export declare enum ChatEventType {
  *
  * @public
  */
-export declare class ChatManager {
-    /**
-     * A function that is called when a broadcast (public) message is sent
-     * by a player or the server.
-     *
-     * @param player - The player that sent the message, or undefined if the message is a system message from the server.
-     * @param message - The message to send.
-     * @param color - The color of the message as a hex color code, excluding #.
-     */
-    onBroadcastMessage?: (player: Player | undefined, message: string, color?: string) => void;
+export declare class ChatManager extends EventRouter {
 
 
 
@@ -662,7 +700,6 @@ export declare class ChatManager {
     sendPlayerMessage(player: Player, message: string, color?: string): void;
 
 
-
 }
 
 /**
@@ -685,6 +722,11 @@ export declare class ChatManager {
  * associated with the {@link World} the chunk belongs to. A block type id of 0
  * is used to represent no block. Removing a block is done by .setBlock(localCoordinate, 0).
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link ChunkEventPayloads}
+ *
  * @example
  * ```typescript
  * // Assume we previously registered a stone block with type id of 10..
@@ -697,7 +739,7 @@ export declare class ChatManager {
  *
  * @public
  */
-export declare class Chunk implements protocol.Serializable {
+export declare class Chunk extends EventRouter implements protocol.Serializable {
 
 
 
@@ -779,27 +821,30 @@ export declare class Chunk implements protocol.Serializable {
 
 }
 
-/** Payloads for events a Chunk instance can emit. @public */
-export declare namespace ChunkEventPayload {
-    export interface Despawn {
+/** Event types a Chunk instance can emit. See {@link ChunkEventPayloads} for the payloads. @public */
+export declare enum ChunkEvent {
+    DESPAWN = "CHUNK.DESPAWN",
+    SET_BLOCK = "CHUNK.SET_BLOCK",
+    SPAWN = "CHUNK.SPAWN"
+}
+
+/** Event payloads for Chunk emitted events. @public */
+export declare interface ChunkEventPayloads {
+    /** Emitted when a chunk is despawned. */
+    [ChunkEvent.DESPAWN]: {
         chunk: Chunk;
-    }
-    export interface SetBlock {
+    };
+    /** Emitted when a block is set in a chunk. */
+    [ChunkEvent.SET_BLOCK]: {
         chunk: Chunk;
         globalCoordinate: Vector3Like;
         localCoordinate: Vector3Like;
         blockTypeId: number;
-    }
-    export interface Spawn {
+    };
+    /** Emitted when a chunk is spawned. */
+    [ChunkEvent.SPAWN]: {
         chunk: Chunk;
-    }
-}
-
-/** Event types a Chunk instance can emit. @public */
-export declare enum ChunkEventType {
-    DESPAWN = "CHUNK.DESPAWN",
-    SET_BLOCK = "CHUNK.SET_BLOCK",
-    SPAWN = "CHUNK.SPAWN"
+    };
 }
 
 /**
@@ -888,7 +933,7 @@ export declare enum CoefficientCombineRule {
  *
  * @public
  */
-export declare class Collider {
+export declare class Collider extends EventRouter {
 
 
 
@@ -1259,6 +1304,11 @@ export declare const DEFAULT_ENTITY_RIGID_BODY_OPTIONS: RigidBodyOptions;
  * allow full control of their rigid body and attached collider
  * dynamics.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link EntityEventPayloads}
+ *
  * @example
  * ```typescript
  * const spider = new Entity({
@@ -1286,66 +1336,6 @@ export declare const DEFAULT_ENTITY_RIGID_BODY_OPTIONS: RigidBodyOptions;
  * @public
  */
 export declare class Entity extends RigidBody implements protocol.Serializable {
-    /**
-     * A function that is called when the entity collides with a block.
-     *
-     * @remarks
-     * This must be set before the entity is spawned.
-     *
-     * @param entity - The Entity instance the collision is for.
-     * @param blockType - The block type that the entity collided with.
-     * @param started - Whether the collision started or ended.
-     */
-    onBlockCollision?: ((entity: Entity, blockType: BlockType, started: boolean) => void) | ((entity: Entity, blockType: BlockType, started: boolean, colliderHandleA: number, colliderHandleB: number) => void);
-    /**
-     * A function that is called when the entity collides with a block.
-     *
-     * @remarks
-     * This must be set before the entity is spawned.
-     *
-     * @param entity - The Entity instance the collision is for.
-     * @param blockType - The block type that the entity collided with.
-     * @param contactForceData - The contact force data.
-     */
-    onBlockContactForce?: (entity: Entity, blockType: BlockType, contactForceData: ContactForceData) => void;
-    /**
-     * A function that is called when the entity collides with another entity.
-     *
-     * @remarks
-     * This must be set before the entity is spawned.
-     *
-     * @param entity - The Entity instance the collision is for.
-     * @param otherEntity - The other entity that the entity collided with.
-     * @param started - Whether the collision started or ended.
-     */
-    onEntityCollision?: ((entity: Entity, otherEntity: Entity, started: boolean) => void) | ((entity: Entity, otherEntity: Entity, started: boolean, colliderHandleA: number, colliderHandleB: number) => void);
-    /**
-     * A function that is called when the entity contacts another entity.
-     *
-     * @remarks
-     * This must be set before the entity is spawned.
-     *
-     * @param entity - The Entity instance the collision is for.
-     * @param otherEntity - The other entity that the entity collided with.
-     * @param contactForceData - The contact force data.
-     */
-    onEntityContactForce?: (entity: Entity, otherEntity: Entity, contactForceData: ContactForceData) => void;
-    /**
-     * A function that is called when the entity is spawned.
-     * @param entity - The Entity instance that spawned.
-     */
-    onSpawn?: (entity: Entity) => void;
-    /**
-     * A function that is called when the entity is despawned.
-     * @param entity - The Entity instance that despawned.
-     */
-    onDespawn?: (entity: Entity) => void;
-    /**
-     * A function that is called every tick.
-     * @param entity - The Entity instance that ticked.
-     * @param tickDeltaMs - The delta time in milliseconds since the last tick.
-     */
-    onTick?: (entity: Entity, tickDeltaMs: number) => void;
 
 
 
@@ -1511,71 +1501,121 @@ export declare class Entity extends RigidBody implements protocol.Serializable {
 
 }
 
-/** Payloads for events an Entity instance can emit. @public */
-export declare namespace EntityEventPayload {
-    export interface Despawn {
+/** Event types an Entity instance can emit. See {@link EntityEventPayloads} for the payloads. @public */
+export declare enum EntityEvent {
+    BLOCK_COLLISION = "ENTITY.BLOCK_COLLISION",
+    BLOCK_CONTACT_FORCE = "ENTITY.BLOCK_CONTACT_FORCE",
+    DESPAWN = "ENTITY.DESPAWN",
+    ENTITY_COLLISION = "ENTITY.ENTITY_COLLISION",
+    ENTITY_CONTACT_FORCE = "ENTITY.ENTITY_CONTACT_FORCE",
+    SET_MODEL_ANIMATIONS_PLAYBACK_RATE = "ENTITY.SET_MODEL_ANIMATIONS_PLAYBACK_RATE",
+    SET_MODEL_HIDDEN_NODES = "ENTITY.SET_MODEL_HIDDEN_NODES",
+    SET_OPACITY = "ENTITY.SET_OPACITY",
+    SET_PARENT = "ENTITY.SET_PARENT",
+    SET_TINT_COLOR = "ENTITY.SET_TINT_COLOR",
+    SPAWN = "ENTITY.SPAWN",
+    START_MODEL_LOOPED_ANIMATIONS = "ENTITY.START_MODEL_LOOPED_ANIMATIONS",
+    START_MODEL_ONESHOT_ANIMATIONS = "ENTITY.START_MODEL_ONESHOT_ANIMATIONS",
+    STOP_MODEL_ANIMATIONS = "ENTITY.STOP_MODEL_ANIMATIONS",
+    TICK = "ENTITY.TICK",
+    UPDATE_POSITION = "ENTITY.UPDATE_POSITION",
+    UPDATE_ROTATION = "ENTITY.UPDATE_ROTATION"
+}
+
+/** Event payloads for Entity emitted events. @public */
+export declare interface EntityEventPayloads {
+    /** Emitted when an entity collides with a block type. */
+    [EntityEvent.BLOCK_COLLISION]: {
+        entity: Entity;
+        blockType: BlockType;
+        started: boolean;
+        colliderHandleA: number;
+        colliderHandleB: number;
+    };
+    /** Emitted when an entity's contact force is applied to a block type. */
+    [EntityEvent.BLOCK_CONTACT_FORCE]: {
         entity: Entity;
-    }
-    export interface SetModelAnimationsPlaybackRate {
+        blockType: BlockType;
+        contactForceData: ContactForceData;
+    };
+    /** Emitted when an entity is despawned. */
+    [EntityEvent.DESPAWN]: {
+        entity: Entity;
+    };
+    /** Emitted when an entity collides with another entity. */
+    [EntityEvent.ENTITY_COLLISION]: {
+        entity: Entity;
+        otherEntity: Entity;
+        started: boolean;
+        colliderHandleA: number;
+        colliderHandleB: number;
+    };
+    /** Emitted when an entity's contact force is applied to another entity. */
+    [EntityEvent.ENTITY_CONTACT_FORCE]: {
+        entity: Entity;
+        otherEntity: Entity;
+        contactForceData: ContactForceData;
+    };
+    /** Emitted when the playback rate of the entity's model animations is set. */
+    [EntityEvent.SET_MODEL_ANIMATIONS_PLAYBACK_RATE]: {
         entity: Entity;
         playbackRate: number;
-    }
-    export interface SetModelHiddenNodes {
+    };
+    /** Emitted when the nodes of the entity's model are set to be hidden. */
+    [EntityEvent.SET_MODEL_HIDDEN_NODES]: {
         entity: Entity;
         modelHiddenNodes: Set<string>;
-    }
-    export interface SetOpacity {
+    };
+    /** Emitted when the opacity of the entity is set. */
+    [EntityEvent.SET_OPACITY]: {
         entity: Entity;
         opacity: number;
-    }
-    export interface SetParent {
+    };
+    /** Emitted when the parent of the entity is set. */
+    [EntityEvent.SET_PARENT]: {
         entity: Entity;
         parent: Entity | undefined;
         parentNodeName: string | undefined;
-    }
-    export interface SetTintColor {
+    };
+    /** Emitted when the tint color of the entity is set. */
+    [EntityEvent.SET_TINT_COLOR]: {
         entity: Entity;
         tintColor: RgbColor | undefined;
-    }
-    export interface Spawn {
+    };
+    /** Emitted when the entity is spawned. */
+    [EntityEvent.SPAWN]: {
         entity: Entity;
-    }
-    export interface StartModelLoopedAnimations {
+    };
+    /** Emitted when the looped animations of the entity's model are started. */
+    [EntityEvent.START_MODEL_LOOPED_ANIMATIONS]: {
         entity: Entity;
         animations: Set<string>;
-    }
-    export interface StartModelOneshotAnimations {
+    };
+    /** Emitted when the oneshot animations of the entity's model are started. */
+    [EntityEvent.START_MODEL_ONESHOT_ANIMATIONS]: {
         entity: Entity;
         animations: Set<string>;
-    }
-    export interface StopModelAnimations {
+    };
+    /** Emitted when the model animations of the entity are stopped. */
+    [EntityEvent.STOP_MODEL_ANIMATIONS]: {
         entity: Entity;
         animations: Set<string>;
-    }
-    export interface UpdatePosition {
+    };
+    /** Emitted when the entity is ticked. */
+    [EntityEvent.TICK]: {
+        entity: Entity;
+        tickDeltaMs: number;
+    };
+    /** Emitted when the position of the entity is updated at the end of the tick, either directly or by physics. */
+    [EntityEvent.UPDATE_POSITION]: {
         entity: Entity;
         position: Vector3Like;
-    }
-    export interface UpdateRotation {
+    };
+    /** Emitted when the rotation of the entity is updated at the end of the tick, either directly or by physics. */
+    [EntityEvent.UPDATE_ROTATION]: {
         entity: Entity;
         rotation: QuaternionLike;
-    }
-}
-
-/** Event types an Entity instance can emit. @public */
-export declare enum EntityEventType {
-    DESPAWN = "ENTITY.DESPAWN",
-    SET_MODEL_ANIMATIONS_PLAYBACK_RATE = "ENTITY.SET_MODEL_ANIMATIONS_PLAYBACK_RATE",
-    SET_MODEL_HIDDEN_NODES = "ENTITY.SET_MODEL_HIDDEN_NODES",
-    SET_OPACITY = "ENTITY.SET_OPACITY",
-    SET_PARENT = "ENTITY.SET_PARENT",
-    SET_TINT_COLOR = "ENTITY.SET_TINT_COLOR",
-    SPAWN = "ENTITY.SPAWN",
-    START_MODEL_LOOPED_ANIMATIONS = "ENTITY.START_MODEL_LOOPED_ANIMATIONS",
-    START_MODEL_ONESHOT_ANIMATIONS = "ENTITY.START_MODEL_ONESHOT_ANIMATIONS",
-    STOP_MODEL_ANIMATIONS = "ENTITY.STOP_MODEL_ANIMATIONS",
-    UPDATE_POSITION = "ENTITY.UPDATE_POSITION",
-    UPDATE_ROTATION = "ENTITY.UPDATE_ROTATION"
+    };
 }
 
 /**
@@ -1684,56 +1724,88 @@ export declare interface EntityOptions {
 }
 
 /**
- * Manages event emission and assigned listener callbacks.
+ * The payloads for all events in the game server.
  *
- * @remarks
- * This class is used as a singleton for global server events via
- * {@link EventRouter.serverInstance}. For individual worlds, an
- * internal EventRouter instance is instantiated per world. EventRouters
- * only have visibility of events emitted and subscribed to relative to
- * their unique instances.
+ * @public
+ */
+export declare interface EventPayloads extends AudioEventPayloads, BaseEntityControllerEventPayloads, BlockTypeEventPayloads, BlockTypeRegistryEventPayloads, ChatEventPayloads, ChunkEventPayloads, ConnectionEventPayloads, EntityEventPayloads, GameServerEventPayloads, PlayerCameraEventPayloads, PlayerEventPayloads, PlayerManagerEventPayloads, PlayerUIEventPayloads, SceneUIEventPayloads, SimulationEventPayloads, SocketEventPayloads, LightEventPayloads, WebServerEventPayloads, WorldEventPayloads, WorldLoopEventPayloads {
+}
+
+/**
+ * Manages event emission and assigned listener callbacks.
  *
  * @public
  */
 export declare class EventRouter {
-    /** The singleton instance for global server events. */
-    static readonly serverInstance: EventRouter;
     private _emitter;
-    private _tag;
-    /** Enable logging of all events. Default: false */
-    logAllEvents: boolean;
-    /** Enable logging of event payloads. Default: false */
-    logEventsPayloads: boolean;
-    /** Enable logging of events with no listeners. Default: false */
-    logUnlistenedEvents: boolean;
-    /** Array of events to exclude from logging */
-    logIgnoreEvents: string[];
-    /** Array of event prefixes to exclude from logging */
-    logIgnoreEventPrefixes: string[];
-    /** @param tag - Tag for logging, used to identify EventRouter instances in logs. */
-    constructor(tag: string);
+    private _finalListeners;
     /**
      * Emit an event, invoking all registered listeners for the event type.
      *
      * @param eventType - The type of event to emit.
      * @param payload - The payload to emit.
      *
-     * @returns `true` if listeners were found and invoked, `false` otherwise.
+     * @returns `true` if any listeners were found and invoked, `false` otherwise.
+     */
+    emit<TEventType extends keyof EventPayloads>(eventType: TEventType, payload: EventPayloads[TEventType]): boolean;
+    emit<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, payload: TPayload): boolean;
+    /**
+     * Emits an event to the local and global server instance event routers.
+     *
+     * @param eventType - The type of event to emit.
+     * @param payload - The payload to emit.
+     */
+    emitWithGlobal<TEventType extends keyof EventPayloads>(eventType: TEventType, payload: EventPayloads[TEventType]): void;
+    emitWithGlobal<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, payload: TPayload): void;
+    /**
+     * Emits an event to local and provided world event routers.
+     *
+     * @param world - The world to broadcast the event to.
+     * @param eventType - The type of event to broadcast.
+     * @param payload - The payload to broadcast.
+     */
+    emitWithWorld<TEventType extends keyof EventPayloads>(world: World, eventType: TEventType, payload: EventPayloads[TEventType]): void;
+    emitWithWorld<TEventType extends string, TPayload = any>(world: World, eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, payload: TPayload): void;
+
+    final<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, listener: (payload: TPayload) => void): void;
+    /**
+     * Check if there are listeners for a specific event type.
+     *
+     * @param eventType - The type of event to check for listeners.
+     *
+     * @returns `true` if listeners are found, `false` otherwise.
      */
-    emit<TPayload>(eventType: string, payload: TPayload): boolean;
+    hasListeners(eventType: keyof EventPayloads): boolean;
+    /**
+     * Get all listeners for a specific event type.
+     *
+     * @param eventType - The type of event to get listeners for.
+     *
+     * @returns All listeners for the event type.
+     */
+    listeners(eventType: keyof EventPayloads): EventEmitter.EventListener<any, string>[];
+    /**
+     * Get the number of listeners for a specific event type.
+     *
+     * @param eventType - The type of event to get the listener count for.
+     *
+     * @returns The number of listeners for the event type.
+     */
+    listenerCount(eventType: keyof EventPayloads): number;
     /**
      * Remove a listener for a specific event type.
      *
      * @param eventType - The type of event to remove the listener from.
      * @param listener - The listener function to remove.
      */
-    off<TPayload>(eventType: string, listener: (payload: TPayload) => void): void;
+    off<TEventType extends keyof EventPayloads>(eventType: TEventType, listener: (payload: EventPayloads[TEventType]) => void): void;
+    off<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, listener: (payload: TPayload) => void): void;
     /**
-     * Remove all listeners for a specific event type.
+     * Remove all listeners or all listeners for a provided event type.
      *
      * @param eventType - The type of event to remove all listeners from.
      */
-    offAll(eventType: string): void;
+    offAll(eventType?: keyof EventPayloads): void;
     /**
      * Register a listener for a specific event type.
      *
@@ -1743,28 +1815,16 @@ export declare class EventRouter {
      * @param eventType - The type of event to listen for.
      * @param listener - The listener function to invoke when the event is emitted.
      */
-    on<TPayload>(eventType: string, listener: (payload: TPayload) => void): void;
+    on<TEventType extends keyof EventPayloads>(eventType: TEventType, listener: (payload: EventPayloads[TEventType]) => void): void;
+    on<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, listener: (payload: TPayload) => void): void;
     /**
      * Register a listener for a specific event type that will be invoked once.
      *
      * @param eventType - The type of event to listen for.
      * @param listener - The listener function to invoke when the event is emitted.
      */
-    once<TPayload>(eventType: string, listener: (payload: TPayload) => void): void;
-    /**
-     * Register a listener for a specific event type that will be invoked before all other existing listeners.
-     *
-     * @param eventType - The type of event to listen for.
-     * @param listener - The listener function to invoke when the event is emitted.
-     */
-    prependOn<TPayload>(eventType: string, listener: (payload: TPayload) => void): void;
-    /**
-     * Register a listener for a specific event type that will be invoked once before all other existing listeners.
-     *
-     * @param eventType - The type of event to listen for.
-     * @param listener - The listener function to invoke when the event is emitted.
-     */
-    prependOnce<TPayload>(eventType: string, listener: (payload: TPayload) => void): void;
+    once<TEventType extends keyof EventPayloads>(eventType: TEventType, listener: (payload: EventPayloads[TEventType]) => void): void;
+    once<TEventType extends string, TPayload = any>(eventType: TEventType & Exclude<TEventType, keyof EventPayloads>, listener: (payload: TPayload) => void): void;
 }
 
 /**
@@ -1829,22 +1889,24 @@ export declare class GameServer {
 
 }
 
-/** Payloads for events emitted by a GameServer instance. @public */
-export declare namespace GameServerEventPayload {
-    export interface Start {
-        startedAtMs: number;
-    }
-    export interface Stop {
-        stoppedAtMs: number;
-    }
-}
-
-/** Event types a GameServer instance can emit. @public */
-export declare enum GameServerEventType {
+/** Event types a GameServer instance can emit to the global event router. See {@link GameServerEventPayloads} for the payloads. @public */
+export declare enum GameServerEvent {
     START = "GAMESERVER.START",
     STOP = "GAMESERVER.STOP"
 }
 
+/** Event payloads for GameServer emitted events. @public */
+export declare interface GameServerEventPayloads {
+    /** Emitted when the game server starts. */
+    [GameServerEvent.START]: {
+        startedAtMs: number;
+    };
+    /** Emitted when the game server stops. */
+    [GameServerEvent.STOP]: {
+        stoppedAtMs: number;
+    };
+}
+
 /**
  * Represents a light in a world. Lights can be point lights
  * or spotlights.
@@ -1854,6 +1916,11 @@ export declare enum GameServerEventType {
  * variety of configuration options through the {@link LightOptions}
  * constructor argument.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link LightEventPayloads}
+ *
  * @example
  * ```typescript
  * const light = new Light({
@@ -1868,7 +1935,7 @@ export declare enum GameServerEventType {
  *
  * @public
  */
-export declare class Light implements protocol.Serializable {
+export declare class Light extends EventRouter implements protocol.Serializable {
 
 
 
@@ -1987,71 +2054,82 @@ export declare class Light implements protocol.Serializable {
 
 }
 
-/** Payloads for events a Light instance can emit. @public */
-export declare namespace LightEventPayload {
-    export interface Despawn {
+/** Event types a Light instance can emit. See {@link LightEventPayloads} for the payloads. @public */
+export declare enum LightEvent {
+    DESPAWN = "LIGHT.DESPAWN",
+    SET_ANGLE = "LIGHT.SET_ANGLE",
+    SET_ATTACHED_TO_ENTITY = "LIGHT.SET_ATTACHED_TO_ENTITY",
+    SET_COLOR = "LIGHT.SET_COLOR",
+    SET_DISTANCE = "LIGHT.SET_DISTANCE",
+    SET_INTENSITY = "LIGHT.SET_INTENSITY",
+    SET_OFFSET = "LIGHT.SET_OFFSET",
+    SET_PENUMBRA = "LIGHT.SET_PENUMBRA",
+    SET_POSITION = "LIGHT.SET_POSITION",
+    SET_TRACKED_ENTITY = "LIGHT.SET_TRACKED_ENTITY",
+    SET_TRACKED_POSITION = "LIGHT.SET_TRACKED_POSITION",
+    SPAWN = "LIGHT.SPAWN"
+}
+
+/** Event payloads for Light emitted events. @public */
+export declare interface LightEventPayloads {
+    /** Emitted when a light is despawned. */
+    [LightEvent.DESPAWN]: {
         light: Light;
-    }
-    export interface SetAngle {
+    };
+    /** Emitted when the angle of the spotlight is set. */
+    [LightEvent.SET_ANGLE]: {
         light: Light;
         angle: number;
-    }
-    export interface SetAttachedToEntity {
+    };
+    /** Emitted when the light is attached to an entity. */
+    [LightEvent.SET_ATTACHED_TO_ENTITY]: {
         light: Light;
         entity: Entity;
-    }
-    export interface SetColor {
+    };
+    /** Emitted when the color of the light is set. */
+    [LightEvent.SET_COLOR]: {
         light: Light;
         color: RgbColor;
-    }
-    export interface SetDistance {
+    };
+    /** Emitted when the maximum distance the light will illuminate is set. */
+    [LightEvent.SET_DISTANCE]: {
         light: Light;
         distance: number;
-    }
-    export interface SetIntensity {
+    };
+    /** Emitted when the intensity of the light is set. */
+    [LightEvent.SET_INTENSITY]: {
         light: Light;
         intensity: number;
-    }
-    export interface SetOffset {
+    };
+    /** Emitted when the offset of the light is set. */
+    [LightEvent.SET_OFFSET]: {
         light: Light;
         offset: Vector3Like;
-    }
-    export interface SetPenumbra {
+    };
+    /** Emitted when the penumbra of the spotlight is set. */
+    [LightEvent.SET_PENUMBRA]: {
         light: Light;
         penumbra: number;
-    }
-    export interface SetPosition {
+    };
+    /** Emitted when the position of the light is set. */
+    [LightEvent.SET_POSITION]: {
         light: Light;
         position: Vector3Like;
-    }
-    export interface SetTrackedEntity {
+    };
+    /** Emitted when the tracked entity of the spotlight is set. */
+    [LightEvent.SET_TRACKED_ENTITY]: {
         light: Light;
         entity: Entity;
-    }
-    export interface SetTrackedPosition {
+    };
+    /** Emitted when the tracked position of the spotlight is set. */
+    [LightEvent.SET_TRACKED_POSITION]: {
         light: Light;
         position: Vector3Like;
-    }
-    export interface Spawn {
+    };
+    /** Emitted when a light is spawned. */
+    [LightEvent.SPAWN]: {
         light: Light;
-    }
-}
-
-/** Event types a Light instance can emit. @public */
-export declare enum LightEventType {
-    DESPAWN = "LIGHT.DESPAWN",
-    SET_ANGLE = "LIGHT.SET_ANGLE",
-    SET_ATTACHED_TO_ENTITY = "LIGHT.SET_ATTACHED_TO_ENTITY",
-    SET_COLOR = "LIGHT.SET_COLOR",
-    SET_DISTANCE = "LIGHT.SET_DISTANCE",
-    SET_INTENSITY = "LIGHT.SET_INTENSITY",
-    SET_OFFSET = "LIGHT.SET_OFFSET",
-    SET_PENUMBRA = "LIGHT.SET_PENUMBRA",
-    SET_POSITION = "LIGHT.SET_POSITION",
-    SET_TRACKED_ENTITY = "LIGHT.SET_TRACKED_ENTITY",
-    SET_TRACKED_POSITION = "LIGHT.SET_TRACKED_POSITION",
-    SET_TYPE = "LIGHT.SET_TYPE",
-    SPAWN = "LIGHT.SPAWN"
+    };
 }
 
 /**
@@ -2921,9 +2999,14 @@ export declare type PathfindingOptions = {
  * authenticate with the game server. This is all handled
  * internally.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link PlayerEventPayloads}
+ *
  * @public
  */
-export declare class Player implements protocol.Serializable {
+export declare class Player extends EventRouter implements protocol.Serializable {
     /** The unique HYTOPIA UUID for the player. */
     readonly id: string;
     /** The unique HYTOPIA username for the player. */
@@ -2978,6 +3061,11 @@ export declare class Player implements protocol.Serializable {
  * control the camera of a player. All player objects
  * have a camera, accessible via {@link Player.camera}.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link PlayerCameraEventPayloads}
+ *
  * @example
  * ```typescript
  * player.camera.setMode(PlayerCameraMode.FIRST_PERSON);
@@ -2985,7 +3073,7 @@ export declare class Player implements protocol.Serializable {
  *
  * @public
  */
-export declare class PlayerCamera implements protocol.Serializable {
+export declare class PlayerCamera extends EventRouter implements protocol.Serializable {
     /** The player that the camera belongs to. @readonly */
     readonly player: Player;
 
@@ -3110,77 +3198,90 @@ export declare class PlayerCamera implements protocol.Serializable {
 
 }
 
-/** Payloads for events a PlayerCamera can emit. @public */
-export declare namespace PlayerCameraEventPayload {
-    export interface LookAtEntity {
+/** Event types a PlayerCamera can emit. See {@link PlayerCameraEventPayloads} for the payloads. @public */
+export declare enum PlayerCameraEvent {
+    LOOK_AT_ENTITY = "PLAYER_CAMERA.LOOK_AT_ENTITY",
+    LOOK_AT_POSITION = "PLAYER_CAMERA.LOOK_AT_POSITION",
+    SET_ATTACHED_TO_ENTITY = "PLAYER_CAMERA.SET_ATTACHED_TO_ENTITY",
+    SET_ATTACHED_TO_POSITION = "PLAYER_CAMERA.SET_ATTACHED_TO_POSITION",
+    SET_FILM_OFFSET = "PLAYER_CAMERA.SET_FILM_OFFSET",
+    SET_FORWARD_OFFSET = "PLAYER_CAMERA.SET_FORWARD_OFFSET",
+    SET_FOV = "PLAYER_CAMERA.SET_FOV",
+    SET_MODEL_HIDDEN_NODES = "PLAYER_CAMERA.SET_MODEL_HIDDEN_NODES",
+    SET_MODE = "PLAYER_CAMERA.SET_MODE",
+    SET_OFFSET = "PLAYER_CAMERA.SET_OFFSET",
+    SET_TRACKED_ENTITY = "PLAYER_CAMERA.SET_TRACKED_ENTITY",
+    SET_TRACKED_POSITION = "PLAYER_CAMERA.SET_TRACKED_POSITION",
+    SET_ZOOM = "PLAYER_CAMERA.SET_ZOOM"
+}
+
+/** Event payloads for PlayerCamera emitted events. @public */
+export declare interface PlayerCameraEventPayloads {
+    /** Emitted when the camera looks at an entity. */
+    [PlayerCameraEvent.LOOK_AT_ENTITY]: {
         playerCamera: PlayerCamera;
         entity: Entity;
-    }
-    export interface LookAtPosition {
+    };
+    /** Emitted when the camera looks at a position. */
+    [PlayerCameraEvent.LOOK_AT_POSITION]: {
         playerCamera: PlayerCamera;
         position: Vector3Like;
-    }
-    export interface SetAttachedToEntity {
+    };
+    /** Emitted when the camera is attached to an entity. */
+    [PlayerCameraEvent.SET_ATTACHED_TO_ENTITY]: {
         playerCamera: PlayerCamera;
         entity: Entity;
-    }
-    export interface SetAttachedToPosition {
+    };
+    /** Emitted when the camera is attached to a position. */
+    [PlayerCameraEvent.SET_ATTACHED_TO_POSITION]: {
         playerCamera: PlayerCamera;
         position: Vector3Like;
-    }
-    export interface SetFilmOffset {
+    };
+    /** Emitted when the film offset of the camera is set. */
+    [PlayerCameraEvent.SET_FILM_OFFSET]: {
         playerCamera: PlayerCamera;
         filmOffset: number;
-    }
-    export interface SetForwardOffset {
+    };
+    /** Emitted when the forward offset of the camera is set. */
+    [PlayerCameraEvent.SET_FORWARD_OFFSET]: {
         playerCamera: PlayerCamera;
         forwardOffset: number;
-    }
-    export interface SetFov {
+    };
+    /** Emitted when the field of view of the camera is set. */
+    [PlayerCameraEvent.SET_FOV]: {
         playerCamera: PlayerCamera;
         fov: number;
-    }
-    export interface SetModelHiddenNodes {
+    };
+    /** Emitted when the nodes of the model the camera is attached to are set to be hidden. */
+    [PlayerCameraEvent.SET_MODEL_HIDDEN_NODES]: {
         playerCamera: PlayerCamera;
         modelHiddenNodes: Set<string>;
-    }
-    export interface SetMode {
+    };
+    /** Emitted when the mode of the camera is set. */
+    [PlayerCameraEvent.SET_MODE]: {
         playerCamera: PlayerCamera;
         mode: PlayerCameraMode;
-    }
-    export interface SetOffset {
+    };
+    /** Emitted when the offset of the camera is set. */
+    [PlayerCameraEvent.SET_OFFSET]: {
         playerCamera: PlayerCamera;
         offset: Vector3Like;
-    }
-    export interface SetTrackedEntity {
+    };
+    /** Emitted when the tracked entity of the camera is set. */
+    [PlayerCameraEvent.SET_TRACKED_ENTITY]: {
         playerCamera: PlayerCamera;
         entity: Entity | undefined;
-    }
-    export interface SetTrackedPosition {
+    };
+    /** Emitted when the tracked position of the camera is set. */
+    [PlayerCameraEvent.SET_TRACKED_POSITION]: {
         playerCamera: PlayerCamera;
         position: Vector3Like | undefined;
-    }
-    export interface SetZoom {
+    };
+    /** Emitted when the zoom of the camera is set. */
+    [PlayerCameraEvent.SET_ZOOM]: {
         playerCamera: PlayerCamera;
         zoom: number;
-    }
-}
-
-/** Event types a PlayerCamera can emit. @public */
-export declare enum PlayerCameraEventType {
-    LOOK_AT_ENTITY = "PLAYER_CAMERA.LOOK_AT_ENTITY",
-    LOOK_AT_POSITION = "PLAYER_CAMERA.LOOK_AT_POSITION",
-    SET_ATTACHED_TO_ENTITY = "PLAYER_CAMERA.SET_ATTACHED_TO_ENTITY",
-    SET_ATTACHED_TO_POSITION = "PLAYER_CAMERA.SET_ATTACHED_TO_POSITION",
-    SET_FILM_OFFSET = "PLAYER_CAMERA.SET_FILM_OFFSET",
-    SET_FORWARD_OFFSET = "PLAYER_CAMERA.SET_FORWARD_OFFSET",
-    SET_FOV = "PLAYER_CAMERA.SET_FOV",
-    SET_MODEL_HIDDEN_NODES = "PLAYER_CAMERA.SET_MODEL_HIDDEN_NODES",
-    SET_MODE = "PLAYER_CAMERA.SET_MODE",
-    SET_OFFSET = "PLAYER_CAMERA.SET_OFFSET",
-    SET_TRACKED_ENTITY = "PLAYER_CAMERA.SET_TRACKED_ENTITY",
-    SET_TRACKED_POSITION = "PLAYER_CAMERA.SET_TRACKED_POSITION",
-    SET_ZOOM = "PLAYER_CAMERA.SET_ZOOM"
+    };
 }
 
 /** The mode of the camera. @public */
@@ -3375,33 +3476,37 @@ export declare interface PlayerEntityOptions extends EntityOptions {
     player: Player;
 }
 
-/** Payloads for events a Player can emit. @public */
-export declare namespace PlayerEventPayload {
-    export interface ChatMessageSend {
+/** Event types a Player can emit. See {@link PlayerEventPayloads} for the payloads. @public */
+export declare enum PlayerEvent {
+    CHAT_MESSAGE_SEND = "PLAYER.CHAT_MESSAGE_SEND",
+    JOINED_WORLD = "PLAYER.JOINED_WORLD",
+    LEFT_WORLD = "PLAYER.LEFT_WORLD",
+    REQUEST_SYNC = "PLAYER.REQUEST_SYNC"
+}
+
+/** Event payloads for Player emitted events. @public */
+export declare interface PlayerEventPayloads {
+    /** Emitted when a player sends a chat message. */
+    [PlayerEvent.CHAT_MESSAGE_SEND]: {
         player: Player;
-        message: protocol.ChatMessageSchema;
-    }
-    export interface JoinedWorld {
+        message: string;
+    };
+    /** Emitted when a player joins a world. */
+    [PlayerEvent.JOINED_WORLD]: {
         player: Player;
         world: World;
-    }
-    export interface LeftWorld {
+    };
+    /** Emitted when a player leaves a world. */
+    [PlayerEvent.LEFT_WORLD]: {
         player: Player;
         world: World;
-    }
-    export interface RequestSync {
+    };
+    /** Emitted when a player's client requests a round trip time synchronization. */
+    [PlayerEvent.REQUEST_SYNC]: {
         player: Player;
         receivedAt: number;
         receivedAtMs: number;
-    }
-}
-
-/** Event types a Player can emit. @public */
-export declare enum PlayerEventType {
-    CHAT_MESSAGE_SEND = "PLAYER.CHAT_MESSAGE_SEND",
-    JOINED_WORLD = "PLAYER.JOINED_WORLD",
-    LEFT_WORLD = "PLAYER.LEFT_WORLD",
-    REQUEST_SYNC = "PLAYER.REQUEST_SYNC"
+    };
 }
 
 /** The input state of a Player; keys from SUPPORTED_INPUT_KEYS. @public */
@@ -3415,6 +3520,11 @@ export declare type PlayerInput = Partial<Record<keyof InputSchema, boolean>>;
  * singleton accessible with the static property
  * `PlayerManager.instance`.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link PlayerManagerEventPayloads}
+ *
  * @example
  * ```typescript
  * import { PlayerManager } from 'hytopia';
@@ -3453,6 +3563,18 @@ export declare class PlayerManager {
 
 }
 
+/** Event payloads for PlayerManager emitted events. @public */
+export declare interface PlayerManagerEventPayloads {
+    /** Emitted when a player connects to the server. */
+    [PlayerManagerEvent.PLAYER_CONNECTED]: {
+        player: Player;
+    };
+    /** Emitted when a player disconnects from the server. */
+    [PlayerManagerEvent.PLAYER_DISCONNECTED]: {
+        player: Player;
+    };
+}
+
 /**
  * The UI for a player.
  *
@@ -3461,9 +3583,14 @@ export declare class PlayerManager {
  * sees. UI is controlled by HTML, CSS and JavaScript
  * files you provide in your `assets` folder.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link PlayerUIEventPayloads}
+ *
  * @public
  */
-export declare class PlayerUI {
+export declare class PlayerUI extends EventRouter {
     /** The player that the UI belongs to. @readonly */
     readonly player: Player;
     /**
@@ -3497,27 +3624,30 @@ export declare class PlayerUI {
     sendData(data: object): void;
 }
 
-/** Payloads for events a PlayerUI instance can emit. @public */
-export declare namespace PlayerUIEventPayload {
-    export interface Load {
+/** Event types a PlayerUI can emit. See {@link PlayerUIEventPayloads} for the payloads. @public */
+export declare enum PlayerUIEvent {
+    LOAD = "PLAYER_UI.LOAD",
+    LOCK_POINTER = "PLAYER_UI.LOCK_POINTER",
+    SEND_DATA = "PLAYER_UI.SEND_DATA"
+}
+
+/** Event payloads for PlayerUI emitted events. @public */
+export declare interface PlayerUIEventPayloads {
+    /** Emitted when the player's client UI is loaded. */
+    [PlayerUIEvent.LOAD]: {
         playerUI: PlayerUI;
         htmlUri: string;
-    }
-    export interface LockPointer {
+    };
+    /** Emitted when the player's mouse pointer is locked or unlocked. */
+    [PlayerUIEvent.LOCK_POINTER]: {
         playerUI: PlayerUI;
         lock: boolean;
-    }
-    export interface SendData {
+    };
+    /** Emitted when the player's client UI sends data to the server. */
+    [PlayerUIEvent.SEND_DATA]: {
         playerUI: PlayerUI;
         data: object;
-    }
-}
-
-/** Event types a PlayerUI can emit. @public */
-export declare enum PlayerUIEventType {
-    LOAD = "PLAYER_UI.LOAD",
-    LOCK_POINTER = "PLAYER_UI.LOCK_POINTER",
-    SEND_DATA = "PLAYER_UI.SEND_DATA"
+    };
 }
 
 /**
@@ -3798,7 +3928,7 @@ export declare interface RgbColor {
  *
  * @public
  */
-export declare class RigidBody {
+export declare class RigidBody extends EventRouter {
 
 
 
@@ -4186,6 +4316,11 @@ export declare enum RigidBodyType {
  * They support a variety of configuration options through
  * the {@link SceneUIOptions} constructor argument.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link SceneUIEventPayloads}
+ *
  * @example
  * ```typescript
  * const sceneUI = new SceneUI({
@@ -4197,7 +4332,7 @@ export declare enum RigidBodyType {
  *
  * @public
  */
-export declare class SceneUI implements protocol.Serializable {
+export declare class SceneUI extends EventRouter implements protocol.Serializable {
 
 
 
@@ -4271,6 +4406,54 @@ export declare class SceneUI implements protocol.Serializable {
 
 }
 
+/** Event types a SceneUI instance can emit. See {@link SceneUIEventPayloads} for the payloads. @public */
+export declare enum SceneUIEvent {
+    LOAD = "SCENE_UI.LOAD",
+    SET_ATTACHED_TO_ENTITY = "SCENE_UI.SET_ATTACHED_TO_ENTITY",
+    SET_OFFSET = "SCENE_UI.SET_OFFSET",
+    SET_POSITION = "SCENE_UI.SET_POSITION",
+    SET_STATE = "SCENE_UI.SET_STATE",
+    SET_VIEW_DISTANCE = "SCENE_UI.SET_VIEW_DISTANCE",
+    UNLOAD = "SCENE_UI.UNLOAD"
+}
+
+/** Event payloads for SceneUI emitted events. @public */
+export declare interface SceneUIEventPayloads {
+    /** Emitted when a SceneUI is loaded into the world. */
+    [SceneUIEvent.LOAD]: {
+        sceneUI: SceneUI;
+    };
+    /** Emitted when a SceneUI is attached to an entity. */
+    [SceneUIEvent.SET_ATTACHED_TO_ENTITY]: {
+        sceneUI: SceneUI;
+        entity: Entity;
+    };
+    /** Emitted when the offset of a SceneUI is set. */
+    [SceneUIEvent.SET_OFFSET]: {
+        sceneUI: SceneUI;
+        offset: Vector3Like;
+    };
+    /** Emitted when the position of a SceneUI is set. */
+    [SceneUIEvent.SET_POSITION]: {
+        sceneUI: SceneUI;
+        position: Vector3Like;
+    };
+    /** Emitted when the state of a SceneUI is set. */
+    [SceneUIEvent.SET_STATE]: {
+        sceneUI: SceneUI;
+        state: object;
+    };
+    /** Emitted when the view distance of a SceneUI is set. */
+    [SceneUIEvent.SET_VIEW_DISTANCE]: {
+        sceneUI: SceneUI;
+        viewDistance: number;
+    };
+    /** Emitted when a SceneUI is unloaded from the world. */
+    [SceneUIEvent.UNLOAD]: {
+        sceneUI: SceneUI;
+    };
+}
+
 /**
  * Manages SceneUI instances in a world.
  *
@@ -4422,9 +4605,14 @@ export declare class SimpleEntityController extends BaseEntityController {
  * of the world. Most methods are not often used directly, but are
  * provided for advanced usage.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link SimulationEventPayloads}
+ *
  * @public
  */
-export declare class Simulation {
+export declare class Simulation extends EventRouter {
 
 
 
@@ -4497,6 +4685,42 @@ export declare class Simulation {
 
 
 
+}
+
+/** Event types a Simulation instance can emit. See {@link SimulationEventPayloads} for the payloads. @public */
+export declare enum SimulationEvent {
+    STEP_START = "SIMULATION.STEP_START",
+    STEP_END = "SIMULATION.STEP_END",
+    DEBUG_RAYCAST = "SIMULATION.DEBUG_RAYCAST",
+    DEBUG_RENDER = "SIMULATION.DEBUG_RENDER"
+}
+
+/** Event payloads for Simulation emitted events. @public */
+export declare interface SimulationEventPayloads {
+    /** Emitted when the simulation step starts. */
+    [SimulationEvent.STEP_START]: {
+        simulation: Simulation;
+        tickDeltaMs: number;
+    };
+    /** Emitted when the simulation step ends. */
+    [SimulationEvent.STEP_END]: {
+        simulation: Simulation;
+        stepDurationMs: number;
+    };
+    /** Emitted when a debug raycast is performed. */
+    [SimulationEvent.DEBUG_RAYCAST]: {
+        simulation: Simulation;
+        origin: Vector3Like;
+        direction: Vector3Like;
+        length: number;
+        hit: boolean;
+    };
+    /** Emitted when the simulation debug rendering is enabled. */
+    [SimulationEvent.DEBUG_RENDER]: {
+        simulation: Simulation;
+        vertices: Float32Array;
+        colors: Float32Array;
+    };
 }
 
 /** A 3x3 symmetric positive-definite matrix for spatial dynamics. @public */
@@ -5071,6 +5295,11 @@ export declare type WaypointMoveSkippedCallback = (waypoint: Vector3Like, waypoi
  * automatically created default world is all you need, but
  * this flexibility is available for more complex games.
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link WorldEventPayloads}
+ *
  * @example
  * ```typescript
  * const world = new World({
@@ -5082,18 +5311,7 @@ export declare type WaypointMoveSkippedCallback = (waypoint: Vector3Like, waypoi
  *
  * @public
  */
-export declare class World implements protocol.Serializable {
-    /**
-     * A function that is called when a player joins the world.
-     * @param player - The player that joined the world.
-     */
-    onPlayerJoin?: (player: Player) => void;
-    /**
-     * A function that is called when a player leaves the world.
-     * @param player - The player that left the world.
-     */
-    onPlayerLeave?: (player: Player) => void;
-
+export declare class World extends EventRouter implements protocol.Serializable {
 
 
 
@@ -5142,8 +5360,6 @@ export declare class World implements protocol.Serializable {
     get chunkLattice(): ChunkLattice;
     /** The entity manager for the world. */
     get entityManager(): EntityManager;
-    /** The event router for the world. */
-    get eventRouter(): EventRouter;
     /** The light manager for the world. */
     get lightManager(): LightManager;
     /** The world loop for the world. */
@@ -5194,6 +5410,56 @@ export declare class World implements protocol.Serializable {
 
 }
 
+/** Event types a World instance can emit. See {@link WorldEventPayloads} for the payloads. @public */
+export declare enum WorldEvent {
+    SET_AMBIENT_LIGHT_COLOR = "WORLD.SET_AMBIENT_LIGHT_COLOR",
+    SET_AMBIENT_LIGHT_INTENSITY = "WORLD.SET_AMBIENT_LIGHT_INTENSITY",
+    SET_DIRECTIONAL_LIGHT_COLOR = "WORLD.SET_DIRECTIONAL_LIGHT_COLOR",
+    SET_DIRECTIONAL_LIGHT_INTENSITY = "WORLD.SET_DIRECTIONAL_LIGHT_INTENSITY",
+    SET_DIRECTIONAL_LIGHT_POSITION = "WORLD.SET_DIRECTIONAL_LIGHT_POSITION",
+    START = "WORLD.START",
+    STOP = "WORLD.STOP"
+}
+
+/** Event payloads for World emitted events. @public */
+export declare interface WorldEventPayloads {
+    /** Emitted when the color of the world's ambient light is set. */
+    [WorldEvent.SET_AMBIENT_LIGHT_COLOR]: {
+        world: World;
+        color: RgbColor;
+    };
+    /** Emitted when the intensity of the world's ambient light is set. */
+    [WorldEvent.SET_AMBIENT_LIGHT_INTENSITY]: {
+        world: World;
+        intensity: number;
+    };
+    /** Emitted when the color of the world's directional light is set. */
+    [WorldEvent.SET_DIRECTIONAL_LIGHT_COLOR]: {
+        world: World;
+        color: RgbColor;
+    };
+    /** Emitted when the intensity of the world's directional light is set. */
+    [WorldEvent.SET_DIRECTIONAL_LIGHT_INTENSITY]: {
+        world: World;
+        intensity: number;
+    };
+    /** Emitted when the position of the world's directional light is set. */
+    [WorldEvent.SET_DIRECTIONAL_LIGHT_POSITION]: {
+        world: World;
+        position: Vector3Like;
+    };
+    /** Emitted when the world starts. */
+    [WorldEvent.START]: {
+        world: World;
+        startedAtMs: number;
+    };
+    /** Emitted when the world stops. */
+    [WorldEvent.STOP]: {
+        world: World;
+        stoppedAtMs: number;
+    };
+}
+
 /**
  * Manages the tick loop for a world.
  *
@@ -5213,9 +5479,14 @@ export declare class World implements protocol.Serializable {
  *
  * 5. Synchronize network packets with player clients
  *
+ * <h2>Events</h2>
+ *
+ * This class is an EventRouter, and instances of it emit
+ * events with payloads listed under {@link WorldLoopEventPayloads}
+ *
  * @public
  */
-export declare class WorldLoop {
+export declare class WorldLoop extends EventRouter {
 
 
 
@@ -5234,35 +5505,40 @@ export declare class WorldLoop {
 
 }
 
-/** Payloads for events emitted by a WorldLoop instance. @public */
-export declare namespace WorldLoopEventPayload {
-    export interface Start {
+/** Event types a WorldLoop instance can emit. See {@link WorldLoopEventPayloads} for the payloads. @public */
+export declare enum WorldLoopEvent {
+    START = "WORLD_LOOP.START",
+    STOP = "WORLD_LOOP.STOP",
+    TICK_START = "WORLD_LOOP.TICK_START",
+    TICK_END = "WORLD_LOOP.TICK_END",
+    TICK_ERROR = "WORLD_LOOP.TICK_ERROR"
+}
+
+/** Event payloads for WorldLoop emitted events. @public */
+export declare interface WorldLoopEventPayloads {
+    /** Emitted when the world loop starts. */
+    [WorldLoopEvent.START]: {
         worldLoop: WorldLoop;
-    }
-    export interface Stop {
+    };
+    /** Emitted when the world loop stops. */
+    [WorldLoopEvent.STOP]: {
         worldLoop: WorldLoop;
-    }
-    export interface TickStart {
+    };
+    /** Emitted when the world loop tick starts. */
+    [WorldLoopEvent.TICK_START]: {
         worldLoop: WorldLoop;
         tickDeltaMs: number;
-    }
-    export interface TickEnd {
+    };
+    /** Emitted when the world loop tick ends. */
+    [WorldLoopEvent.TICK_END]: {
         worldLoop: WorldLoop;
         tickDurationMs: number;
-    }
-    export interface TickError {
+    };
+    /** Emitted when an error occurs during a world loop tick. */
+    [WorldLoopEvent.TICK_ERROR]: {
         worldLoop: WorldLoop;
         error: Error;
-    }
-}
-
-/** Event types a WorldLoop instance can emit. @public */
-export declare enum WorldLoopEventType {
-    START = "WORLD_LOOP.START",
-    STOP = "WORLD_LOOP.STOP",
-    TICK_START = "WORLD_LOOP.TICK_START",
-    TICK_END = "WORLD_LOOP.TICK_END",
-    TICK_ERROR = "WORLD_LOOP.TICK_ERROR"
+    };
 }
 
 /** A map representation for a world. @public */