@minecraft/server 2.8.0-rc.1.26.30-preview.21 → 2.9.0-beta.1.26.30-preview.21

package/index.d.ts

@@ -7,7 +7,7 @@
    Copyright (c) Microsoft Corporation.
    ***************************************************************************** */
 /**
- * @preview
+ * @beta
  * @packageDocumentation
  * Contains many types related to manipulating a Minecraft
  * world, including entities, blocks, dimensions, and more.
@@ -16,7 +16,7 @@
  * ```json
  * {
  *   "module_name": "@minecraft/server",
- *   "version": "2.8.0"
+ *   "version": "2.9.0-beta"
  * }
  * ```
  *
@@ -229,6 +229,55 @@ export enum CommandPermissionLevel {
     Owner = 4,
 }
 
+/**
+ * @beta
+ * The Action enum determines how the CompoundBlockVolume
+ * considers the associated CompoundBlockVolumeItem when
+ * performing inside/outside calculations.
+ */
+export enum CompoundBlockVolumeAction {
+    /**
+     * @remarks
+     * The associated BlockVolume is considered a positive space,
+     * and any intersection tests are considered hits
+     *
+     */
+    Add = 0,
+    /**
+     * @remarks
+     * The associated BlockVolume is considered a negative or void
+     * space, and any intersection tests are considered misses.
+     * Using the Subtract action, it is possible to `punch holes`
+     * in block volumes so that any intersection tests may pass
+     * through such spaces
+     *
+     */
+    Subtract = 1,
+}
+
+/**
+ * @beta
+ * An enum describing the relativity of the
+ * CompoundBlockVolumeItem, relative to the parent
+ * CompoundVolume.
+ */
+export enum CompoundBlockVolumePositionRelativity {
+    /**
+     * @remarks
+     * The locations within the associated BlockVolume are relative
+     * to the CompoundBlockVolume to which they were added
+     *
+     */
+    Relative = 0,
+    /**
+     * @remarks
+     * The locations within the associated BlockVolume are in
+     * absolute world space
+     *
+     */
+    Absolute = 1,
+}
+
 /**
  * Reasons that the {@link
  * @minecraft/server.ContainerRulesError} was thrown.
@@ -331,6 +380,13 @@ export enum CustomCommandErrorReason {
      *
      */
     RegistryReadOnly = 'RegistryReadOnly',
+    /**
+     * @beta
+     * @remarks
+     * Non enum type command parameters cannot use enumName.
+     *
+     */
+    UnexpectedEnumName = 'UnexpectedEnumName',
 }
 
 /**
@@ -1068,6 +1124,14 @@ export enum EntityComponentTypes {
      *
      */
     NavigationWalk = 'minecraft:navigation.walk',
+    /**
+     * @beta
+     * @remarks
+     * Adds NPC capabilities to an entity such as custom skin,
+     * name, and dialogue interactions.
+     *
+     */
+    Npc = 'minecraft:npc',
     /**
      * @remarks
      * When present on an entity, this entity is on fire.
@@ -1438,6 +1502,13 @@ export enum EntityHealCause {
      *
      */
     SelfHeal = 'SelfHeal',
+    /**
+     * @beta
+     * @remarks
+     * Healing caused when Totem of Undying is activated.
+     *
+     */
+    TotemOfUndying = 'TotemOfUndying',
 }
 
 /**
@@ -1545,6 +1616,14 @@ export enum EntitySwingSource {
  * and mainhand slots.
  */
 export enum EquipmentSlot {
+    /**
+     * @beta
+     * @remarks
+     * The body slot. This slot is used to hold armor for
+     * non-humanoid mobs.
+     *
+     */
+    Body = 'Body',
     /**
      * @remarks
      * The chest slot. This slot is used to hold items such as
@@ -1814,6 +1893,14 @@ export enum GameRule {
      *
      */
     PlayersSleepingPercentage = 'playersSleepingPercentage',
+    /**
+     * @beta
+     * @remarks
+     * Controls which player waypoints are automatically added to
+     * the players locator bar.
+     *
+     */
+    PlayerWaypoints = 'playerWaypoints',
     /**
      * @remarks
      * Controls whether projectiles (entities with a projectile
@@ -2258,6 +2345,34 @@ export enum LiquidType {
     Water = 'Water',
 }
 
+/**
+ * @beta
+ * Enum representing the different reasons why a locator bar
+ * operation may fail.
+ */
+export enum LocatorBarErrorReason {
+    /**
+     * @remarks
+     * The waypoint already exists in the locator bar and cannot be
+     * added again.
+     *
+     */
+    WaypointAlreadyExists = 'WaypointAlreadyExists',
+    /**
+     * @remarks
+     * The maximum number of waypoints has been reached and no more
+     * can be added.
+     *
+     */
+    WaypointLimitExceeded = 'WaypointLimitExceeded',
+    /**
+     * @remarks
+     * The specified waypoint does not exist in the locator bar.
+     *
+     */
+    WaypointNotFound = 'WaypointNotFound',
+}
+
 /**
  * Describes the memory of a device.
  */
@@ -2576,6 +2691,14 @@ export enum PlayerPermissionLevel {
     Custom = 3,
 }
 
+/**
+ * @beta
+ */
+export enum PlayerWaypointsMode {
+    Everyone = 'Everyone',
+    Off = 'Off',
+}
+
 /**
  * Contains objectives and participants for the scoreboard.
  */
@@ -2902,6 +3025,61 @@ export enum TintMethod {
     Water = 'Water',
 }
 
+/**
+ * @beta
+ * An enumeration with the reason that a watchdog is deciding
+ * to terminate execution of a behavior packs' script.
+ */
+export enum WatchdogTerminateReason {
+    /**
+     * @remarks
+     * Script runtime for a behavior pack is terminated due to
+     * non-responsiveness from script (a hang or infinite loop).
+     *
+     */
+    Hang = 'Hang',
+    /**
+     * @remarks
+     * Script runtime for a behavior pack is terminated due to a
+     * stack overflow (a long, and potentially infinite) chain of
+     * function calls.
+     *
+     */
+    StackOverflow = 'StackOverflow',
+}
+
+/**
+ * @beta
+ * Enum representing different texture icons that can be
+ * displayed for waypoints on the locator bar.
+ */
+export enum WaypointTexture {
+    /**
+     * @remarks
+     * Circle waypoint icon texture.
+     *
+     */
+    Circle = 'minecraft:circle',
+    /**
+     * @remarks
+     * Small square waypoint icon texture.
+     *
+     */
+    SmallSquare = 'minecraft:small_square',
+    /**
+     * @remarks
+     * Small star waypoint icon texture.
+     *
+     */
+    SmallStar = 'minecraft:small_star',
+    /**
+     * @remarks
+     * Square waypoint icon texture.
+     *
+     */
+    Square = 'minecraft:square',
+}
+
 /**
  * Used to specify the type of weather condition within the
  * world.
@@ -3055,6 +3233,7 @@ export type EntityComponentTypeMap = {
     'minecraft:navigation.generic': EntityNavigationGenericComponent;
     'minecraft:navigation.hover': EntityNavigationHoverComponent;
     'minecraft:navigation.walk': EntityNavigationWalkComponent;
+    'minecraft:npc': EntityNpcComponent;
     'minecraft:onfire': EntityOnFireComponent;
     'minecraft:player.exhaustion': EntityExhaustionComponent;
     'minecraft:player.hunger': EntityHungerComponent;
@@ -3088,6 +3267,7 @@ export type EntityComponentTypeMap = {
     'navigation.generic': EntityNavigationGenericComponent;
     'navigation.hover': EntityNavigationHoverComponent;
     'navigation.walk': EntityNavigationWalkComponent;
+    npc: EntityNpcComponent;
     onfire: EntityOnFireComponent;
     'player.exhaustion': EntityExhaustionComponent;
     'player.hunger': EntityHungerComponent;
@@ -3107,6 +3287,15 @@ export type EntityComponentTypeMap = {
     wants_jockey: EntityWantsJockeyComponent;
 };
 
+/**
+ * @beta
+ */
+export type EntityIdentifierType<T> = [T] extends [never]
+    ? VanillaEntityIdentifier
+    : T extends string
+      ? VanillaEntityIdentifier | T
+      : never;
+
 export type ItemComponentReturnType<T extends string> = T extends keyof ItemComponentTypeMap
     ? ItemComponentTypeMap[T]
     : ItemCustomComponentInstance;
@@ -3132,6 +3321,15 @@ export type ItemComponentTypeMap = {
     potion: ItemPotionComponent;
 };
 
+/**
+ * @beta
+ */
+export type VanillaEntityIdentifier =
+    | EntityType
+    | minecraftvanilladata.MinecraftEntityTypes
+    | `${minecraftvanilladata.MinecraftEntityTypes}`
+    | `${minecraftvanilladata.MinecraftEntityTypes}<${string}>`;
+
 /**
  * Handle to an aim-assist category that exists in the
  * world.aimAssist registry.
@@ -3289,7 +3487,9 @@ export class AimAssistCategorySettings {
      * A record mapping block Ids to their priority settings.
      * Larger numbers have greater priority.
      */
-    setBlockPriorities(blockPriorities: Record<string, number>): void;
+    setBlockPriorities(
+        blockPriorities: Record<keyof typeof minecraftvanilladata.MinecraftBlockTypes | string, number>,
+    ): void;
     /**
      * @remarks
      * Sets the priority settings used for block targeting.
@@ -3308,7 +3508,9 @@ export class AimAssistCategorySettings {
      * A record mapping entity Ids to their priority settings.
      * Larger numbers have greater priority.
      */
-    setEntityPriorities(entityPriorities: Record<string, number>): void;
+    setEntityPriorities(
+        entityPriorities: Record<keyof typeof minecraftvanilladata.MinecraftEntityTypes | string, number>,
+    ): void;
     /**
      * @remarks
      * Sets the priority settings used for entity targeting.
@@ -3507,8 +3709,10 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
+     * @param targets
+     * An array of block tags.
      */
-    setExcludedBlockTagTargets(blockTagTargets?: string[]): void;
+    setExcludedBlockTagTargets(targets?: string[]): void;
     /**
      * @remarks
      * Sets the list of block Ids to exclude from aim assist
@@ -3516,8 +3720,10 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
+     * @param targets
+     * An array of block Ids.
      */
-    setExcludedBlockTargets(blockTargets?: string[]): void;
+    setExcludedBlockTargets(targets?: (keyof typeof minecraftvanilladata.MinecraftBlockTypes | string)[]): void;
     /**
      * @remarks
      * Sets the list of entity Ids to exclude from aim assist
@@ -3525,8 +3731,10 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
+     * @param targets
+     * An array of entity Ids.
      */
-    setExcludedEntityTargets(entityTargets?: string[]): void;
+    setExcludedEntityTargets(targets?: (keyof typeof minecraftvanilladata.MinecraftEntityTypes | string)[]): void;
     /**
      * @remarks
      * Sets the list of entity type families to exclude from aim
@@ -3534,8 +3742,10 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
+     * @param targets
+     * An array of entity type families.
      */
-    setExcludedEntityTypeFamilyTargets(entityTypeFamilyTargets?: string[]): void;
+    setExcludedEntityTypeFamilyTargets(targets?: string[]): void;
     /**
      * @remarks
      * Sets the per-item aim-assist category Ids.
@@ -3546,7 +3756,7 @@ export class AimAssistPresetSettings {
      * A record mapping item Ids to aim-assist category Ids.
      * Category Ids must have a namespace.
      */
-    setItemSettings(itemSettings: Record<string, string>): void;
+    setItemSettings(itemSettings: Record<keyof typeof minecraftvanilladata.MinecraftItemTypes | string, string>): void;
     /**
      * @remarks
      * Sets the list of item Ids that will target liquid blocks
@@ -3557,7 +3767,7 @@ export class AimAssistPresetSettings {
      * @param items
      * An array of item Ids.
      */
-    setLiquidTargetingItems(items?: string[]): void;
+    setLiquidTargetingItems(items?: (keyof typeof minecraftvanilladata.MinecraftItemTypes | string)[]): void;
 }
 
 /**
@@ -3663,6 +3873,28 @@ export class AimAssistRegistry {
     getPresets(): AimAssistPreset[];
 }
 
+/**
+ * @beta
+ * Describes a single banner pattern, which includes a colour
+ * and a pattern type.
+ */
+export class BannerPattern {
+    private constructor();
+    /**
+     * @remarks
+     * The color to apply to this banner pattern.
+     *
+     */
+    readonly color: string;
+    /**
+     * @remarks
+     * The pattern type (e.g. gradient, chevron, cross, etc.) to
+     * apply to the banner.
+     *
+     */
+    readonly pattern: string;
+}
+
 /**
  * Describes a type of biome.
  */
@@ -3759,6 +3991,20 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     readonly isLiquid: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Returns true if this block is solid and impassible - (e.g.,
+     * a cobblestone block and a diamond block are solid, while a
+     * ladder block and a fence block are not).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly isSolid: boolean;
     /**
      * @remarks
      * Returns true if this reference to a block is still valid
@@ -3924,6 +4170,30 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     canContainLiquid(liquidType: LiquidType): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Checks to see whether it is valid to place the specified
+     * block type or block permutation, on a specified face on this
+     * block.
+     *
+     * @param blockToPlace
+     * Block type or block permutation to check placement for.
+     * @param faceToPlaceOn
+     * Optional specific face of this block to check placement
+     * against.
+     * @returns
+     * Returns `true` if the block type or permutation can be
+     * placed on this block, else `false`.
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    canPlace(blockToPlace: BlockPermutation | BlockType | string, faceToPlaceOn?: Direction): boolean;
     /**
      * @remarks
      * Returns the {@link Vector3} of the center of this block on
@@ -4020,6 +4290,29 @@ export class Block {
      * {@link LocationInUnloadedChunkError}
      */
     getLightLevel(): number;
+    /**
+     * @beta
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getMapColor(): RGBA;
+    /**
+     * @beta
+     * @remarks
+     * Returns array of all loaded block parts if this block has
+     * the 'minecraft:multi_block' trait. If it does not have the
+     * trait returns undefined
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getParts(): Block[] | undefined;
     /**
      * @remarks
      * Returns the net redstone power of this block.
@@ -4287,6 +4580,27 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     south(steps?: number): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Tries to set the block in the dimension to the state of the
+     * permutation by first checking if the placement is valid.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param permutation
+     * Permutation that contains a set of property states for the
+     * Block.
+     * @returns
+     * Returns `true` if the block permutation data was
+     * successfully set, else `false`.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    trySetPermutation(permutation: BlockPermutation): boolean;
     /**
      * @remarks
      * Returns the {@link Block} to the west of this block
@@ -4304,6 +4618,137 @@ export class Block {
     west(steps?: number): Block | undefined;
 }
 
+/**
+ * @beta
+ * Bounding Box Utils is a utility class that provides a number
+ * of useful functions for the creation and utility of {@link
+ * BlockBoundingBox} objects
+ */
+export class BlockBoundingBoxUtils {
+    private constructor();
+    /**
+     * @remarks
+     * Create a validated instance of a {@link BlockBoundingBox}
+     * where the min and max components are guaranteed to be (min
+     * <= max)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param min
+     * A corner world location
+     * @param max
+     * A corner world location diametrically opposite
+     */
+    static createValid(min: Vector3, max: Vector3): BlockBoundingBox;
+    /**
+     * @remarks
+     * Expand a {@link BlockBoundingBox} by a given amount along
+     * each axis.
+     * Sizes can be negative to perform contraction.
+     * Note: corners can be inverted if the contraction size is
+     * greater than the span, but the min/max relationship will
+     * remain correct
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * Return a new {@link BlockBoundingBox} object representing
+     * the changes
+     */
+    static dilate(box: BlockBoundingBox, size: Vector3): BlockBoundingBox;
+    /**
+     * @remarks
+     * Check if two {@link BlockBoundingBox} objects are identical
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static equals(box: BlockBoundingBox, other: BlockBoundingBox): boolean;
+    /**
+     * @remarks
+     * Expand the initial box object bounds to include the 2nd box
+     * argument.  The resultant {@link BlockBoundingBox} object
+     * will be a BlockBoundingBox which exactly encompasses the two
+     * boxes.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * A new {@link BlockBoundingBox} instance representing the
+     * smallest possible bounding box which can encompass both
+     */
+    static expand(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox;
+    /**
+     * @remarks
+     * Calculate the center block of a given {@link
+     * BlockBoundingBox} object.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * Note that {@link BlockBoundingBox} objects represent whole
+     * blocks, so the center of boxes which have odd numbered
+     * bounds are not mathematically centered...
+     * i.e. a BlockBoundingBox( 0,0,0 -> 3,3,3 )  would have a
+     * center of (1,1,1)  (not (1.5, 1.5, 1.5) as expected)
+     */
+    static getCenter(box: BlockBoundingBox): Vector3;
+    /**
+     * @remarks
+     * Calculate the BlockBoundingBox which represents the union
+     * area of two intersecting BlockBoundingBoxes
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static getIntersection(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox | undefined;
+    /**
+     * @remarks
+     * Get the Span of each of the BlockBoundingBox Axis components
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static getSpan(box: BlockBoundingBox): Vector3;
+    /**
+     * @remarks
+     * Check to see if two BlockBoundingBox objects intersect
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static intersects(box: BlockBoundingBox, other: BlockBoundingBox): boolean;
+    /**
+     * @remarks
+     * Check to see if a given coordinate is inside a
+     * BlockBoundingBox
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static isInside(box: BlockBoundingBox, pos: Vector3): boolean;
+    /**
+     * @remarks
+     * Check to see if a BlockBoundingBox is valid (i.e. (min <=
+     * max))
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    static isValid(box: BlockBoundingBox): boolean;
+    /**
+     * @remarks
+     * Move a BlockBoundingBox by a given amount
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * Return a new BlockBoundingBox object which represents the
+     * change
+     */
+    static translate(box: BlockBoundingBox, delta: Vector3): BlockBoundingBox;
+}
+
 /**
  * Base type for components associated with blocks.
  */
@@ -4347,22 +4792,38 @@ export class BlockComponentBlockBreakEvent extends BlockEvent {
 }
 
 /**
- * Contains information regarding an event sent by an entity to
- * this block in the world.
+ * @beta
+ * Contains information regarding a specific block permutation
+ * that was changed from a previous permutation.
  */
 // @ts-ignore Class inheritance allowed for native defined classes
-export class BlockComponentEntityEvent extends BlockEvent {
+export class BlockComponentBlockStateChangeEvent extends BlockEvent {
     private constructor();
     /**
      * @remarks
-     * Returns permutation information about the block receiving
-     * the event.
+     * The previous BlockPermutation.
      *
      */
-    readonly blockPermutation: BlockPermutation;
-    /**
-     * @remarks
-     * The entity that sent the event.
+    readonly previousPermutation: BlockPermutation;
+}
+
+/**
+ * Contains information regarding an event sent by an entity to
+ * this block in the world.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentEntityEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Returns permutation information about the block receiving
+     * the event.
+     *
+     */
+    readonly blockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * The entity that sent the event.
      *
      */
     readonly entitySource: Entity;
@@ -4511,6 +4972,13 @@ export class BlockComponentRandomTickEvent extends BlockEvent {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class BlockComponentRedstoneUpdateEvent extends BlockEvent {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The first update event for the redstone component.
+     *
+     */
+    readonly firstUpdate: boolean;
     /**
      * @remarks
      * The redstone signal strength passing through this block. It
@@ -4915,6 +5383,18 @@ export class BlockLocationIterator implements Iterable<Vector3> {
      *
      */
     [Symbol.iterator](): Iterator<Vector3>;
+    /**
+     * @beta
+     * @remarks
+     * Checks if the underlining block volume has been invalidated.
+     * Will return false if the block volume was modified between
+     * creating the iterator and iterating it, and true otherwise.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    isValid(): boolean;
     /**
      * @remarks
      * This function can't be called in restricted-execution mode.
@@ -5286,6 +5766,20 @@ export class BlockPrecipitationInteractionsComponent extends BlockComponent {
      * {@link LocationOutOfWorldBoundariesError}
      */
     accumulatesSnow(): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Returns `true` if this block can have snow within it, like a
+     * flower submerged in snow. Returns `false` if this block
+     * cannot have snow within it.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    isSnowLoggable(): boolean;
     /**
      * @remarks
      * Returns `true` if rain will not go through the block.
@@ -5817,6 +6311,15 @@ export class BlockVolumeBase {
      *
      */
     getBlockLocationIterator(): BlockLocationIterator;
+    /**
+     * @beta
+     * @remarks
+     * Return a {@link BlockBoundingBox} object which represents
+     * the validated min and max coordinates of the volume
+     *
+     * @throws This function can throw errors.
+     */
+    getBoundingBox(): BlockBoundingBox;
     /**
      * @remarks
      * Return the capacity (volume) of the BlockVolume (W*D*H)
@@ -6047,6 +6550,23 @@ export class Camera {
             | CameraSetRotOptions
             | CameraTargetOptions,
     ): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the current active camera with easing.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param cameraPreset
+     * Identifier of a camera preset file defined within JSON.
+     * @param easeOptions
+     * Options to ease the camera from the previous camera to the
+     * current one.
+     * @throws
+     * Throws when easing to minecraft:first_person presets
+     * currently without the experimental cameras toggle enabled.
+     */
+    setCameraWithEase(cameraPreset: string, easeOptions: EaseOptions): void;
     /**
      * @remarks
      * Sets the current active camera for the specified player and
@@ -6086,6 +6606,164 @@ export class CatmullRomSpline {
     controlPoints: Vector3[];
 }
 
+/**
+ * @beta
+ * An event that fires as players enter chat messages.
+ */
+export class ChatSendAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Message that is being broadcast.
+     *
+     */
+    readonly message: string;
+    /**
+     * @remarks
+     * Player that sent the chat message.
+     *
+     */
+    readonly sender: Player;
+    /**
+     * @remarks
+     * Optional list of players that will receive this message. If
+     * defined, this message is directly targeted to one or more
+     * players (i.e., is not broadcast.)
+     *
+     */
+    readonly targets?: Player[];
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to chat messages being
+ * sent.
+ */
+export class ChatSendAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when new chat messages
+     * are sent.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: ChatSendAfterEvent) => void): (arg0: ChatSendAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when new chat messages
+     * are sent.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: ChatSendAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * An event that fires as players enter chat messages.
+ */
+export class ChatSendBeforeEvent {
+    private constructor();
+    /**
+     * @remarks
+     * If set to true in a beforeChat event handler, this message
+     * is not broadcast out.
+     *
+     */
+    cancel: boolean;
+    /**
+     * @remarks
+     * Message that is being broadcast.
+     *
+     */
+    readonly message: string;
+    /**
+     * @remarks
+     * Player that sent the chat message.
+     *
+     */
+    readonly sender: Player;
+    /**
+     * @remarks
+     * Optional list of players that will receive this message. If
+     * defined, this message is directly targeted to one or more
+     * players (i.e., is not broadcast.)
+     *
+     */
+    readonly targets?: Player[];
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to an event that fires
+ * before chat messages are sent.
+ * @example customCommand.ts
+ * ```typescript
+ * import { world, DimensionLocation } from '@minecraft/server';
+ *
+ * function customCommand(targetLocation: DimensionLocation) {
+ *   const chatCallback = world.beforeEvents.chatSend.subscribe(eventData => {
+ *     if (eventData.message.includes('cancel')) {
+ *       // Cancel event if the message contains "cancel"
+ *       eventData.cancel = true;
+ *     } else {
+ *       const args = eventData.message.split(' ');
+ *
+ *       if (args.length > 0) {
+ *         switch (args[0].toLowerCase()) {
+ *           case 'echo':
+ *             // Send a modified version of chat message
+ *             world.sendMessage(`Echo '${eventData.message.substring(4).trim()}'`);
+ *             break;
+ *           case 'help':
+ *             world.sendMessage(`Available commands: echo <message>`);
+ *             break;
+ *         }
+ *       }
+ *     }
+ *   });
+ * }
+ * ```
+ */
+export class ChatSendBeforeEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called before new chat messages
+     * are sent.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     * @returns
+     * Closure that is called with restricted-execution privilege.
+     */
+    subscribe(callback: (arg0: ChatSendBeforeEvent) => void): (arg0: ChatSendBeforeEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called before new chat
+     * messages are sent.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     */
+    unsubscribe(callback: (arg0: ChatSendBeforeEvent) => void): void;
+}
+
 /**
  * Contains the device information for a client instance.
  */
@@ -6159,125 +6837,377 @@ export class Component {
 }
 
 /**
- * Represents a container that can hold sets of items. Used
- * with entities such as Players, Chest Minecarts, Llamas, and
- * more.
- * @example containers.ts
- * ```typescript
- * import { ItemStack, EntityInventoryComponent, BlockInventoryComponent, DimensionLocation } from '@minecraft/server';
- * import { MinecraftBlockTypes, MinecraftItemTypes, MinecraftEntityTypes } from '@minecraft/vanilla-data';
- *
- * function containers(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
- *   const xLocation = targetLocation; // left chest location
- *   const xPlusTwoLocation = { x: targetLocation.x + 2, y: targetLocation.y, z: targetLocation.z }; // right chest
- *
- *   const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
- *     x: targetLocation.x + 4,
- *     y: targetLocation.y,
- *     z: targetLocation.z,
- *   });
- *
- *   const xChestBlock = targetLocation.dimension.getBlock(xLocation);
- *   const xPlusTwoChestBlock = targetLocation.dimension.getBlock(xPlusTwoLocation);
- *
- *   if (!xChestBlock || !xPlusTwoChestBlock) {
- *     log('Could not retrieve chest blocks.');
- *     return;
- *   }
- *
- *   xChestBlock.setType(MinecraftBlockTypes.Chest);
- *   xPlusTwoChestBlock.setType(MinecraftBlockTypes.Chest);
- *
- *   const xPlusTwoChestInventoryComp = xPlusTwoChestBlock.getComponent('inventory') as BlockInventoryComponent;
- *   const xChestInventoryComponent = xChestBlock.getComponent('inventory') as BlockInventoryComponent;
- *   const chestCartInventoryComp = chestCart.getComponent('inventory') as EntityInventoryComponent;
- *
- *   const xPlusTwoChestContainer = xPlusTwoChestInventoryComp.container;
- *   const xChestContainer = xChestInventoryComponent.container;
- *   const chestCartContainer = chestCartInventoryComp.container;
- *
- *   if (!xPlusTwoChestContainer || !xChestContainer || !chestCartContainer) {
- *     log('Could not retrieve chest containers.');
- *     return;
- *   }
- *
- *   xPlusTwoChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Apple, 10));
- *   if (xPlusTwoChestContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
- *     log('Expected apple in x+2 container slot index 0', -1);
- *   }
- *
- *   xPlusTwoChestContainer.setItem(1, new ItemStack(MinecraftItemTypes.Emerald, 10));
- *   if (xPlusTwoChestContainer.getItem(1)?.typeId !== MinecraftItemTypes.Emerald) {
- *     log('Expected emerald in x+2 container slot index 1', -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.size !== 27) {
- *     log('Unexpected size: ' + xPlusTwoChestContainer.size, -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.emptySlotsCount !== 25) {
- *     log('Unexpected emptySlotsCount: ' + xPlusTwoChestContainer.emptySlotsCount, -1);
- *   }
- *
- *   xChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Cake, 10));
- *
- *   xPlusTwoChestContainer.transferItem(0, chestCartContainer); // transfer the apple from the xPlusTwo chest to a chest cart
- *   xPlusTwoChestContainer.swapItems(1, 0, xChestContainer); // swap the cake from x and the emerald from xPlusTwo
- *
- *   if (chestCartContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
- *     log('Expected apple in minecraft chest container slot index 0', -1);
- *   }
- *
- *   if (xChestContainer.getItem(0)?.typeId === MinecraftItemTypes.Emerald) {
- *     log('Expected emerald in x container slot index 0', -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.getItem(1)?.typeId === MinecraftItemTypes.Cake) {
- *     log('Expected cake in x+2 container slot index 1', -1);
- *   }
- * }
- * ```
+ * @beta
+ * The Compound Block Volume is a collection of individual
+ * block volume definitions which, as a collection, define a
+ * larger volume of (sometimes non-contiguous) irregular
+ * shapes.
+ * This class is loosely based on the concept of CSG
+ * (Computational Solid Geometry) and allows a user to create
+ * complex volumes by building a stack of volumes and voids to
+ * make a larger single volume.
+ * For example - normally a creator would create a hollow cube
+ * by creating 6 "wall" surfaces for each face.
+ * With a Compound Block Volume, a creator can define a hollow
+ * cube by creating a single outer solid cube, and then
+ * defining a further single 'void' cube inside the larger one.
+ * Similarly, the Compound Block Volume can represent irregular
+ * shaped volumes (e.g. a tree consists of a trunk and lots of
+ * leaf cubes which are not necessarily contiguously placed).
+ * Each of the volumes added to the CompoundBlockVolume are (by
+ * default) relative to the origin set (either at construction
+ * or via one of the set functions).
+ * However, it is also possible to push volumes to the compound
+ * collection which are absolute in nature and are not affected
+ * by origin changes.
  */
-export class Container {
-    private constructor();
+export class CompoundBlockVolume {
     /**
      * @remarks
-     * If these rules are defined other container operations will
-     * throw if they cause these rules to be invalidated. For
-     * example, adding a shulker box to a vanilla bundle.
+     * Return the 'capacity' of the bounding rectangle which
+     * represents the collection of volumes in the stack
      *
      */
-    readonly containerRules?: ContainerRules;
+    readonly capacity: number;
+    readonly items: CompoundBlockVolumeItem[];
+    readonly itemsAbsolute: CompoundBlockVolumeItem[];
     /**
      * @remarks
-     * Count of the slots in the container that are empty.
+     * Return the number of volumes (positive and negative) in the
+     * volume stack
      *
-     * @throws
-     * Throws if the container is invalid.
      */
-    readonly emptySlotsCount: number;
+    readonly volumeCount: number;
     /**
      * @remarks
-     * Returns whether a container object (or the entity or block
-     * that this container is associated with) is still available
-     * for use in this context.
+     * Create a CompoundBlockVolume object
      *
+     * @param origin
+     * An optional world space origin on which to center the
+     * compound volume.
+     * If not specified, the origin is set to (0,0,0)
      */
-    readonly isValid: boolean;
+    constructor(origin?: Vector3);
     /**
      * @remarks
-     * The number of slots in this container. For example, a
-     * standard single-block chest has a size of 27. Note, a
-     * player's inventory container contains a total of 36 slots, 9
-     * hotbar slots plus 27 inventory slots.
+     * Clear the contents of the volume stack
+     *
+     * This function can't be called in restricted-execution mode.
      *
-     * @throws
-     * Throws if the container is invalid.
      */
-    readonly size: number;
+    clear(): void;
     /**
      * @remarks
-     * The combined weight of all items in the container.
+     * Fetch a Block Location Iterator for the Compound Block
+     * Volume.  This iterator will allow a creator to iterate
+     * across all of the selected volumes within the larger
+     * bounding area.
+     * Areas of a volume which have been overridden by a
+     * subtractive volume will not be included in the iterator
+     * step.
+     * (i.e. if you push a cube to the stack, and then push a
+     * subtractive volume to the same location, then the iterator
+     * will step over the initial volume because it is considered
+     * negative space)
+     * Note that the Block Locations returned by this iterator are
+     * in absolute world space (irrespective of whether the
+     * compound volume items pushed are absolute or relative)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getBlockLocationIterator(): BlockLocationIterator;
+    /**
+     * @remarks
+     * Get the largest bounding box that represents a container for
+     * all of the volumes on the stack
+     * Note that the bounding box returned is represented in
+     * absolute world space  (irrespective of whether the compound
+     * volume items pushed are absolute or relative)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getBoundingBox(): BlockBoundingBox;
+    /**
+     * @remarks
+     * Get the max block location of the outermost bounding
+     * rectangle which represents the volumes on the stack.
+     * Note that the max location returned is in absolute world
+     * space (irrespective of whether the compound volume items
+     * pushed are absolute or relative)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getMax(): Vector3;
+    /**
+     * @remarks
+     * Get the min block location of the outermost bounding
+     * rectangle which represents the volumes on the stack.
+     * Note that the min location returned is in absolute world
+     * space (irrespective of whether the compound volume items
+     * pushed are absolute or relative)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getMin(): Vector3;
+    /**
+     * @remarks
+     * Fetch the origin in world space of the compound volume
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getOrigin(): Vector3;
+    /**
+     * @remarks
+     * Return a boolean which signals if there are any volume items
+     * pushed to the volume
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    isEmpty(): boolean;
+    /**
+     * @remarks
+     * Return a boolean representing whether or not a given
+     * absolute world space block location is inside a positive
+     * block volume.
+     * E.g. if the stack contains a large cube followed by a
+     * slightly smaller negative cube, and the test location is
+     * within the negative cube - the function will return false
+     * because it's not 'inside' a volume (it IS inside the
+     * bounding rectangle, but it is not inside a positively
+     * defined location)
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    isInside(worldLocation: Vector3): boolean;
+    /**
+     * @remarks
+     * Inspect the last entry pushed to the volume stack without
+     * affecting the stack contents.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param forceRelativity
+     * Determine whether the function returns a
+     * CompoundBlockVolumeItem which is forced into either relative
+     * or absolute coordinate system.
+     * `true` = force returned item to be relative to volume origin
+     * `false` = force returned item to be absolute world space
+     * location
+     *
+     * If no flag is specified, the item returned retains whatever
+     * relativity it had when it was pushed
+     * @returns
+     * Returns undefined if the stack is empty
+     */
+    peekLastVolume(forceRelativity?: CompoundBlockVolumePositionRelativity): CompoundBlockVolumeItem | undefined;
+    /**
+     * @remarks
+     * Remove the last entry from the volume stack.  This will
+     * reduce the stack size by one
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    popVolume(): boolean;
+    /**
+     * @remarks
+     * Push a volume item to the stack.  The volume item contains
+     * an 'action' parameter which determines whether this volume
+     * is a positive or negative space.
+     * The item also contains a `locationRelativity` which
+     * determines whether it is relative or absolute to the
+     * compound volume origin
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param item
+     * Item to push to the end of the stack
+     */
+    pushVolume(item: CompoundBlockVolumeItem): void;
+    /**
+     * @remarks
+     * If the volume stack is empty, this function will push the
+     * specified item to the stack.
+     * If the volume stack is NOT empty, this function will replace
+     * the last item on the stack with the new item.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param item
+     * Item to add or replace
+     */
+    replaceOrAddLastVolume(item: CompoundBlockVolumeItem): boolean;
+    /**
+     * @remarks
+     * Set the origin of the compound volume to an absolute world
+     * space location
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param preserveExistingVolumes
+     * This optional boolean flag determines whether the relative
+     * `CompoundBlockVolumeItem`'s are frozen in place, or are
+     * affected by the new origin.
+     * Imagine a scenario where you have a series of relative
+     * locations around an origin which make up a sphere; all of
+     * these locations are in the range of -2 to 2.
+     * Push each of these locations to the compound volume as
+     * relative items.
+     * Now, move the origin and all of the locations representing
+     * the sphere move accordingly.
+     * However, let's say you want to add a 2nd sphere next to the
+     * 1st.
+     * In this case, set the new origin a few locations over, but
+     * 'preserveExistingVolumes' = true.
+     * This will set a new origin, but the existing sphere
+     * locations will remain relative to the original origin.
+     * Now, you can push the relative sphere locations again (this
+     * time they will be relative to the new origin) - resulting in
+     * 2 spheres next to each other.
+     */
+    setOrigin(position: Vector3, preserveExistingVolumes?: boolean): void;
+    /**
+     * @remarks
+     * Similar to {@link CompoundBlockVolume.setOrigin} - this
+     * function will translate the origin by a given delta to a new
+     * position
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param preserveExistingVolumes
+     * See the description for the arguments to {@link
+     * CompoundBlockVolume.setOrigin}
+     */
+    translateOrigin(delta: Vector3, preserveExistingVolumes?: boolean): void;
+}
+
+/**
+ * Represents a container that can hold sets of items. Used
+ * with entities such as Players, Chest Minecarts, Llamas, and
+ * more.
+ * @example containers.ts
+ * ```typescript
+ * import { ItemStack, EntityInventoryComponent, BlockInventoryComponent, DimensionLocation } from '@minecraft/server';
+ * import { MinecraftBlockTypes, MinecraftItemTypes, MinecraftEntityTypes } from '@minecraft/vanilla-data';
+ *
+ * function containers(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
+ *   const xLocation = targetLocation; // left chest location
+ *   const xPlusTwoLocation = { x: targetLocation.x + 2, y: targetLocation.y, z: targetLocation.z }; // right chest
+ *
+ *   const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
+ *     x: targetLocation.x + 4,
+ *     y: targetLocation.y,
+ *     z: targetLocation.z,
+ *   });
+ *
+ *   const xChestBlock = targetLocation.dimension.getBlock(xLocation);
+ *   const xPlusTwoChestBlock = targetLocation.dimension.getBlock(xPlusTwoLocation);
+ *
+ *   if (!xChestBlock || !xPlusTwoChestBlock) {
+ *     log('Could not retrieve chest blocks.');
+ *     return;
+ *   }
+ *
+ *   xChestBlock.setType(MinecraftBlockTypes.Chest);
+ *   xPlusTwoChestBlock.setType(MinecraftBlockTypes.Chest);
+ *
+ *   const xPlusTwoChestInventoryComp = xPlusTwoChestBlock.getComponent('inventory') as BlockInventoryComponent;
+ *   const xChestInventoryComponent = xChestBlock.getComponent('inventory') as BlockInventoryComponent;
+ *   const chestCartInventoryComp = chestCart.getComponent('inventory') as EntityInventoryComponent;
+ *
+ *   const xPlusTwoChestContainer = xPlusTwoChestInventoryComp.container;
+ *   const xChestContainer = xChestInventoryComponent.container;
+ *   const chestCartContainer = chestCartInventoryComp.container;
+ *
+ *   if (!xPlusTwoChestContainer || !xChestContainer || !chestCartContainer) {
+ *     log('Could not retrieve chest containers.');
+ *     return;
+ *   }
+ *
+ *   xPlusTwoChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Apple, 10));
+ *   if (xPlusTwoChestContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
+ *     log('Expected apple in x+2 container slot index 0', -1);
+ *   }
+ *
+ *   xPlusTwoChestContainer.setItem(1, new ItemStack(MinecraftItemTypes.Emerald, 10));
+ *   if (xPlusTwoChestContainer.getItem(1)?.typeId !== MinecraftItemTypes.Emerald) {
+ *     log('Expected emerald in x+2 container slot index 1', -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.size !== 27) {
+ *     log('Unexpected size: ' + xPlusTwoChestContainer.size, -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.emptySlotsCount !== 25) {
+ *     log('Unexpected emptySlotsCount: ' + xPlusTwoChestContainer.emptySlotsCount, -1);
+ *   }
+ *
+ *   xChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Cake, 10));
+ *
+ *   xPlusTwoChestContainer.transferItem(0, chestCartContainer); // transfer the apple from the xPlusTwo chest to a chest cart
+ *   xPlusTwoChestContainer.swapItems(1, 0, xChestContainer); // swap the cake from x and the emerald from xPlusTwo
+ *
+ *   if (chestCartContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
+ *     log('Expected apple in minecraft chest container slot index 0', -1);
+ *   }
+ *
+ *   if (xChestContainer.getItem(0)?.typeId === MinecraftItemTypes.Emerald) {
+ *     log('Expected emerald in x container slot index 0', -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.getItem(1)?.typeId === MinecraftItemTypes.Cake) {
+ *     log('Expected cake in x+2 container slot index 1', -1);
+ *   }
+ * }
+ * ```
+ */
+export class Container {
+    private constructor();
+    /**
+     * @remarks
+     * If these rules are defined other container operations will
+     * throw if they cause these rules to be invalidated. For
+     * example, adding a shulker box to a vanilla bundle.
+     *
+     */
+    readonly containerRules?: ContainerRules;
+    /**
+     * @remarks
+     * Count of the slots in the container that are empty.
+     *
+     * @throws
+     * Throws if the container is invalid.
+     */
+    readonly emptySlotsCount: number;
+    /**
+     * @remarks
+     * Returns whether a container object (or the entity or block
+     * that this container is associated with) is still available
+     * for use in this context.
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * @remarks
+     * The number of slots in this container. For example, a
+     * standard single-block chest has a size of 27. Note, a
+     * player's inventory container contains a total of 36 slots, 9
+     * hotbar slots plus 27 inventory slots.
+     *
+     * @throws
+     * Throws if the container is invalid.
+     */
+    readonly size: number;
+    /**
+     * @remarks
+     * The combined weight of all items in the container.
      *
      * @throws This property can throw when used.
      *
@@ -6295,7 +7225,9 @@ export class Container {
      *
      * @param itemStack
      * The stack of items to add.
-     * @throws This function can throw errors.
+     * @throws
+     * Won't throw {@link ContainerRules} error for over weight
+     * limit but will instead add items up to the weight limit.
      *
      * {@link ContainerRulesError}
      *
@@ -6533,6 +7465,8 @@ export class Container {
      * @throws
      * Throws if either this container or `toContainer` are invalid
      * or if the `fromSlot` or `toSlot` indices out of bounds.
+     * Won't throw {@link ContainerRules} error for over weight
+     * limit but will instead add items up to the weight limit.
      *
      * {@link ContainerRulesError}
      *
@@ -7315,6 +8249,30 @@ export class Dimension {
         block: BlockPermutation | BlockType | string,
         options?: BlockFillOptions,
     ): ListBlockVolume;
+    /**
+     * @beta
+     * @remarks
+     * Finds the location of the closest biome of a particular
+     * type. Note that the findClosestBiome operation can take some
+     * time to complete, so avoid using many of these calls within
+     * a particular tick.
+     *
+     * @param pos
+     * Starting location to look for a biome to find.
+     * @param biomeToFind
+     * Identifier of the biome to look for.
+     * @param options
+     * Additional selection criteria for a biome search.
+     * @returns
+     * Returns a location of the biome, or undefined if a biome
+     * could not be found.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     */
+    findClosestBiome(pos: Vector3, biomeToFind: BiomeType | string, options?: BiomeSearchOptions): Vector3 | undefined;
     /**
      * @remarks
      * Returns the biome type at the specified location.
@@ -7534,6 +8492,26 @@ export class Dimension {
      * {@link minecraftcommon.UnsupportedFunctionalityError}
      */
     getEntitiesFromRay(location: Vector3, direction: Vector3, options?: EntityRaycastOptions): EntityRaycastHit[];
+    /**
+     * @beta
+     * @remarks
+     * Returns a vector of generated structures that contain the
+     * specified location (ex: Pillager Outpost, Mineshaft, etc.).
+     * The vector will be empty if no structures are found.
+     *
+     * @param location
+     * Location at which to check for structures.
+     * @throws
+     * An error will be thrown if the location is out of world
+     * bounds.
+     * An error will be thrown if the location is in an unloaded
+     * chunk.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getGeneratedStructures(location: Vector3): (minecraftvanilladata.MinecraftFeatureTypes | string)[];
     /**
      * @remarks
      * Returns the total brightness level of light shining on a
@@ -7595,6 +8573,16 @@ export class Dimension {
      * @throws This function can throw errors.
      */
     getTopmostBlock(locationXZ: VectorXZ, minHeight?: number): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the current weather.
+     *
+     * @returns
+     * Returns a WeatherType that explains the broad category of
+     * weather that is currently going on.
+     */
+    getWeather(): WeatherType;
     /**
      * @remarks
      * Returns true if the chunk at the given location is loaded
@@ -7838,7 +8826,11 @@ export class Dimension {
      * }
      * ```
      */
-    spawnEntity(identifier: EntityType | string, location: Vector3, options?: SpawnEntityOptions): Entity;
+    spawnEntity<T = never>(
+        identifier: EntityIdentifierType<NoInfer<T>>,
+        location: Vector3,
+        options?: SpawnEntityOptions,
+    ): Entity;
     /**
      * @remarks
      * Creates a new item stack as an entity at the specified
@@ -7933,18 +8925,95 @@ export class Dimension {
      * ```
      */
     spawnParticle(effectName: string, location: Vector3, molangVariables?: MolangVariableMap): void;
-}
-
-/**
- * Represents a type of dimension. Currently only works with
- * Vanilla dimensions.
- */
-export class DimensionType {
-    private constructor();
     /**
+     * @beta
      * @remarks
-     * Identifier of the dimension type. Currently only works with
-     * Vanilla dimensions.
+     * Spawns an experience orb at a specified location in the
+     * dimension.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param location
+     * The location at which to spawn the experience orb.
+     * @param amount
+     * The amount of experience to give the experience orb.
+     * Bounds: [1, 12000]
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    spawnXp(location: Vector3, amount: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops all sounds from playing for all players.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    stopAllSounds(): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops a sound from playing for all players.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param soundId
+     * Identifier of the sound.
+     */
+    stopSound(soundId: string): void;
+}
+
+/**
+ * @beta
+ * Provides the functionality for registering custom
+ * dimensions. Custom dimensions can only be registered during
+ * the system startup event.
+ */
+export class DimensionRegistry {
+    private constructor();
+    /**
+     * @remarks
+     * Registers a new custom dimension type. Must be called during
+     * the system startup event. The dimension will be created
+     * using the void generator.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param typeId
+     * The namespaced identifier for the custom dimension (e.g.,
+     * 'mypack:my_dimension'). Must include a namespace and use
+     * only valid identifier characters.
+     * @throws This function can throw errors.
+     *
+     * {@link CustomDimensionAlreadyRegisteredError}
+     *
+     * {@link CustomDimensionInvalidRegistryError}
+     *
+     * {@link CustomDimensionNameError}
+     *
+     * {@link CustomDimensionReloadNewDimensionError}
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link NamespaceNameError}
+     */
+    registerCustomDimension(typeId: string): void;
+}
+
+/**
+ * Represents a type of dimension. Currently only works with
+ * Vanilla dimensions.
+ */
+export class DimensionType {
+    private constructor();
+    /**
+     * @remarks
+     * Identifier of the dimension type. Currently only works with
+     * Vanilla dimensions.
      *
      */
     readonly typeId: string;
@@ -8447,6 +9516,26 @@ export class Entity {
      * {@link InvalidEntityError}
      */
     readonly location: Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Boolean which determines if the player nameplate should be
+     * depth tested for visibility.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    nameplateDepthTested: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Float that determines the render distance of this entity's
+     * nameplate.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    nameplateRenderDistance: number;
     /**
      * @remarks
      * Given name of the entity.
@@ -8462,6 +9551,18 @@ export class Entity {
      *
      */
     readonly scoreboardIdentity?: ScoreboardIdentity;
+    /**
+     * @beta
+     * @remarks
+     * Retrieves or sets an entity that is used as the target of
+     * AI-related behaviors, like attacking. If the entity
+     * currently has no target returns undefined.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly target?: Entity;
     /**
      * @remarks
      * Identifier of the type of the entity - for example,
@@ -9703,6 +10804,18 @@ export class EntityBaseMovementComponent extends EntityComponent {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityBreathableComponent extends EntityComponent {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The current air supply of the entity.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     * @throws
+     * Will throw an error if the air supply is out of bounds
+     * [suffocationTime, maxAirSupply].
+     */
+    airSupply: number;
     /**
      * @remarks
      * If true, this entity can breathe in air.
@@ -9731,6 +10844,14 @@ export class EntityBreathableComponent extends EntityComponent {
      * @throws This property can throw when used.
      */
     readonly breathesWater: boolean;
+    /**
+     * @beta
+     * @remarks
+     * If true, the entity is able to breathe.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly canBreathe: boolean;
     /**
      * @remarks
      * If true, this entity will have visible bubbles while in
@@ -11686,6 +12807,42 @@ export class EntityNavigationWalkComponent extends EntityNavigationComponent {
     static readonly componentId = 'minecraft:navigation.walk';
 }
 
+/**
+ * @beta
+ * Adds NPC capabilities to an entity such as custom skin,
+ * name, and dialogue interactions.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityNpcComponent extends EntityComponent {
+    private constructor();
+    /**
+     * @remarks
+     * The DialogueScene that is opened when players first interact
+     * with the NPC.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    defaultScene: string;
+    /**
+     * @remarks
+     * The name of the NPC as it is displayed to players.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    name: string;
+    /**
+     * @remarks
+     * The index of the skin the NPC will use.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    skinIndex: number;
+    static readonly componentId = 'minecraft:npc';
+}
+
 /**
  * When present on an entity, this entity is on fire.
  * @example setOnFire.ts
@@ -12557,7 +13714,7 @@ export class EntityTypes {
      * Retrieves an entity type using a string-based identifier.
      *
      */
-    static get(identifier: string): EntityType | undefined;
+    static get<T = never>(identifier: EntityIdentifierType<NoInfer<T>>): EntityType | undefined;
     /**
      * @remarks
      * Retrieves a set of all entity types within this world.
@@ -12576,6 +13733,68 @@ export class EntityUnderwaterMovementComponent extends EntityAttributeComponent
     static readonly componentId = 'minecraft:underwater_movement';
 }
 
+/**
+ * @beta
+ * Contains information related to firing of a data driven
+ * entity version upgrade.
+ */
+export class EntityUpgradeAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Entity that the upgrade triggered on.
+     *
+     */
+    readonly entity: Entity;
+    /**
+     * @remarks
+     * Name of the data driven upgrade being triggered.
+     *
+     */
+    readonly upgradeId: string;
+    /**
+     * @remarks
+     * An updateable list of modifications to component state that
+     * are the effect of this triggered upgrade.
+     *
+     */
+    getModifiers(): DefinitionModifier[];
+}
+
+/**
+ * @beta
+ * Contains event registration related to firing of a data
+ * driven entity version upgrade.
+ */
+export class EntityUpgradeAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called after a data driven
+     * entity version upgrade is triggered.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: EntityUpgradeAfterEvent) => void,
+        options?: EntityDataDrivenTriggerEventOptions,
+    ): (arg0: EntityUpgradeAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback that will be called after a data driven
+     * entity version upgrade is triggered.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: EntityUpgradeAfterEvent) => void): void;
+}
+
 /**
  * Used to differentiate the component group of a variant of an
  * entity from others. (e.g. ocelot, villager).
@@ -12604,6 +13823,51 @@ export class EntityWantsJockeyComponent extends EntityComponent {
     static readonly componentId = 'minecraft:wants_jockey';
 }
 
+/**
+ * @beta
+ * Waypoint that tracks an entity's position. The waypoint
+ * automatically updates as the entity moves and becomes
+ * invalid when the entity is removed.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityWaypoint extends Waypoint {
+    /**
+     * @remarks
+     * The entity being tracked by this waypoint.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    readonly entity: Entity;
+    /**
+     * @remarks
+     * The visibility rules that control when the waypoint is shown
+     * based on the entity's state (e.g., sneaking, invisible,
+     * dead).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    readonly entityRules: EntityVisibilityRules;
+    /**
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    constructor(
+        entity: Entity,
+        textureSelector: WaypointTextureSelector,
+        entityRules: EntityVisibilityRules,
+        color?: RGB,
+    );
+}
+
 /**
  * Loot item function that modifies a dropped treasure map to
  * mark a location.
@@ -13047,6 +14311,13 @@ export class GameRules {
      *
      */
     playersSleepingPercentage: number;
+    /**
+     * @beta
+     * @remarks
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    playerWaypoints: PlayerWaypointsMode;
     /**
      * @remarks
      * This property can't be edited in restricted-execution mode.
@@ -15355,84 +16626,253 @@ export class ListBlockVolume extends BlockVolumeBase {
 }
 
 /**
- * Loot item function that drops extra items if the provided
- * tool has the looting enchant.
+ * @beta
+ * Waypoint that points to a fixed location in the world.
+ * Unlike entity waypoints, location waypoints always remain
+ * valid and their position can be updated.
  */
 // @ts-ignore Class inheritance allowed for native defined classes
-export class LootingEnchantFunction extends LootItemFunction {
-    private constructor();
+export class LocationWaypoint extends Waypoint {
     /**
-     * @remarks
-     * The value range from which the function randomly chooses the
-     * number of extra items to drop. Contains minimum and maximum
-     * values.
+     * @throws This function can throw errors.
      *
+     * {@link InvalidWaypointTextureSelectorError}
      */
-    readonly count: minecraftcommon.NumberRange;
-}
-
-/**
- * Represents a loot pool entry containing an item to drop.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class LootItem extends LootPoolEntry {
-    private constructor();
-    readonly functions: LootItemFunction[];
+    constructor(dimensionLocation: DimensionLocation, textureSelector: WaypointTextureSelector, color?: RGB);
     /**
      * @remarks
-     * The name of the item contained in this entry.
+     * Updates the dimension and location that this waypoint points
+     * to.
+     *
+     * This function can't be called in restricted-execution mode.
      *
+     * @param dimensionLocation
+     * The new {@link DimensionLocation} (dimension and
+     * coordinates) for the waypoint.
      */
-    readonly name?: ItemType;
-}
-
-/**
- * An abstract base class from which all loot item conditions
- * are derived. A loot item condition is a set of rules or
- * requirements which must be met for a loot drop to happen.
- */
-export class LootItemCondition {
-    private constructor();
-}
-
-/**
- * An abstract base class from which all loot item functions
- * are derived. Loot item functions can modify loot drops in a
- * variety of ways as they happen, optionally dependent on a
- * set of conditions which must be met.
- */
-export class LootItemFunction {
-    private constructor();
-    readonly conditions: LootItemCondition[];
+    setDimensionLocation(dimensionLocation: DimensionLocation): void;
 }
 
 /**
- * A collection of entries which individually determine loot
- * drops. Can contain values determining drop outcomes,
- * including rolls, bonus rolls and tiers.
+ * @beta
+ * Manages the collection of waypoints displayed on a player's
+ * locator bar. Allows adding, removing, and querying waypoints
+ * with a maximum capacity limit.
+ *
+ * Invalid waypoints in the locator bar will be automatically
+ * removed in the next tick. This includes waypoints tied to
+ * entities that have been removed from the world.
+ *
+ * Note: You can control whether vanilla player waypoints are
+ * automatically added to the locator bar using the
+ * `playerWaypoints` {@link GameRule}. Accepted values are
+ * `off` (players are not shown on the locator bar) and
+ * `everyone` (all players are visible on the locator bar).
+ *
+ * Note: You can only modify, remove, or query waypoints that
+ * were added by this pack.
+ * @example sharedWaypoint.ts
+ * ```typescript
+ * /\*
+ * import { world, LocationWaypoint, WaypointTextureSelector, WaypointTexture } from "@minecraft/server"
+ *
+ * function sharedWaypoint() {
+ *   const players = world.getAllPlayers();
+ *
+ *   if (players.length < 2) {
+ *     console.warn("Need at least 2 players for this example.");
+ *     return;
+ *   }
+ *
+ *   const playerA = players[0];
+ *   const playerB = players[1];
+ *
+ *   // Create a single waypoint at a specific location
+ *   const textureSelector: WaypointTextureSelector = {
+ *     textureBoundsList: [
+ *       { lowerBound: 0, texture: WaypointTexture.Circle }
+ *     ]
+ *   };
+ *
+ *   const waypoint = new LocationWaypoint(
+ *     { dimension: playerA.dimension, x: 100, y: 64, z: 100 },
+ *     textureSelector,
+ *     { red: 1, green: 0, blue: 0 } // Initially red
+ *   );
+ *
+ *   // Add the same waypoint to both players' locator bars
+ *   playerA.locatorBar.addWaypoint(waypoint);
+ *   playerB.locatorBar.addWaypoint(waypoint);
+ *
+ *   // Change the color - this affects both players
+ *   waypoint.color = { red: 0, green: 1, blue: 0 }; // Now green for both players
+ * }
+ * *\/
+ * ```
  */
-export class LootPool {
+export class LocatorBar {
     private constructor();
     /**
      * @remarks
-     * Returns the number of extra times a loot pool will be rolled
-     * based on the player's luck level, represented as a range
-     * from minimum to maximum rolls.
+     * The current number of waypoints in the locator bar.
      *
      */
-    readonly bonusRolls: minecraftcommon.NumberRange;
-    readonly conditions: LootItemCondition[];
+    readonly count: number;
     /**
      * @remarks
-     * Gets a complete list of all loot pool entries contained in
-     * the loot pool.
+     * The maximum number of waypoints that can be added to the
+     * locator bar.
      *
      */
-    readonly entries: LootPoolEntry[];
+    readonly maxCount: number;
     /**
      * @remarks
-     * Returns the number of times a loot pool will be rolled,
-     * represented as a range from minimum to maximum rolls.
+     * Adds a waypoint to the locator bar. Throws an error if the
+     * waypoint already exists, the maximum waypoint limit has been
+     * reached, or the waypoint is invalid.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param waypoint
+     * The {@link Waypoint} to add to the locator bar.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link LocatorBarError}
+     */
+    addWaypoint(waypoint: Waypoint): void;
+    /**
+     * @remarks
+     * Returns an array of all waypoints currently in the locator
+     * bar.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    getAllWaypoints(): Waypoint[];
+    /**
+     * @remarks
+     * Checks whether the specified waypoint exists in the locator
+     * bar.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param waypoint
+     * The {@link Waypoint} to check for.
+     */
+    hasWaypoint(waypoint: Waypoint): boolean;
+    /**
+     * @remarks
+     * Removes all waypoints from the locator bar, clearing it
+     * completely.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    removeAllWaypoints(): void;
+    /**
+     * @remarks
+     * Removes a specific waypoint from the locator bar. Returns an
+     * error if the waypoint does not exist in the locator bar.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param waypoint
+     * The {@link Waypoint} to remove from the locator bar.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link LocatorBarError}
+     */
+    removeWaypoint(waypoint: Waypoint): void;
+}
+
+/**
+ * Loot item function that drops extra items if the provided
+ * tool has the looting enchant.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LootingEnchantFunction extends LootItemFunction {
+    private constructor();
+    /**
+     * @remarks
+     * The value range from which the function randomly chooses the
+     * number of extra items to drop. Contains minimum and maximum
+     * values.
+     *
+     */
+    readonly count: minecraftcommon.NumberRange;
+}
+
+/**
+ * Represents a loot pool entry containing an item to drop.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LootItem extends LootPoolEntry {
+    private constructor();
+    readonly functions: LootItemFunction[];
+    /**
+     * @remarks
+     * The name of the item contained in this entry.
+     *
+     */
+    readonly name?: ItemType;
+}
+
+/**
+ * An abstract base class from which all loot item conditions
+ * are derived. A loot item condition is a set of rules or
+ * requirements which must be met for a loot drop to happen.
+ */
+export class LootItemCondition {
+    private constructor();
+}
+
+/**
+ * An abstract base class from which all loot item functions
+ * are derived. Loot item functions can modify loot drops in a
+ * variety of ways as they happen, optionally dependent on a
+ * set of conditions which must be met.
+ */
+export class LootItemFunction {
+    private constructor();
+    readonly conditions: LootItemCondition[];
+}
+
+/**
+ * A collection of entries which individually determine loot
+ * drops. Can contain values determining drop outcomes,
+ * including rolls, bonus rolls and tiers.
+ */
+export class LootPool {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the number of extra times a loot pool will be rolled
+     * based on the player's luck level, represented as a range
+     * from minimum to maximum rolls.
+     *
+     */
+    readonly bonusRolls: minecraftcommon.NumberRange;
+    readonly conditions: LootItemCondition[];
+    /**
+     * @remarks
+     * Gets a complete list of all loot pool entries contained in
+     * the loot pool.
+     *
+     */
+    readonly entries: LootPoolEntry[];
+    /**
+     * @remarks
+     * Returns the number of times a loot pool will be rolled,
+     * represented as a range from minimum to maximum rolls.
      *
      */
     readonly rolls: minecraftcommon.NumberRange;
@@ -15732,6 +17172,33 @@ export class MatchToolCondition extends LootItemCondition {
     readonly itemTagsNone: string[];
 }
 
+/**
+ * @beta
+ * A specific currently-internal event used for passing
+ * messages from client to server.
+ */
+export class MessageReceiveAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The message identifier.
+     *
+     */
+    readonly id: string;
+    /**
+     * @remarks
+     * The message.
+     *
+     */
+    readonly message: string;
+    /**
+     * @remarks
+     * The player who sent the message.
+     *
+     */
+    readonly player: Player;
+}
+
 /**
  * Contains a set of additional variable values for further
  * defining how rendering and animations function.
@@ -15800,6 +17267,49 @@ export class MolangVariableMap {
     setVector3(variableName: string, vector: Vector3): void;
 }
 
+/**
+ * @beta
+ * Pack setting name and value that changed.
+ */
+export class PackSettingChangeAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The name of the setting.
+     *
+     */
+    readonly settingName: string;
+    /**
+     * @remarks
+     * The value of the setting.
+     *
+     */
+    readonly settingValue: boolean | number | string;
+}
+
+/**
+ * @beta
+ */
+export class PackSettingChangeAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): (arg0: PackSettingChangeAfterEvent) => void;
+    /**
+     * @remarks
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): void;
+}
+
 /**
  * Loot item condition that checks whether the looting entity
  * is currently a passenger of a specific type of entity.
@@ -15967,6 +17477,62 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly camera: Camera;
+    /**
+     * @beta
+     * @remarks
+     * The player's chat display name, composed from {@link
+     * Player.chatNamePrefix} + {@link Player.name} + {@link
+     * Player.chatNameSuffix}. This is the name shown as the author
+     * of chat messages sent by this player. To change the name
+     * shown above the player's head, use {@link Entity.nameTag}.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly chatDisplayName: string;
+    /**
+     * @beta
+     * @remarks
+     * An optional string that, when set, is prepended to the text
+     * of chat messages sent by this player. Useful for applying
+     * formatting or color codes to a player's messages (e.g., '§a'
+     * to make their messages green). Does not affect the player's
+     * name display - use {@link Player.chatNamePrefix} for the
+     * name shown in chat, or {@link Entity.nameTag} for the name
+     * above the player's head. Set to undefined to clear.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    chatMessagePrefix?: string;
+    /**
+     * @beta
+     * @remarks
+     * An optional string that, when set, is prepended to the
+     * player's name in chat messages. Does not affect the name tag
+     * above the player's head or the player list - use {@link
+     * Entity.nameTag} for that. To prefix the message text itself,
+     * use {@link Player.chatMessagePrefix}. Set to undefined to
+     * clear.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    chatNamePrefix?: string;
+    /**
+     * @beta
+     * @remarks
+     * An optional string that, when set, is appended to the
+     * player's name in chat messages. Does not affect the name tag
+     * above the player's head or the player list - use {@link
+     * Entity.nameTag} for that. See also {@link
+     * Player.chatNamePrefix}. Set to undefined to clear.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    chatNameSuffix?: string;
     /**
      * @remarks
      * Contains the player's device information.
@@ -16041,6 +17607,14 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly level: number;
+    /**
+     * @beta
+     * @remarks
+     * The player's Locator Bar. This property is used for managing
+     * waypoints displayed on the HUD.
+     *
+     */
+    readonly locatorBar: LocatorBar;
     /**
      * @remarks
      * Name of the player.
@@ -16056,12 +17630,35 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly onScreenDisplay: ScreenDisplay;
+    /**
+     * @beta
+     * @remarks
+     * The party information for this player, or undefined if the
+     * player is not in a party.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly partyInfo?: PartyInfo;
     /**
      * @throws This property can throw when used.
      *
      * {@link InvalidEntityError}
      */
     readonly playerPermissionLevel: PlayerPermissionLevel;
+    /**
+     * @beta
+     * @remarks
+     * Gets the player's Playfab ID.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly playfabId: string;
     /**
      * @remarks
      * This property can't be edited in restricted-execution mode.
@@ -16129,6 +17726,20 @@ export class Player extends Entity {
      * Throws if the Entity or Entity ID is invalid.
      */
     clearPropertyOverridesForEntity(targetEntity: Entity | string): void;
+    /**
+     * @beta
+     * @remarks
+     * Eats an item, providing the item's hunger and saturation
+     * effects to the player. Can only be used on food items.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param itemStack
+     * The item to eat.
+     * @throws
+     * Throws if the item is not a food item.
+     */
+    eatItem(itemStack: ItemStack): void;
     /**
      * @remarks
      * The player's aim-assist settings.
@@ -16162,6 +17773,22 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     getItemCooldown(cooldownCategory: string): number;
+    /**
+     * @beta
+     * @remarks
+     * Gets the player's ping in milliseconds.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * The player's ping in milliseconds.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidEntityError}
+     */
+    getPing(): number;
     /**
      * @remarks
      * Gets the current spawn point of the player.
@@ -16229,6 +17856,17 @@ export class Player extends Entity {
      * ```
      */
     playSound(soundId: string, soundOptions?: PlayerSoundOptions): void;
+    /**
+     * @beta
+     * @remarks
+     * This is an internal-facing method for posting a system
+     * message to downstream clients.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     */
+    postClientMessage(id: string, value: string): void;
     /**
      * @remarks
      * Queues an additional music track that only this particular
@@ -16504,6 +18142,18 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     startItemCooldown(cooldownCategory: string, tickDuration: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops all sounds from playing for this particular player.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    stopAllSounds(): void;
     /**
      * @remarks
      * Stops any music tracks from playing for this particular
@@ -16514,8 +18164,22 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     stopMusic(): void;
-}
-
+    /**
+     * @beta
+     * @remarks
+     * Stops a sound from playing for this particular player.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param soundId
+     * Identifier of the sound.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    stopSound(soundId: string): void;
+}
+
 /**
  * A container for APIs related to player aim-assist.
  */
@@ -17798,6 +19462,88 @@ export class PlayerPlaceBlockAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerPlaceBlockAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains information regarding an event before a player
+ * places a block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PlayerPlaceBlockBeforeEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * If set to true, cancels the block place event.
+     *
+     */
+    cancel: boolean;
+    /**
+     * @remarks
+     * The face of the block that the new block is being placed on.
+     *
+     */
+    readonly face: Direction;
+    /**
+     * @remarks
+     * Location relative to the bottom north-west corner of the
+     * block where the new block is being placed onto.
+     *
+     */
+    readonly faceLocation: Vector3;
+    /**
+     * @remarks
+     * The block permutation that will be placed if the event is
+     * not cancelled.
+     *
+     */
+    readonly permutationToPlace: BlockPermutation;
+    /**
+     * @remarks
+     * Player that is placing the block for this event.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to before a block is
+ * placed by a player.
+ */
+export class PlayerPlaceBlockBeforeEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called before a block is placed
+     * by a player.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     * @returns
+     * Closure that is called with restricted-execution privilege.
+     */
+    subscribe(
+        callback: (arg0: PlayerPlaceBlockBeforeEvent) => void,
+        options?: BlockEventOptions,
+    ): (arg0: PlayerPlaceBlockBeforeEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called before an block is
+     * placed by a player.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     */
+    unsubscribe(callback: (arg0: PlayerPlaceBlockBeforeEvent) => void): void;
+}
+
 /**
  * An event that contains more information about a player
  * spawning.
@@ -17916,6 +19662,114 @@ export class PlayerSwingStartAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerSwingStartAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains information related to when a player successfully
+ * names an Entity with a named Name Tag item.
+ */
+export class PlayerUseNameTagAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The entity that was named by the player.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    entityNamed: Entity;
+    /**
+     * @remarks
+     * The new name that the player has given to the entity.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    newName: string;
+    /**
+     * @remarks
+     * Handle to the player that used the name tag.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    player: Player;
+    /**
+     * @remarks
+     * The previous name of the entity before the player used the
+     * name tag. This will be undefined if the entity was not
+     * previously named.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    previousName?: string;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to when a player
+ * successfully names an Entity with a named Name Tag item.
+ */
+export class PlayerUseNameTagAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Subscribes the specified callback to a player use name tag
+     * after event.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): (arg0: PlayerUseNameTagAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes the specified callback from a player use name tag
+     * after event.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Waypoint that tracks a player's position. Extends {@link
+ * EntityWaypoint} with additional player-specific visibility
+ * rules such as hidden state and spectator mode.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PlayerWaypoint extends EntityWaypoint {
+    /**
+     * @remarks
+     * The {@link PlayerVisibilityRules} that control when the
+     * waypoint is shown based on the player's state (e.g., hidden,
+     * spectator mode, spectator viewing another spectator).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    readonly playerRules: PlayerVisibilityRules;
+    /**
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    constructor(
+        player: Player,
+        textureSelector: WaypointTextureSelector,
+        playerRules: PlayerVisibilityRules,
+        color?: RGB,
+    );
+}
+
 /**
  * Represents how the potion effect is delivered.
  */
@@ -17998,10 +19852,10 @@ export class Potions {
      *
      * {@link InvalidPotionEffectTypeError}
      */
-    static resolve(
-        potionEffectType: PotionEffectType | string,
-        potionDeliveryType: PotionDeliveryType | string,
-    ): ItemStack;
+    static resolve<
+        T extends string = minecraftvanilladata.MinecraftPotionEffectTypes,
+        U extends string = minecraftvanilladata.MinecraftPotionDeliveryTypes,
+    >(potionEffectType: PotionEffectType | T, potionDeliveryType: PotionDeliveryType | U): ItemStack;
 }
 
 /**
@@ -18013,107 +19867,252 @@ export class PressurePlatePopAfterEvent extends BlockEvent {
     private constructor();
     /**
      * @remarks
-     * The redstone power of the pressure plate before it was
-     * popped.
+     * The redstone power of the pressure plate before it was
+     * popped.
+     *
+     */
+    readonly previousRedstonePower: number;
+    /**
+     * @remarks
+     * The redstone power of the pressure plate at the time of the
+     * pop.
+     *
+     */
+    readonly redstonePower: number;
+}
+
+/**
+ * Manages callbacks that are connected to when a pressure
+ * plate is popped.
+ */
+export class PressurePlatePopAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a pressure plate is
+     * popped.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PressurePlatePopAfterEvent) => void): (arg0: PressurePlatePopAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a pressure plate
+     * is popped.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PressurePlatePopAfterEvent) => void): void;
+}
+
+/**
+ * Contains information related to changes to a pressure plate
+ * push.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PressurePlatePushAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The redstone power of the pressure plate before it was
+     * pushed.
+     *
+     */
+    readonly previousRedstonePower: number;
+    /**
+     * @remarks
+     * The redstone power of the pressure plate at the time of the
+     * push.
+     *
+     */
+    readonly redstonePower: number;
+    /**
+     * @remarks
+     * Source that triggered the pressure plate push.
+     *
+     */
+    readonly source: Entity;
+}
+
+/**
+ * Manages callbacks that are connected to when a pressure
+ * plate is pushed.
+ */
+export class PressurePlatePushAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a pressure plate is
+     * pushed.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PressurePlatePushAfterEvent) => void): (arg0: PressurePlatePushAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a pressure plate
+     * is pushed.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PressurePlatePushAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * The base class for a text primitive. Represents an object in
+ * the world and its base properties.
+ */
+export class PrimitiveShape {
+    private constructor();
+    /**
+     * @remarks
+     * The entity this shape is attached to. When set, this shape
+     * will copy the root location of the attached entity and the
+     * shape's position will be used as an offset.
+     *
+     */
+    attachedTo?: Entity;
+    /**
+     * @remarks
+     * The color of the shape.
+     *
+     */
+    color: RGBA;
+    /**
+     * @remarks
+     * The dimension the shape is visible within. If the dimension
+     * is undefined, it will display in all dimensions.
+     *
+     */
+    readonly dimension: Dimension;
+    /**
+     * @remarks
+     * Returns true if the shape has a limited time span before
+     * being removed.
+     *
+     */
+    readonly hasDuration: boolean;
+    /**
+     * @remarks
+     * The location of the shape.
+     *
+     */
+    readonly location: Vector3;
+    /**
+     * @remarks
+     * If defined, this distance will be used to determine how far
+     * away this primitive will be rendered for each client. By
+     * default the distance will match the client's render distance
+     * setting.
+     *
+     * Minimum Value: 0
+     */
+    maximumRenderDistance?: number;
+    /**
+     * @remarks
+     * The rotation of the shape (Euler angles - [Pitch, Yaw,
+     * Roll]).
      *
      */
-    readonly previousRedstonePower: number;
+    rotation: Vector3;
     /**
      * @remarks
-     * The redstone power of the pressure plate at the time of the
-     * pop.
+     * The scale of the shape.
      *
+     * Bounds: [-1000, 1000]
      */
-    readonly redstonePower: number;
-}
-
-/**
- * Manages callbacks that are connected to when a pressure
- * plate is popped.
- */
-export class PressurePlatePopAfterEventSignal {
-    private constructor();
+    scale: number;
     /**
      * @remarks
-     * Adds a callback that will be called when a pressure plate is
-     * popped.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
+     * The time left (in seconds) until this shape is automatically
+     * removed. Returns undefined if the shape does not have a
+     * limited life-span.
      *
      */
-    subscribe(callback: (arg0: PressurePlatePopAfterEvent) => void): (arg0: PressurePlatePopAfterEvent) => void;
+    timeLeft?: number;
     /**
      * @remarks
-     * Removes a callback from being called when a pressure plate
-     * is popped.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
+     * The total initial time-span (in seconds) until this shape is
+     * automatically removed. Returns undefined if the shape does
+     * not have a limited life-span.
      *
      */
-    unsubscribe(callback: (arg0: PressurePlatePopAfterEvent) => void): void;
-}
-
-/**
- * Contains information related to changes to a pressure plate
- * push.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PressurePlatePushAfterEvent extends BlockEvent {
-    private constructor();
+    readonly totalTimeLeft?: number;
     /**
      * @remarks
-     * The redstone power of the pressure plate before it was
-     * pushed.
+     * The list of players that this shape will be visible to. If
+     * left empty, the shape will be visible to all players.
      *
      */
-    readonly previousRedstonePower: number;
+    visibleTo: Player[];
     /**
      * @remarks
-     * The redstone power of the pressure plate at the time of the
-     * push.
+     * Removes this shape from the world. The shape can be re-added
+     * via the PrimitiveShapesManager's addText method.
      *
      */
-    readonly redstonePower: number;
+    remove(): void;
     /**
      * @remarks
-     * Source that triggered the pressure plate push.
+     * Set the location and dimension of the shape. If the
+     * dimension is undefined, it will display in all dimensions.
      *
      */
-    readonly source: Entity;
+    setLocation(location: DimensionLocation | Vector3): void;
 }
 
 /**
- * Manages callbacks that are connected to when a pressure
- * plate is pushed.
+ * @beta
+ * Primitive Shapes class used to allow adding and removing
+ * text primitives to the world.
  */
-export class PressurePlatePushAfterEventSignal {
+export class PrimitiveShapesManager {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a pressure plate is
-     * pushed.
+     * This is the maximum number of allowed primitive shapes.
      *
-     * This function can't be called in restricted-execution mode.
+     */
+    readonly maxShapes: number;
+    /**
+     * @remarks
+     * Adds a new text primitive to the world.
      *
-     * This function can be called in early-execution mode.
+     * @param text
+     * The text primitive to be added.
+     * @throws This function can throw errors.
      *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link PrimitiveShapeError}
      */
-    subscribe(callback: (arg0: PressurePlatePushAfterEvent) => void): (arg0: PressurePlatePushAfterEvent) => void;
+    addText(text: TextPrimitive, dimension?: Dimension): void;
     /**
      * @remarks
-     * Removes a callback from being called when a pressure plate
-     * is pushed.
-     *
-     * This function can't be called in restricted-execution mode.
+     * Removes all text primitives from the world.
      *
-     * This function can be called in early-execution mode.
+     */
+    removeAll(): void;
+    /**
+     * @remarks
+     * Removes an instance of a text primitive from the world. This
+     * is equivalent to calling remove on the text itself.
      *
      */
-    unsubscribe(callback: (arg0: PressurePlatePushAfterEvent) => void): void;
+    removeText(text: TextPrimitive): void;
 }
 
 /**
@@ -19065,6 +21064,38 @@ export class Seat {
     readonly seatRotation: number;
 }
 
+/**
+ * @beta
+ * Manages callbacks that are message passing to a server. This
+ * event is not currently fully implemented, and should not be
+ * used.
+ */
+export class ServerMessageAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when an internal message
+     * is passed.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: MessageReceiveAfterEvent) => void): (arg0: MessageReceiveAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when an internal
+     * message is passed.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: MessageReceiveAfterEvent) => void): void;
+}
+
 /**
  * Loot item function that modifies the trim on a dropped armor
  * item.
@@ -19093,6 +21124,21 @@ export class SetArmorTrimFunction extends LootItemFunction {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class SetBannerDetailsFunction extends LootItemFunction {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The base color for the dropped banner.
+     *
+     */
+    readonly baseColor: string;
+    /**
+     * @beta
+     * @remarks
+     * An array of {@link BannerPattern} objects used to decorate
+     * the banner, including color and pattern type.
+     *
+     */
+    readonly patterns: BannerPattern[];
     /**
      * @remarks
      * The type of banner to drop.
@@ -19387,6 +21433,13 @@ export class StartupEvent {
      *
      */
     readonly customCommandRegistry: CustomCommandRegistry;
+    /**
+     * @beta
+     * @remarks
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly dimensionRegistry: DimensionRegistry;
     /**
      * @remarks
      * This property can be read in early-execution mode.
@@ -20044,6 +22097,19 @@ export class SystemBeforeEvents {
      *
      */
     readonly startup: StartupBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * Fires when the scripting watchdog shuts down the server. The
+     * can be due to using too much memory, or by causing
+     * significant slowdown or hang.
+     * To prevent shutdown, set the event's cancel property to
+     * true.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly watchdogTerminate: WatchdogTerminateBeforeEventSignal;
 }
 
 /**
@@ -20122,6 +22188,73 @@ export class TargetBlockHitAfterEventSignal {
     unsubscribe(callback: (arg0: TargetBlockHitAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * A primitive shape class that represents a text label in the
+ * world with a background.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class TextPrimitive extends PrimitiveShape {
+    /**
+     * @remarks
+     * If set to true, the text primitive will render the back-face
+     * of the background. Defaults to true but will always be false
+     * if 'useRotation' is set to false.
+     *
+     */
+    backfaceVisible: boolean;
+    /**
+     * @remarks
+     * The color of the background plate of the text. If set to
+     * undefined, it will use the default color.
+     *
+     */
+    backgroundColorOverride?: RGBA;
+    /**
+     * @remarks
+     * If set to true, the text will be hidden behind blocks or
+     * entities. By default this is set to false (will always
+     * render).
+     *
+     */
+    depthTest: boolean;
+    /**
+     * @remarks
+     * Get the text of the debug text shape. Returns the RawText of
+     * the debug text if `setText` was called with a RawMessage or
+     * a RawText object, otherwise returns a string.
+     *
+     */
+    readonly text: RawMessage | string;
+    /**
+     * @remarks
+     * If set to true, the text primitive will render the back-face
+     * of the text. Defaults to true but will always be false if
+     * 'useRotation' is set to false.
+     *
+     */
+    textBackfaceVisible: boolean;
+    /**
+     * @remarks
+     * If set to true, the text will not face the camera and
+     * instead will use the rotation from the shape.
+     *
+     */
+    useRotation: boolean;
+    constructor(location: DimensionLocation | Vector3, text: RawMessage | string);
+    /**
+     * @remarks
+     * Sets the text to display.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link RawMessageError}
+     */
+    setText(text: RawMessage | string): void;
+}
+
 /**
  * This manager is used to add, remove or query temporary
  * ticking areas to a dimension. These ticking areas are
@@ -20363,6 +22496,151 @@ export class TripWireTripAfterEventSignal {
     unsubscribe(callback: (arg0: TripWireTripAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains information related to a script watchdog
+ * termination.
+ */
+export class WatchdogTerminateBeforeEvent {
+    private constructor();
+    /**
+     * @remarks
+     * If set to true, cancels the termination of the script
+     * runtime. Note that depending on server configuration
+     * settings, cancellation of the termination may not be
+     * allowed.
+     *
+     */
+    cancel: boolean;
+    /**
+     * @remarks
+     * Contains the reason why a script runtime is to be
+     * terminated.
+     *
+     */
+    readonly terminateReason: WatchdogTerminateReason;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to a callback that will
+ * be called when a script runtime is being terminated due to a
+ * violation of the performance watchdog system.
+ */
+export class WatchdogTerminateBeforeEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a script runtime is
+     * being terminated due to a violation of the performance
+     * watchdog system.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     * @returns
+     * Closure that is called with restricted-execution privilege.
+     */
+    subscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): (arg0: WatchdogTerminateBeforeEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a script runtime
+     * is being terminated due to a violation of the performance
+     * watchdog system.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     */
+    unsubscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Base class for waypoints displayed on the player's locator
+ * bar. Waypoints can track locations or entities and are
+ * rendered with customizable textures and colors.
+ *
+ * Waypoints act as shared handles that can be added to
+ * multiple players' locator bars. When you modify a waypoint's
+ * properties (such as color, texture, or enabled state), the
+ * changes are reflected for all players who have that waypoint
+ * in their locator bar. This allows you to efficiently manage
+ * waypoints across multiple players without creating separate
+ * instances for each player.
+ */
+export class Waypoint {
+    private constructor();
+    /**
+     * @remarks
+     * Optional {@link RGB} color tint applied to the waypoint
+     * icon. If not specified, the waypoint uses its default color.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    color?: RGB;
+    /**
+     * @remarks
+     * Controls whether the waypoint is currently displayed on the
+     * player's screen. When disabled, the waypoint is hidden but
+     * remains valid.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    isEnabled: boolean;
+    /**
+     * @remarks
+     * Returns whether the waypoint is currently valid. A waypoint
+     * becomes invalid when its tracked entity is no longer valid.
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * @remarks
+     * The {@link WaypointTextureSelector} that determines which
+     * icon texture is displayed for the waypoint based on distance
+     * or other criteria.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    textureSelector: WaypointTextureSelector;
+    /**
+     * @remarks
+     * Gets the current {@link DimensionLocation} of the waypoint.
+     * For entity waypoints, this returns the entity's current
+     * position. For location waypoints, this returns the stored
+     * location.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    getDimensionLocation(): DimensionLocation;
+    /**
+     * @remarks
+     * Removes the waypoint from all locator bars it has been added
+     * to. This affects all players who have this waypoint in their
+     * locator bar.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    remove(): void;
+}
+
 /**
  * Contains information related to changes in weather in the
  * environment.
@@ -20499,6 +22777,15 @@ export class World {
      *
      */
     readonly afterEvents: WorldAfterEvents;
+    /**
+     * @beta
+     * @remarks
+     * Enables or disables cheats.
+     *
+     * This property can't be edited in restricted-execution mode.
+     *
+     */
+    allowCheats: boolean;
     /**
      * @remarks
      * Contains a set of events that are applicable to the entirety
@@ -20543,6 +22830,14 @@ export class World {
      */
     readonly gameRules: GameRules;
     readonly isHardcore: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Manager for adding and removing primitive text objects in
+     * the world.
+     *
+     */
+    readonly primitiveShapesManager: PrimitiveShapesManager;
     /**
      * @remarks
      * Returns the general global scoreboard that applies to the
@@ -20568,7 +22863,21 @@ export class World {
      * ticking areas.
      *
      */
-    readonly tickingAreaManager: TickingAreaManager;
+    readonly tickingAreaManager: TickingAreaManager;
+    /**
+     * @beta
+     * @remarks
+     * A method that is internal-only, used for broadcasting
+     * specific messages between client and server.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param id
+     * The message identifier.
+     * @param value
+     * The message.
+     */
+    broadcastClientMessage(id: string, value: string): void;
     /**
      * @remarks
      * Clears the set of dynamic properties declared for this
@@ -20762,6 +23071,15 @@ export class World {
      *
      */
     getMoonPhase(): MoonPhase;
+    /**
+     * @beta
+     * @remarks
+     * Returns a map of pack setting name and value pairs.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    getPackSettings(): Record<string, boolean | number | string>;
     /**
      * @remarks
      * Returns a set of players based on a set of conditions
@@ -21052,6 +23370,16 @@ export class WorldAfterEvents {
      *
      */
     readonly buttonPush: ButtonPushAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly chatSend: ChatSendAfterEventSignal;
     /**
      * @remarks
      * This event is fired when an entity event has been triggered
@@ -21178,6 +23506,13 @@ export class WorldAfterEvents {
      *
      */
     readonly entitySpawn: EntitySpawnAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly entityUpgrade: EntityUpgradeAfterEventSignal;
     /**
      * @remarks
      * This event is fired after an explosion occurs.
@@ -21267,6 +23602,25 @@ export class WorldAfterEvents {
      *
      */
     readonly leverAction: LeverActionAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is an internal implementation detail, and is
+     * otherwise not currently functional.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly messageReceive: ServerMessageAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered when a pack setting is changed.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly packSettingChange: PackSettingChangeAfterEventSignal;
     /**
      * @remarks
      * This event fires when a piston expands or retracts.
@@ -21403,6 +23757,16 @@ export class WorldAfterEvents {
      *
      */
     readonly playerSwingStart: PlayerSwingStartAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * An event for when a player uses a named name tag on an
+     * entity.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly playerUseNameTag: PlayerUseNameTagAfterEventSignal;
     /**
      * @remarks
      * A pressure plate has popped back up (i.e., there are no
@@ -21479,6 +23843,43 @@ export class WorldAfterEvents {
  */
 export class WorldBeforeEvents {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     * This property can be read in early-execution mode.
+     *
+     * @example customCommand.ts
+     * ```typescript
+     * import { world, DimensionLocation } from '@minecraft/server';
+     *
+     * function customCommand(targetLocation: DimensionLocation) {
+     *   const chatCallback = world.beforeEvents.chatSend.subscribe(eventData => {
+     *     if (eventData.message.includes('cancel')) {
+     *       // Cancel event if the message contains "cancel"
+     *       eventData.cancel = true;
+     *     } else {
+     *       const args = eventData.message.split(' ');
+     *
+     *       if (args.length > 0) {
+     *         switch (args[0].toLowerCase()) {
+     *           case 'echo':
+     *             // Send a modified version of chat message
+     *             world.sendMessage(`Echo '${eventData.message.substring(4).trim()}'`);
+     *             break;
+     *           case 'help':
+     *             world.sendMessage(`Available commands: echo <message>`);
+     *             break;
+     *         }
+     *       }
+     *     }
+     *   });
+     * }
+     * ```
+     */
+    readonly chatSend: ChatSendBeforeEventSignal;
     /**
      * @remarks
      * This event is triggered after an event has been added to an
@@ -21572,6 +23973,15 @@ export class WorldBeforeEvents {
      *
      */
     readonly playerLeave: PlayerLeaveBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires before a block is placed by a player.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly playerPlaceBlock: PlayerPlaceBlockBeforeEventSignal;
     /**
      * @remarks
      * This property can be read in early-execution mode.
@@ -21649,13 +24059,27 @@ export interface BiomeFilter {
     includeTags?: string[];
 }
 
+/**
+ * @beta
+ * Contains additional options for searches for the
+ * dimension.findNearestBiome API.
+ */
+export interface BiomeSearchOptions {
+    /**
+     * @remarks
+     * Bounding volume size to look within.
+     *
+     */
+    boundingSize?: Vector3;
+}
+
 /**
  * A BlockBoundingBox is an interface to an object which
  * represents an AABB aligned rectangle.
  * The BlockBoundingBox assumes that it was created in a valid
  * state (min <= max) but cannot guarantee it (unless it was
- * created using the associated {@link
- * @minecraft/server.BlockBoundingBoxUtils} utility functions.
+ * created using the associated {@link BlockBoundingBoxUtils}
+ * utility functions.
  * The min/max coordinates represent the diametrically opposite
  * corners of the rectangle.
  * The BlockBoundingBox is not a representation of blocks - it
@@ -21715,6 +24139,10 @@ export interface BlockCustomComponent {
      *
      */
     beforeOnPlayerPlace?: (arg0: BlockComponentPlayerPlaceBeforeEvent, arg1: CustomComponentParameters) => void;
+    /**
+     * @beta
+     */
+    onBlockStateChange?: (arg0: BlockComponentBlockStateChangeEvent, arg1: CustomComponentParameters) => void;
     /**
      * @remarks
      * This function will be called when a specific block is
@@ -22102,6 +24530,40 @@ export interface CameraTargetOptions {
     targetEntity: Entity;
 }
 
+/**
+ * @beta
+ * This interface defines an entry into the {@link
+ * CompoundBlockVolume} which represents a volume of positive
+ * or negative space.
+ *
+ */
+export interface CompoundBlockVolumeItem {
+    /**
+     * @remarks
+     * The 'action' defines how the block volume is represented in
+     * the compound block volume stack.
+     * 'Add' creates a block volume which is positively selected
+     * 'Subtract' creates a block volume which represents a hole or
+     * negative space in the overall compound block volume.
+     *
+     */
+    action?: CompoundBlockVolumeAction;
+    /**
+     * @remarks
+     * The relativity enumeration determines whether the
+     * BlockVolume specified is positioned relative to the parent
+     * compound block volume origin, or in absolute world space.
+     *
+     */
+    locationRelativity?: CompoundBlockVolumePositionRelativity;
+    /**
+     * @remarks
+     * The volume of space
+     *
+     */
+    volume: BlockVolume;
+}
+
 /**
  * @rc
  * Represents the source of a container access.
@@ -22213,6 +24675,15 @@ export interface CustomCommand {
  * command.
  */
 export interface CustomCommandParameter {
+    /**
+     * @beta
+     * @remarks
+     * Can be used to reference the enum name when {@link
+     * CustomCommandParamType} is 'Enum'. Allows the parameter name
+     * to be different from the enum name.
+     *
+     */
+    enumName?: string;
     /**
      * @remarks
      * The name of parameter as it appears on the command line.
@@ -22246,6 +24717,35 @@ export interface CustomCommandResult {
     status: CustomCommandStatus;
 }
 
+/**
+ * @beta
+ */
+export interface CustomTexture {
+    /**
+     * @remarks
+     * The height of the icon, in relative units. Value must be
+     * between 0.0 and 1.0, inclusive.
+     *
+     * Bounds: [0, 1]
+     */
+    iconHeight: number;
+    /**
+     * @remarks
+     * The width of the icon, in relative units. Value must be
+     * between 0.0 and 1.0, inclusive.
+     *
+     * Bounds: [0, 1]
+     */
+    iconWidth: number;
+    /**
+     * @remarks
+     * The resource path to the custom texture. This should be a
+     * valid string path to a texture asset.
+     *
+     */
+    path: string;
+}
+
 /**
  * Contains a set of updates to the component definition state
  * of an entity.
@@ -22265,6 +24765,14 @@ export interface DefinitionModifier {
      *
      */
     removedComponentGroups: string[];
+    /**
+     * @beta
+     * @remarks
+     * The list of entity definition events that will be fired via
+     * this update.
+     *
+     */
+    triggers: Trigger[];
 }
 
 /**
@@ -23066,6 +25574,37 @@ export interface EntityRaycastOptions extends EntityFilter {
     maxDistance?: number;
 }
 
+/**
+ * @beta
+ * Controls when a waypoint is visible based on the state of
+ * the entity it tracks. These rules allow filtering waypoint
+ * visibility by entity conditions like sneaking, invisibility,
+ * and death state.
+ */
+export interface EntityVisibilityRules {
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when the tracked
+     * entity is dead. If undefined, defaults to true.
+     *
+     */
+    showDead?: boolean;
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when the tracked
+     * entity is invisible. If undefined, defaults to true.
+     *
+     */
+    showInvisible?: boolean;
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when the tracked
+     * entity is sneaking. If undefined, defaults to true.
+     *
+     */
+    showSneaking?: boolean;
+}
+
 /**
  * Equal to operator.
  */
@@ -23472,6 +26011,27 @@ export interface NotEqualsComparison {
     notEquals: boolean | number | string;
 }
 
+/**
+ * @beta
+ * Contains information about a player's party membership. This
+ * object is a snapshot of the player's party state at the time
+ * it was retrieved and is not kept up to date.
+ */
+export interface PartyInfo {
+    /**
+     * @remarks
+     * Whether this player is the leader of their party.
+     *
+     */
+    isLeader: boolean;
+    /**
+     * @remarks
+     * The unique identifier of the party this player belongs to.
+     *
+     */
+    partyId: string;
+}
+
 /**
  * Contains additional options for how an animation is played.
  */
@@ -23591,6 +26151,39 @@ export interface PlayerSwingEventOptions {
     swingSource?: EntitySwingSource;
 }
 
+/**
+ * @beta
+ * Controls when a waypoint is visible based on player-specific
+ * states. Extends {@link EntityVisibilityRules} with
+ * additional rules for player-only states like hidden mode and
+ * spectator mode.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export interface PlayerVisibilityRules extends EntityVisibilityRules {
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when the tracked
+     * player is hidden. If undefined, defaults to true.
+     *
+     */
+    showHidden?: boolean;
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when the tracked
+     * player is in spectator mode. If undefined, defaults to true.
+     *
+     */
+    showSpectator?: boolean;
+    /**
+     * @remarks
+     * Controls whether the waypoint is shown when a spectator is
+     * viewing another spectator player. If undefined, defaults to
+     * true.
+     *
+     */
+    showSpectatorToSpectator?: boolean;
+}
+
 /**
  * Key frame that holds the progress of the camera animation.
  */
@@ -24287,6 +26880,60 @@ export interface VectorXZ {
     z: number;
 }
 
+/**
+ * @beta
+ * Defines a texture and the distance range in which it should
+ * be displayed. Used within a {@link WaypointTextureSelector}
+ * to create distance-based texture switching.
+ */
+export interface WaypointTextureBounds {
+    /**
+     * @remarks
+     * The lower distance bound for this texture. The texture is
+     * displayed when the distance to the waypoint is greater than
+     * this value. Value must be greater than or equal to 0.
+     *
+     * Minimum Value: 0
+     */
+    lowerBound: number;
+    /**
+     * @remarks
+     * The {@link WaypointTexture} or {@link CustomTexture} to
+     * display within this distance range.
+     *
+     */
+    texture: CustomTexture | WaypointTexture;
+    /**
+     * @remarks
+     * The upper distance bound for this texture. The texture is
+     * displayed when the distance to the waypoint is less than or
+     * equal to this value. If undefined, there is no upper limit.
+     * Value must be greater than or equal to 0.
+     *
+     * Minimum Value: 0
+     */
+    upperBound?: number;
+}
+
+/**
+ * @beta
+ * Defines how waypoint textures change based on distance.
+ * Contains a list of texture bounds that determine which
+ * texture is displayed at different distance ranges.
+ */
+export interface WaypointTextureSelector {
+    /**
+     * @remarks
+     * An array of {@link WaypointTextureBounds} that define which
+     * textures are displayed at different distance ranges. The
+     * system evaluates these bounds to determine the appropriate
+     * texture based on the current distance to the waypoint. The
+     * list has a maximum size limit of 16.
+     *
+     */
+    textureBoundsList: WaypointTextureBounds[];
+}
+
 /**
  * Contains additional options for a playSound occurrence.
  */
@@ -24422,6 +27069,48 @@ export class CustomComponentNameError extends Error {
     readonly reason: CustomComponentNameErrorReason;
 }
 
+/**
+ * @beta
+ * Thrown when trying to register a custom dimension with a
+ * name that has already been registered.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class CustomDimensionAlreadyRegisteredError extends Error {
+    private constructor();
+}
+
+/**
+ * @beta
+ * Thrown when trying to register a custom dimension outside of
+ * the system startup event.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class CustomDimensionInvalidRegistryError extends Error {
+    private constructor();
+}
+
+/**
+ * @beta
+ * Thrown when trying to register a custom dimension with a
+ * name that contains invalid characters.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class CustomDimensionNameError extends Error {
+    private constructor();
+}
+
+/**
+ * @beta
+ * Thrown after using the /reload command when trying to
+ * register a custom dimension that was not previously
+ * registered. New custom dimensions cannot be added during a
+ * reload.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class CustomDimensionReloadNewDimensionError extends Error {
+    private constructor();
+}
+
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EnchantmentLevelOutOfBoundsError extends Error {
     private constructor();
@@ -24546,6 +27235,25 @@ export class InvalidStructureError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ * Error thrown when attempting to perform operations on an
+ * invalid waypoint. A waypoint becomes invalid when it is
+ * removed or when the entity it tracks is no longer valid.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidWaypointError extends Error {
+    private constructor();
+}
+
+/**
+ * @beta
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidWaypointTextureSelectorError extends Error {
+    private constructor();
+}
+
 /**
  * Thrown when trying to register an item custom component with
  * a name that has already been registered.
@@ -24602,6 +27310,25 @@ export class LocationOutOfWorldBoundariesError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ * Error thrown when a locator bar operation fails. Contains a
+ * reason code indicating the specific cause of the error.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LocatorBarError extends Error {
+    private constructor();
+    /**
+     * @remarks
+     * The {@link LocatorBarErrorReason} code that indicates why
+     * the locator bar operation failed.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly reason: LocatorBarErrorReason;
+}
+
 /**
  * Thrown when a name requires a namespace and an error occurs
  * when validating that namespace
@@ -24622,6 +27349,14 @@ export class PlaceJigsawError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PrimitiveShapeError extends Error {
+    private constructor();
+}
+
 // @ts-ignore Class inheritance allowed for native defined classes
 export class RawMessageError extends Error {
     private constructor();