@minecraft/server 2.10.0-rc.1.26.50-preview.20 → 2.11.0-beta.1.26.50-preview.20

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.10.0"
+ *   "version": "2.11.0-beta"
  * }
  * ```
  *
@@ -47,6 +47,10 @@ export enum AimAssistTargetMode {
  * function Block.getComponent.
  */
 export enum BlockComponentTypes {
+    /**
+     * @beta
+     */
+    DynamicProperties = 'minecraft:dynamic_properties',
     FluidContainer = 'minecraft:fluid_container',
     /**
      * @rc
@@ -216,6 +220,34 @@ export enum CameraShakeType {
     Rotational = 'Rotational',
 }
 
+/**
+ * @beta
+ * An enumeration for the clone modes used when cloning blocks.
+ */
+export enum CloneMode {
+    /**
+     * @remarks
+     * Clones the blocks from the source region to the destination,
+     * leaving the source intact.
+     *
+     */
+    Copy = 0,
+    /**
+     * @remarks
+     * Clones the blocks from the source region to the destination,
+     * allowing the source and destination regions to overlap.
+     *
+     */
+    ForceCopy = 1,
+    /**
+     * @remarks
+     * Clones the blocks from the source region to the destination
+     * and replaces the source region with air.
+     *
+     */
+    Move = 2,
+}
+
 /**
  * The required permission level to execute the custom command.
  */
@@ -354,6 +386,13 @@ export enum CustomCommandErrorReason {
      *
      */
     RegistryReadOnly = 'RegistryReadOnly',
+    /**
+     * @beta
+     * @remarks
+     * Non enum type command parameters cannot use enumName.
+     *
+     */
+    UnexpectedEnumName = 'UnexpectedEnumName',
 }
 
 /**
@@ -1090,6 +1129,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.
@@ -1573,6 +1620,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
@@ -1842,6 +1897,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
@@ -2191,6 +2254,10 @@ export enum InputPermissionCategory {
  * function ItemStack.getComponent.
  */
 export enum ItemComponentTypes {
+    /**
+     * @beta
+     */
+    BlockDynamicProperties = 'minecraft:block_actor_dynamic_properties',
     /**
      * @remarks
      * The minecraft:book component.
@@ -2663,6 +2730,14 @@ export enum PlayerSplitScreenSlot {
     Third = 'Third',
 }
 
+/**
+ * @beta
+ */
+export enum PlayerWaypointsMode {
+    Everyone = 'Everyone',
+    Off = 'Off',
+}
+
 /**
  * Contains objectives and participants for the scoreboard.
  */
@@ -2989,6 +3064,29 @@ 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',
+}
+
 /**
  * Enum representing different texture icons that can be
  * displayed for waypoints on the locator bar.
@@ -3050,10 +3148,12 @@ export type BlockComponentReturnType<T extends string> = T extends keyof BlockCo
     : BlockCustomComponentInstance;
 
 export type BlockComponentTypeMap = {
+    dynamic_properties: BlockDynamicPropertiesComponent;
     fluid_container: BlockFluidContainerComponent;
     instrument_sound: BlockInstrumentComponent;
     inventory: BlockInventoryComponent;
     map_color: BlockMapColorComponent;
+    'minecraft:dynamic_properties': BlockDynamicPropertiesComponent;
     'minecraft:fluid_container': BlockFluidContainerComponent;
     'minecraft:instrument_sound': BlockInstrumentComponent;
     'minecraft:inventory': BlockInventoryComponent;
@@ -3175,6 +3275,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;
@@ -3208,6 +3309,7 @@ export type EntityComponentTypeMap = {
     'navigation.generic': EntityNavigationGenericComponent;
     'navigation.hover': EntityNavigationHoverComponent;
     'navigation.walk': EntityNavigationWalkComponent;
+    npc: EntityNpcComponent;
     onfire: EntityOnFireComponent;
     'player.exhaustion': EntityExhaustionComponent;
     'player.hunger': EntityHungerComponent;
@@ -3227,11 +3329,21 @@ 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;
 
 export type ItemComponentTypeMap = {
+    block_actor_dynamic_properties: ItemBlockDynamicPropertiesComponent;
     book: ItemBookComponent;
     compostable: ItemCompostableComponent;
     cooldown: ItemCooldownComponent;
@@ -3240,6 +3352,7 @@ export type ItemComponentTypeMap = {
     enchantable: ItemEnchantableComponent;
     food: ItemFoodComponent;
     inventory: ItemInventoryComponent;
+    'minecraft:block_actor_dynamic_properties': ItemBlockDynamicPropertiesComponent;
     'minecraft:book': ItemBookComponent;
     'minecraft:compostable': ItemCompostableComponent;
     'minecraft:cooldown': ItemCooldownComponent;
@@ -3252,6 +3365,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.
@@ -3409,7 +3531,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.
@@ -3428,7 +3552,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.
@@ -3627,8 +3753,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
@@ -3636,8 +3764,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
@@ -3645,8 +3775,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
@@ -3654,8 +3786,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.
@@ -3666,7 +3800,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
@@ -3677,7 +3811,7 @@ export class AimAssistPresetSettings {
      * @param items
      * An array of item Ids.
      */
-    setLiquidTargetingItems(items?: string[]): void;
+    setLiquidTargetingItems(items?: (keyof typeof minecraftvanilladata.MinecraftItemTypes | string)[]): void;
 }
 
 /**
@@ -3783,6 +3917,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.
  */
@@ -3876,6 +4032,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
@@ -4041,6 +4211,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
@@ -4137,6 +4331,15 @@ export class Block {
      * {@link LocationInUnloadedChunkError}
      */
     getLightLevel(): number;
+    /**
+     * @beta
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getMapColor(): RGBA;
     /**
      * @rc
      * @remarks
@@ -4418,6 +4621,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
@@ -4435,6 +4659,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.
  */
@@ -4657,6 +5012,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
@@ -4849,45 +5211,149 @@ export class BlockCustomComponentInstance extends BlockComponent {
 }
 
 /**
- * Contains information regarding an event that impacts a
- * specific block.
+ * @beta
+ * Represents the dynamic properties of a block in the world.
+ * Only available with block entities. Up to 1KB per content
+ * pack, per block entity in their dynamic properties storage.
+ * @example rememberPlayerInteraction.ts
+ * ```typescript
+ * import { system } from '@minecraft/server-v2';
+ *
+ * system.beforeEvents.startup.subscribe(initEvent => {
+ *   initEvent.blockComponentRegistry.registerCustomComponent('scripting_demo_pack:block_entity_onPlayerInteract', {
+ *     onPlayerInteract: e => {
+ *       if (e.player === undefined) {
+ *         return;
+ *       }
+ *
+ *       const dynamicProperties = e.block.getComponent('minecraft:dynamic_properties');
+ *       if (!dynamicProperties) {
+ *         return;
+ *       }
+ *
+ *       const lastInteractorValue = dynamicProperties.get('last_interactor');
+ *       const lastVisitor = typeof lastInteractorValue === 'string' ? lastInteractorValue : 'unknown';
+ *       const lastTick = Number(dynamicProperties.get('last_interact_tick') ?? system.currentTick);
+ *       const ticksAgo = Math.max(0, system.currentTick - lastTick);
+ *
+ *       if (lastVisitor === e.player.name) {
+ *         e.player.sendMessage("do you remember that player? I 'member, it was here " + String(ticksAgo) + ' ticks ago!');
+ *       } else {
+ *         e.player.sendMessage("oh, I don't remember that player");
+ *       }
+ *
+ *       dynamicProperties.set('last_interactor', e.player.name);
+ *       dynamicProperties.set('last_interact_tick', system.currentTick);
+ *     },
+ *   });
+ * });
+ * ```
  */
-export class BlockEvent {
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockDynamicPropertiesComponent extends BlockComponent {
     private constructor();
+    static readonly componentId = 'minecraft:dynamic_properties';
     /**
      * @remarks
-     * Block currently in the world at the location of this event.
+     * Returns a DynamicProperty that was stored with the provided
+     * key. Keys are unique to each content pack and cannot be used
+     * to retrieve dynamic properties set from other content packs.
+     * Returns undefined if the key was not found.
      *
-     */
-    readonly block: Block;
-    /**
-     * @remarks
-     * Dimension that contains the block that is the subject of
-     * this event.
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
      *
+     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly dimension: Dimension;
-}
-
-/**
- * Contains information regarding an explosion that has
- * occurred for a specific block.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockExplodeAfterEvent extends BlockEvent {
-    private constructor();
+    get(key: string): boolean | number | string | Vector3 | undefined;
     /**
      * @remarks
-     * Description of the block that has exploded.
+     * Sets a dynamic property with the provided key and value.
+     * Keys are unique to each content pack and cannot be used to
+     * set dynamic properties for other content packs. Values can
+     * be either a Number, a String or a Vector3. Setting a
+     * property with an undefined value will remove it from the
+     * storage. Storage size usage is counted towards the 1KBytes
+     * limit per content pack.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
      *
+     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly explodedBlockPermutation: BlockPermutation;
+    set(key: string, value?: boolean | number | string | Vector3): void;
     /**
      * @remarks
-     * Optional source of the explosion.
+     * Returns the current size, in bytes, of the dynamic
+     * properties storage for this block entity. The byte count
+     * only accounts for properties set by your content pack. The
+     * 1KBytes limit is per content pack.
      *
-     */
-    readonly source?: Entity;
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    totalByteCount(): number;
+}
+
+/**
+ * Contains information regarding an event that impacts a
+ * specific block.
+ */
+export class BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Block currently in the world at the location of this event.
+     *
+     */
+    readonly block: Block;
+    /**
+     * @remarks
+     * Dimension that contains the block that is the subject of
+     * this event.
+     *
+     */
+    readonly dimension: Dimension;
+}
+
+/**
+ * Contains information regarding an explosion that has
+ * occurred for a specific block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockExplodeAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Description of the block that has exploded.
+     *
+     */
+    readonly explodedBlockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * Optional source of the explosion.
+     *
+     */
+    readonly source?: Entity;
 }
 
 /**
@@ -5109,6 +5575,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.
@@ -6024,6 +6502,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)
@@ -6298,6 +6785,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
@@ -6333,6 +6837,24 @@ export class Camera {
     stopShaking(): void;
 }
 
+/**
+ * @beta
+ * Loot item function that will try to copy the block entity
+ * data from the destroyed block to the dropped item.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class CarryOverBlockEntityDataFunction extends LootItemFunction {
+    private constructor();
+    /**
+     * @remarks
+     * If true, and if the block entity had dynamic_properties, the
+     * function will copy the dynamic properties from the block
+     * entity to the dropped item.
+     *
+     */
+    readonly dynamicProperties: boolean;
+}
+
 /**
  * CatmullRom spline creation.
  */
@@ -6347,6 +6869,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.
  */
@@ -6555,7 +7235,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}
      *
@@ -6793,6 +7475,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}
      *
@@ -7451,6 +8135,40 @@ export class Dimension {
         biomeToFind: BiomeType | string,
         options?: BiomeSearchOptions,
     ): Vector3 | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Clones a region of blocks from one area of the dimension to
+     * another.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param beginLocation
+     * The lower northwest starting corner of the area to clone
+     * from.
+     * @param endLocation
+     * The upper southeast ending corner of the area to clone from.
+     * @param destination
+     * The lower northwest starting corner of the area to clone to.
+     * @param cloneMode
+     * Specifies how the cloned blocks should be placed at the
+     * destination.
+     * @param filter
+     * An optional block filter used to include only matching
+     * blocks from the source area.
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    cloneBlocks(
+        beginLocation: Vector3,
+        endLocation: Vector3,
+        destination: Vector3,
+        cloneMode: CloneMode,
+        filter?: BlockFilter,
+    ): void;
     /**
      * @remarks
      * Checks if an area contains the specified biomes. If the area
@@ -7691,10 +8409,14 @@ export class Dimension {
     /**
      * @rc
      * @remarks
-     * Gets all the blocks in a volume that satisfy the filter.
+     * Gets all the blocks in a volume that satisfy the block query
+     * options.
      *
      * @param volume
      * Volume of blocks that will be checked.
+     * @param options
+     * Block query options including filter criteria and optional
+     * closest/farthest distance sorting from a location.
      * @param allowUnloadedChunks
      * If set to true will suppress the UnloadedChunksError if some
      * or all of the block volume is outside of the loaded chunks.
@@ -7703,7 +8425,7 @@ export class Dimension {
      * Defaults to: false
      * @returns
      * Returns the ListBlockVolume that contains all the block
-     * locations that satisfied the block filter.
+     * locations that satisfied the block query options.
      * @throws This function can throw errors.
      *
      * {@link minecraftcommon.ArgumentOutOfBoundsError}
@@ -7828,6 +8550,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
@@ -7889,6 +8631,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
@@ -8134,7 +8886,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
@@ -8229,6 +8985,46 @@ export class Dimension {
      * ```
      */
     spawnParticle(effectName: string, location: Vector3, molangVariables?: MolangVariableMap): void;
+    /**
+     * @beta
+     * @remarks
+     * 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;
 }
 
 /**
@@ -8808,6 +9604,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,
@@ -10049,11 +10857,23 @@ export class EntityBaseMovementComponent extends EntityComponent {
 export class EntityBreathableComponent extends EntityComponent {
     private constructor();
     /**
+     * @beta
      * @remarks
-     * If true, this entity can breathe in air.
+     * The current air supply of the entity.
      *
-     * @throws This property can throw when used.
-     */
+     * 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.
+     *
+     * @throws This property can throw when used.
+     */
     readonly breathesAir: boolean;
     /**
      * @remarks
@@ -10076,6 +10896,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
@@ -12026,6 +12854,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
@@ -12698,6 +13562,102 @@ export class EntitySpawnAfterEventSignal {
     unsubscribe(callback: (arg0: EntitySpawnAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains data related to an entity beginning to sneak.
+ */
+export class EntityStartSneakingAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Entity that has started sneaking.
+     *
+     */
+    readonly entity: Entity;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to when an entity
+ * begins sneaking.
+ */
+export class EntityStartSneakingAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when an entity begins
+     * sneaking.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: EntityStartSneakingAfterEvent) => void,
+        options?: EntitySneakingChangedEventOptions,
+    ): (arg0: EntityStartSneakingAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when an entity begins
+     * sneaking.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: EntityStartSneakingAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Contains data related to an entity stopping sneaking.
+ */
+export class EntityStopSneakingAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Entity that has stopped sneaking.
+     *
+     */
+    readonly entity: Entity;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to when an entity stops
+ * sneaking.
+ */
+export class EntityStopSneakingAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when an entity stops
+     * sneaking.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: EntityStopSneakingAfterEvent) => void,
+        options?: EntitySneakingChangedEventOptions,
+    ): (arg0: EntityStopSneakingAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when an entity stops
+     * sneaking.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: EntityStopSneakingAfterEvent) => void): void;
+}
+
 /**
  * Defines the entity's ability to carry items. An entity with
  * a higher strength would have higher potential carry capacity
@@ -12996,7 +13956,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.
@@ -13401,6 +14361,138 @@ export class FluidContainer {
     static readonly minFillLevel = 0;
 }
 
+/**
+ * @beta
+ * Provides access to the fog definitions stack of a player
+ * entity, allowing scripts to push, pop, remove, and query
+ * active fog definitions.
+ */
+export class FogSettings {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the list of fog identifiers currently on the
+     * player's fog stack, ordered from bottom to top.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * An array of fog definition identifiers currently on the
+     * stack.
+     * @throws
+     * Throws if the entity is invalid.
+     *
+     * {@link InvalidEntityError}
+     */
+    getStack(): string[];
+    /**
+     * @remarks
+     * Returns the list of tags currently present on the player's
+     * fog stack.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @returns
+     * An array of tag strings associated with fog settings on the
+     * stack.
+     * @throws
+     * Throws if the entity is invalid.
+     *
+     * {@link InvalidEntityError}
+     */
+    getTags(): string[];
+    /**
+     * @remarks
+     * Removes the most recently pushed fog definition from the
+     * player's fog stack.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param tag
+     * An optional tag identifying which entry to pop. If provided,
+     * searches the stack from top to bottom and removes the most
+     * recently pushed entry with this tag. If omitted, removes the
+     * most recently pushed entry regardless of tag.
+     * @returns
+     * Returns the identifier of the popped fog definition, or
+     * undefined if the stack was unchanged.
+     * @throws
+     * Throws if the entity is invalid.
+     *
+     * {@link InvalidEntityError}
+     */
+    pop(tag?: string): string | undefined;
+    /**
+     * @remarks
+     * Pushes a new fog definition onto the player's fog stack.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param fogId
+     * The identifier of the fog definition to push onto the stack
+     * (e.g. 'minecraft:fog_bamboo_jungle').
+     * @param tag
+     * An optional tag used to label this fog definition on the
+     * stack, allowing it to be targeted by pop or remove. If
+     * omitted, the entry is stored with the tag 'untagged'.
+     * @returns
+     * Returns the zero-based index at which the fog definition was
+     * inserted into the stack.
+     * @throws
+     * Throws if the entity is invalid, the fog identifier is
+     * invalid, or if the stack limit of 16 has been exceeded.
+     *
+     * {@link FogSettingsError}
+     *
+     * {@link InvalidEntityError}
+     */
+    push(fogId: string, tag?: string): number;
+    /**
+     * @remarks
+     * Removes all fog definitions with the given tag from the
+     * player's fog stack. If no tag is provided, clears all fog
+     * definitions.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param tag
+     * An optional tag identifying which the entries to remove. If
+     * omitted, clears all fog definitions regardless of tag.
+     * @returns
+     * Returns true if at least one entry was removed, or false if
+     * the stack was unchanged.
+     * @throws
+     * Throws if the entity is invalid.
+     *
+     * {@link InvalidEntityError}
+     */
+    remove(tag?: string): boolean;
+    /**
+     * @remarks
+     * Sets the player's fog stack to the given list of fog
+     * identifiers, replacing any existing entries.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param fogIds
+     * A stack of fog definition identifiers to set on the player's
+     * fog stack (e.g. ['minecraft:fog_bamboo_jungle']). Maximum of
+     * 16 entries.
+     * @param tag
+     * An optional tag to associate with the new entries, used to
+     * target them with pop or remove.
+     * @throws
+     * Throws if the entity is invalid, if more than 16 fog
+     * identifiers are provided, or if any fog identifier is
+     * invalid.
+     *
+     * {@link FogSettingsError}
+     *
+     * {@link InvalidEntityError}
+     */
+    setStack(fogIds: string[], tag?: string): void;
+}
+
 /**
  * Contains information regarding a changed world.gameRules
  * property.
@@ -13590,6 +14682,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.
@@ -13737,6 +14836,62 @@ export class ISerializable {
     private constructor();
 }
 
+/**
+ * @beta
+ * Represents the dynamic properties of a block. Only available
+ * from block entities. Up to 1KBytes of data can be stored per
+ * content pack per block entity in their dynamic properties
+ * storage.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class ItemBlockDynamicPropertiesComponent extends ItemComponent {
+    private constructor();
+    static readonly componentId = 'minecraft:block_actor_dynamic_properties';
+    /**
+     * @remarks
+     * Returns a DynamicProperty that was stored with the provided
+     * key. Keys are unique to each content pack and cannot be used
+     * to retrieve dynamic properties set from other content packs.
+     * Returns undefined if the key was not found.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     */
+    get(key: string): boolean | number | string | Vector3 | undefined;
+    /**
+     * @remarks
+     * Sets a dynamic property with the provided key and value.
+     * Keys are unique to each content pack and cannot be used to
+     * set dynamic properties for other content packs. Values can
+     * be either a Number, a String or a Vector3. Setting a
+     * property with an undefined value will remove it from the
+     * storage. Storage size usage is counted towards the 1KBytes
+     * limit per content pack.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     */
+    set(key: string, value?: boolean | number | string | Vector3): void;
+    /**
+     * @remarks
+     * Returns the current size, in bytes, of the dynamic
+     * properties storage for this block. The byte count only
+     * accounts for properties set by your content pack. The
+     * 1KBytes limit is per content pack.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidItemStackError}
+     */
+    totalByteCount(): number;
+}
+
 /**
  * When present on an item, this item is a book item. Can
  * access and modify the contents of the book and sign it.
@@ -16450,6 +17605,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.
@@ -16519,29 +17701,72 @@ export class MolangVariableMap {
 }
 
 /**
- * Loot item condition that checks whether the looting entity
- * is currently a passenger of a specific type of entity.
+ * @beta
+ * Pack setting name and value that changed.
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PassengerOfEntityCondition extends LootItemCondition {
+export class PackSettingChangeAfterEvent {
     private constructor();
     /**
      * @remarks
-     * The entity type required for this condition to pass.
+     * The name of the setting.
      *
      */
-    readonly entityType: string;
+    readonly settingName: string;
+    /**
+     * @remarks
+     * The value of the setting.
+     *
+     */
+    readonly settingValue: boolean | number | string;
 }
 
 /**
- * Contains information related to changes to a piston
- * expanding or retracting.
- * @example pistonAfterEvent.ts
- * ```typescript
- * import {
- *   world,
- *   system,
- *   BlockPermutation,
+ * @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.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PassengerOfEntityCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The entity type required for this condition to pass.
+     *
+     */
+    readonly entityType: string;
+}
+
+/**
+ * Contains information related to changes to a piston
+ * expanding or retracting.
+ * @example pistonAfterEvent.ts
+ * ```typescript
+ * import {
+ *   world,
+ *   system,
+ *   BlockPermutation,
  *   BlockPistonState,
  *   PistonActivateAfterEvent,
  *   DimensionLocation,
@@ -16685,6 +17910,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.
@@ -16698,6 +17979,14 @@ export class Player extends Entity {
      *
      */
     commandPermissionLevel: CommandPermissionLevel;
+    /**
+     * @beta
+     * @remarks
+     * Contains methods for manipulating the render distance fog
+     * settings of a Player.
+     *
+     */
+    readonly fogSettings: FogSettings;
     /**
      * @remarks
      * Gets the current graphics mode of the player's client. This
@@ -16781,6 +18070,19 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly onScreenDisplay: ScreenDisplay;
+    /**
+     * @beta
+     * @remarks
+     * An identifier that can be used to identify a player across
+     * sessions.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly persistentId: string;
     /**
      * @throws This property can throw when used.
      *
@@ -16854,6 +18156,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.
@@ -16887,6 +18203,20 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     getItemCooldown(cooldownCategory: string): number;
+    /**
+     * @beta
+     * @remarks
+     * Gets the player's ping in milliseconds.
+     *
+     * @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.
@@ -16894,6 +18224,21 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     getSpawnPoint(): DimensionLocation | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the split screen slot of the player.
+     *
+     * @returns
+     * The split screen slot of the player or undefined if the
+     * player is not in a split screen session.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidEntityError}
+     */
+    getSplitScreenSlot(): PlayerSplitScreenSlot | undefined;
     /**
      * @remarks
      *  Gets the total experience of the Player.
@@ -16957,7 +18302,18 @@ export class Player extends Entity {
      * }
      * ```
      */
-    playSound(soundId: string, soundOptions?: PlayerSoundOptions): SoundInstance;
+    playSound(soundId: SoundDefinition | string, soundOptions?: PlayerSoundOptions): SoundInstance;
+    /**
+     * @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
@@ -17233,6 +18589,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
@@ -17243,6 +18611,20 @@ 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;
 }
 
 /**
@@ -18604,6 +19986,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.
@@ -18792,6 +20256,80 @@ 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;
+}
+
 /**
  * Waypoint that tracks a player's position. Extends {@link
  * EntityWaypoint} with additional player-specific visibility
@@ -18907,10 +20445,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;
 }
 
 /**
@@ -19153,6 +20691,18 @@ export class PrimitiveShapesManager {
      * {@link PrimitiveShapeError}
      */
     addText(text: TextPrimitive, dimension?: Dimension): void;
+    /**
+     * @beta
+     * @remarks
+     * Fetches and queries all primitive shapes stored in the
+     * manager and returns the results as an array of shape
+     * handles.
+     *
+     * @param options
+     * Optional options for querying existing shapes to narrow down
+     * the results.
+     */
+    getShapes(options?: PrimitiveShapeQueryOptions): PrimitiveShape[];
     /**
      * @remarks
      * Removes all text primitives from the world.
@@ -20117,6 +21667,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.
@@ -20145,6 +21727,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.
@@ -20437,6 +22034,73 @@ export class SoundCompletedAfterEventSignal {
     unsubscribe(callback: (arg0: SoundCompletedAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Static metadata about a sound declared in a
+ * sound_definitions.json file.
+ */
+export class SoundDefinition {
+    private constructor();
+    /**
+     * @remarks
+     * Duration metadata declared for this sound. Undefined when
+     * the sound definition does not specify a duration.
+     *
+     */
+    readonly durationInfo?: SoundDefinitionDurationInfo;
+    /**
+     * @remarks
+     * Music metadata declared for this sound. Undefined when the
+     * sound definition does not specify a music_info block.
+     *
+     */
+    readonly musicInfo?: SoundDefinitionMusicInfo;
+    /**
+     * @remarks
+     * Identifier of the sound event this definition declares, in
+     * the form 'namespace:name'.
+     *
+     */
+    readonly soundEventId: string;
+    /**
+     * @remarks
+     * Tag metadata declared for this sound, as a record mapping
+     * each tag name to its declared values. A tag declared with a
+     * single string value is exposed as a single-element array.
+     * Undefined when the sound definition does not specify any
+     * tags.
+     *
+     */
+    readonly tags?: Record<string, string[]>;
+}
+
+/**
+ * @beta
+ * Provides read-only access to the sound definitions loaded
+ * for the current world.
+ */
+export class SoundDefinitionRegistry {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the sound definitions in the registry, optionally
+     * narrowed by a filter.
+     *
+     * @param filter
+     * Optional filter applied to each definition. When omitted,
+     * every definition is returned.
+     * @returns
+     * All sound definitions matching the filter, or every sound
+     * definition when no filter is supplied.
+     * @throws
+     * An error will be thrown if filter.minDuration is greater
+     * than filter.maxDuration.
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     */
+    getDefinitions(filter?: SoundDefinitionFilter): SoundDefinition[];
+}
+
 /**
  * @rc
  * Provides duration and playback information for a sound whose
@@ -20510,6 +22174,84 @@ export class SoundInstance {
      *
      */
     readonly soundEventId: string;
+    /**
+     * @beta
+     * @remarks
+     * Fades this sound instance from its current volume to the
+     * target volume over the specified duration. To fade in from
+     * silence, call `setVolume(0.0)` first; to fade out, pass a
+     * target volume of `0.0`.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param duration
+     * Duration of the fade in seconds. Must be non-negative.
+     * Minimum value: 0
+     * @param targetVolume
+     * Volume to fade to. Must be non-negative.
+     * Minimum value: 0
+     */
+    fade(duration: number, targetVolume: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Pauses this sound.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    pause(): void;
+    /**
+     * @beta
+     * @remarks
+     * Resumes this sound after a pause.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     */
+    resume(): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the playback position of this sound instance.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param seconds
+     * Position to seek to in seconds. Must be non-negative.
+     * Bounds: [0, 107374184]
+     * @throws
+     * Throws if `seconds` is negative, or if the sound has a known
+     * duration and `seconds` is greater than that duration.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     */
+    seekTo(seconds: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the pitch of this sound instance.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param pitch
+     * Pitch multiplier between 0.01 and 10.0. A value of 1.0 is
+     * normal pitch.
+     * Bounds: [0.009999999776482582, 10]
+     */
+    setPitch(pitch: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the volume of this sound instance.
+     *
+     * This function can't be called in restricted-execution mode.
+     *
+     * @param volume
+     * Volume level between 0.0 and 10.0.
+     * Bounds: [0, 10]
+     */
+    setVolume(volume: number): void;
     /**
      * @rc
      * @remarks
@@ -21234,6 +22976,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;
 }
 
 /**
@@ -21341,6 +23096,14 @@ export class TextPrimitive extends PrimitiveShape {
      *
      */
     depthTest: boolean;
+    /**
+     * @beta
+     * @remarks
+     * This value determines the gap between lines for the
+     * TextPrimitive. By default the line gap height is 0.
+     *
+     */
+    lineGapHeight: number;
     /**
      * @remarks
      * Get the text of the debug text shape. Returns the RawText of
@@ -21619,6 +23382,71 @@ 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;
+}
+
 /**
  * Base class for waypoints displayed on the player's locator
  * bar. Waypoints can track locations or entities and are
@@ -21834,6 +23662,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
@@ -21898,6 +23735,14 @@ export class World {
      *
      */
     readonly seed: string;
+    /**
+     * @beta
+     * @remarks
+     * Provides read-only access to the sound definitions loaded
+     * for this world.
+     *
+     */
+    readonly soundDefinitionRegistry: SoundDefinitionRegistry;
     /**
      * @remarks
      * Returns the manager for {@link Structure} related APIs.
@@ -21911,6 +23756,20 @@ export class World {
      *
      */
     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
@@ -22400,6 +24259,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
@@ -22524,6 +24393,24 @@ export class WorldAfterEvents {
      *
      */
     readonly entitySpawn: EntitySpawnAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires when an entity starts sneaking.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly entityStartSneaking: EntityStartSneakingAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires when an entity stops sneaking.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly entityStopSneaking: EntityStopSneakingAfterEventSignal;
     /**
      * @rc
      * @remarks
@@ -22628,6 +24515,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.
@@ -22782,6 +24688,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
@@ -22867,6 +24783,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
@@ -22969,6 +24922,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.
@@ -23065,8 +25027,8 @@ export interface BiomeSearchOptions {
  * 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
@@ -23694,6 +25656,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.
@@ -23772,6 +25743,14 @@ export interface DefinitionModifier {
      *
      */
     removedComponentGroups: string[];
+    /**
+     * @beta
+     * @remarks
+     * The list of entity definition events that will be fired via
+     * this update.
+     *
+     */
+    triggers: Trigger[];
 }
 
 /**
@@ -24572,6 +26551,15 @@ export interface EntityRaycastOptions extends EntityFilter {
     maxDistance?: number;
 }
 
+/**
+ * @beta
+ * Options used to filter entity start sneaking and stop
+ * sneaking events.
+ */
+export interface EntitySneakingChangedEventOptions {
+    entityFilter?: EntityFilter;
+}
+
 /**
  * @rc
  * Contains options for filtering entity tamed events.
@@ -25124,6 +27112,19 @@ export interface PlayerSoundOptions {
      *
      */
     location?: Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Number of additional times to repeat the sound after the
+     * initial play. `0` (the default) plays the sound once, `-1`
+     * loops it forever, and a positive integer `N` plays the sound
+     * `N + 1` times in total. For example, `loopCount: 1` plays
+     * the sound twice. The loop count is fixed when the sound
+     * starts and cannot be changed afterward. When using `-1`, see
+     * `SoundInstance` for handle lifetime requirements.
+     *
+     */
+    loopCount?: number;
     /**
      * @remarks
      * Optional pitch of the sound.
@@ -25195,6 +27196,43 @@ export interface PlayerVisibilityRules extends EntityVisibilityRules {
     showSpectatorToSpectator?: boolean;
 }
 
+/**
+ * @beta
+ * Contains optional filters that control which primitive
+ * shapes are returned from a primitive shapes query.
+ */
+export interface PrimitiveShapeQueryOptions {
+    /**
+     * @remarks
+     * If specified, only returns shapes attached to this entity.
+     *
+     */
+    attachedTo?: Entity;
+    /**
+     * @remarks
+     * Adds a seed location to the query that is used in
+     * conjunction with distance properties.
+     *
+     */
+    location?: Vector3;
+    /**
+     * @remarks
+     * If specified, only includes shapes that are less than this
+     * distance away from the location specified in the location
+     * property.
+     *
+     */
+    maxDistance?: number;
+    /**
+     * @remarks
+     * If specified, only includes shapes that are at least this
+     * distance away from the location specified in the location
+     * property.
+     *
+     */
+    minDistance?: number;
+}
+
 /**
  * Key frame that holds the progress of the camera animation.
  */
@@ -25516,6 +27554,136 @@ export interface ScriptEventMessageFilterOptions {
     namespaces: string[];
 }
 
+/**
+ * @beta
+ * Duration metadata declared in a sound definition.
+ */
+export interface SoundDefinitionDurationInfo {
+    /**
+     * @remarks
+     * Total duration of the sound in seconds, as declared in the
+     * sound definition.
+     *
+     */
+    duration: number;
+}
+
+/**
+ * @beta
+ * Criteria used to narrow a set of sound definitions. Each
+ * field is optional and applies its constraint only when
+ * defined; a definition must satisfy every defined field to
+ * pass.
+ */
+export interface SoundDefinitionFilter {
+    /**
+     * @remarks
+     * Artist names to match against the definition's
+     * music_info.artist. Comparison is case-insensitive. When
+     * defined as a non-empty array, a definition passes only when
+     * its declared artist matches one of the supplied values. When
+     * undefined, no constraint on artist is applied.
+     *
+     */
+    artists?: string[];
+    /**
+     * @remarks
+     * Genres to match against the definition's music_info.genres.
+     * Comparison is case-insensitive. When defined as a non-empty
+     * array, a definition passes only when at least one of its
+     * declared genres matches one of the supplied values. When
+     * undefined, no constraint on genres is applied.
+     *
+     */
+    genres?: string[];
+    /**
+     * @remarks
+     * Upper bound in seconds, inclusive. When defined, definitions
+     * with a longer duration and definitions without a declared
+     * duration are excluded. When undefined, no upper bound is
+     * applied.
+     *
+     */
+    maxDuration?: number;
+    /**
+     * @remarks
+     * Lower bound in seconds, inclusive. When defined, definitions
+     * with a shorter duration and definitions without a declared
+     * duration are excluded. When undefined, no lower bound is
+     * applied.
+     *
+     */
+    minDuration?: number;
+    /**
+     * @remarks
+     * Moods to match against the definition's music_info.moods.
+     * Comparison is case-insensitive. When defined as a non-empty
+     * array, a definition passes only when at least one of its
+     * declared moods matches one of the supplied values. When
+     * undefined, no constraint on moods is applied.
+     *
+     */
+    moods?: string[];
+    /**
+     * @remarks
+     * Tag constraints to match against the definition's tags.
+     * Comparisons of tag names and values are case-insensitive.
+     * When defined as a non-empty record, a definition passes only
+     * when, for each entry with a non-empty value array, the tag
+     * name is present on the definition with at least one matching
+     * value. When undefined, no constraint on tags is applied.
+     *
+     */
+    tags?: Record<string, string[]>;
+    /**
+     * @remarks
+     * Titles to match against the definition's music_info.title.
+     * Comparison is case-insensitive. When defined as a non-empty
+     * array, a definition passes only when its declared title
+     * matches one of the supplied values. When undefined, no
+     * constraint on title is applied.
+     *
+     */
+    titles?: string[];
+}
+
+/**
+ * @beta
+ * Music metadata declared on a sound definition. Each field is
+ * optional and is undefined when the sound definition does not
+ * declare a value for it.
+ */
+export interface SoundDefinitionMusicInfo {
+    /**
+     * @remarks
+     * Artist declared for this sound. Undefined when no artist was
+     * declared.
+     *
+     */
+    artist?: string;
+    /**
+     * @remarks
+     * Genres declared for this sound. Undefined when no genres
+     * were declared.
+     *
+     */
+    genres?: string[];
+    /**
+     * @remarks
+     * Moods declared for this sound. Undefined when no moods were
+     * declared.
+     *
+     */
+    moods?: string[];
+    /**
+     * @remarks
+     * Title declared for this sound. Undefined when no title was
+     * declared.
+     *
+     */
+    title?: string;
+}
+
 /**
  * Contains additional options for spawning an Entity.
  */
@@ -25947,6 +28115,19 @@ export interface WaypointTextureSelector {
  * Contains additional options for a playSound occurrence.
  */
 export interface WorldSoundOptions {
+    /**
+     * @beta
+     * @remarks
+     * Number of additional times to repeat the sound after the
+     * initial play. `0` (the default) plays the sound once, `-1`
+     * loops it forever, and a positive integer `N` plays the sound
+     * `N + 1` times in total. For example, `loopCount: 1` plays
+     * the sound twice. The loop count is fixed when the sound
+     * starts and cannot be changed afterward. When using `-1`, see
+     * `SoundInstance` for handle lifetime requirements.
+     *
+     */
+    loopCount?: number;
     /**
      * @remarks
      * Pitch of the sound played.
@@ -26136,6 +28317,17 @@ export class EntitySpawnError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ * Error thrown by {@link FogSettings} operations when the fog
+ * stack limit is exceeded or an invalid fog identifier is
+ * provided.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class FogSettingsError extends Error {
+    private constructor();
+}
+
 /**
  * The error can occur when a block is invalid. This can also
  * occur when accessing components on a block that doesn't have