@minecraft/server 2.12.0-rc.1.26.70-preview.20 → 2.13.0-beta.1.26.70-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.12.0"
+ *   "version": "2.13.0-beta"
  * }
  * ```
  *
@@ -48,6 +48,10 @@ export enum AimAssistTargetMode {
  */
 export enum BlockComponentTypes {
     DynamicProperties = 'minecraft:dynamic_properties',
+    /**
+     * @beta
+     */
+    EntityStorage = 'minecraft:entity_storage',
     FluidContainer = 'minecraft:fluid_container',
     Instrument = 'minecraft:instrument_sound',
     /**
@@ -83,6 +87,14 @@ export enum BlockComponentTypes {
      *
      */
     PrecipitationInteractions = 'minecraft:precipitation_interactions',
+    /**
+     * @beta
+     */
+    RecipeCrafting = 'minecraft:recipe_crafting',
+    /**
+     * @beta
+     */
+    RecipeProcessing = 'minecraft:recipe_processing',
     /**
      * @remarks
      * Represents a block that can play a record.
@@ -101,6 +113,10 @@ export enum BlockComponentTypes {
      *
      */
     Sign = 'minecraft:sign',
+    /**
+     * @beta
+     */
+    VibrationProperties = 'minecraft:vibration_properties',
 }
 
 /**
@@ -377,6 +393,13 @@ export enum CustomCommandErrorReason {
      *
      */
     RegistryReadOnly = 'RegistryReadOnly',
+    /**
+     * @beta
+     * @remarks
+     * Non enum type command parameters cannot use enumName.
+     *
+     */
+    UnexpectedEnumName = 'UnexpectedEnumName',
 }
 
 /**
@@ -1112,6 +1135,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.
@@ -1595,6 +1626,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
@@ -1864,6 +1903,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
@@ -2215,6 +2262,10 @@ export enum InputPermissionCategory {
  */
 export enum ItemComponentTypes {
     BlockDynamicProperties = 'minecraft:block_actor_dynamic_properties',
+    /**
+     * @beta
+     */
+    BlockEntityStorage = 'minecraft:block_entity_storage',
     /**
      * @remarks
      * The minecraft:book component.
@@ -2586,6 +2637,31 @@ export enum PaletteColor {
     Black = 15,
 }
 
+/**
+ * @beta
+ * Specifies the pose of an entity passenger of a block.
+ */
+export enum PassengerOfBlockEmoteType {
+    /**
+     * @remarks
+     * The entity will be laying on the block.
+     *
+     */
+    Laying = 'Laying',
+    /**
+     * @remarks
+     * The entity will be sitting on the block.
+     *
+     */
+    Riding = 'Riding',
+    /**
+     * @remarks
+     * The entity will be standing on the block.
+     *
+     */
+    Standing = 'Standing',
+}
+
 /**
  * Describes what kind of platform is a device.
  */
@@ -2686,6 +2762,42 @@ export enum PlayerSplitScreenSlot {
     Third = 'Third',
 }
 
+/**
+ * @beta
+ */
+export enum PlayerWaypointsMode {
+    Everyone = 'Everyone',
+    Off = 'Off',
+}
+
+/**
+ * @beta
+ * Specifies how a block point-of-interest query filters
+ * instances by ticket occupancy.
+ */
+export enum PoiBlockOccupancyFilter {
+    /**
+     * @remarks
+     * Includes POI instances regardless of their occupancy or
+     * available ticket count.
+     *
+     */
+    Any = 'Any',
+    /**
+     * @remarks
+     * Includes POI instances with no available tickets.
+     *
+     */
+    Full = 'Full',
+    /**
+     * @remarks
+     * Includes POI instances with at least one ticket available to
+     * be claimed.
+     *
+     */
+    HasVacancy = 'HasVacancy',
+}
+
 /**
  * Contains objectives and participants for the scoreboard.
  */
@@ -3011,6 +3123,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.
@@ -3073,11 +3208,13 @@ export type BlockComponentReturnType<T extends string> = T extends keyof BlockCo
 
 export type BlockComponentTypeMap = {
     dynamic_properties: BlockDynamicPropertiesComponent;
+    entity_storage: BlockEntityStorageComponent;
     fluid_container: BlockFluidContainerComponent;
     instrument_sound: BlockInstrumentComponent;
     inventory: BlockInventoryComponent;
     map_color: BlockMapColorComponent;
     'minecraft:dynamic_properties': BlockDynamicPropertiesComponent;
+    'minecraft:entity_storage': BlockEntityStorageComponent;
     'minecraft:fluid_container': BlockFluidContainerComponent;
     'minecraft:instrument_sound': BlockInstrumentComponent;
     'minecraft:inventory': BlockInventoryComponent;
@@ -3085,15 +3222,21 @@ export type BlockComponentTypeMap = {
     'minecraft:movable': BlockMovableComponent;
     'minecraft:piston': BlockPistonComponent;
     'minecraft:precipitation_interactions': BlockPrecipitationInteractionsComponent;
+    'minecraft:recipe_crafting': BlockRecipeCraftingComponent;
+    'minecraft:recipe_processing': BlockRecipeProcessingComponent;
     'minecraft:record_player': BlockRecordPlayerComponent;
     'minecraft:redstone_producer': BlockRedstoneProducerComponent;
     'minecraft:sign': BlockSignComponent;
+    'minecraft:vibration_properties': BlockVibrationPropertiesComponent;
     movable: BlockMovableComponent;
     piston: BlockPistonComponent;
     precipitation_interactions: BlockPrecipitationInteractionsComponent;
+    recipe_crafting: BlockRecipeCraftingComponent;
+    recipe_processing: BlockRecipeProcessingComponent;
     record_player: BlockRecordPlayerComponent;
     redstone_producer: BlockRedstoneProducerComponent;
     sign: BlockSignComponent;
+    vibration_properties: BlockVibrationPropertiesComponent;
 };
 
 /**
@@ -3197,6 +3340,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;
@@ -3230,6 +3374,7 @@ export type EntityComponentTypeMap = {
     'navigation.generic': EntityNavigationGenericComponent;
     'navigation.hover': EntityNavigationHoverComponent;
     'navigation.walk': EntityNavigationWalkComponent;
+    npc: EntityNpcComponent;
     onfire: EntityOnFireComponent;
     'player.exhaustion': EntityExhaustionComponent;
     'player.hunger': EntityHungerComponent;
@@ -3249,12 +3394,22 @@ 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;
+    block_entity_storage: ItemBlockEntityStorageComponent;
     book: ItemBookComponent;
     compostable: ItemCompostableComponent;
     cooldown: ItemCooldownComponent;
@@ -3264,6 +3419,7 @@ export type ItemComponentTypeMap = {
     food: ItemFoodComponent;
     inventory: ItemInventoryComponent;
     'minecraft:block_actor_dynamic_properties': ItemBlockDynamicPropertiesComponent;
+    'minecraft:block_entity_storage': ItemBlockEntityStorageComponent;
     'minecraft:book': ItemBookComponent;
     'minecraft:compostable': ItemCompostableComponent;
     'minecraft:cooldown': ItemCooldownComponent;
@@ -3276,6 +3432,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.
@@ -3433,7 +3598,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.
@@ -3452,7 +3619,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.
@@ -3651,8 +3820,10 @@ export class AimAssistPresetSettings {
      *
      * @privilege no-restricted-execution - 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
@@ -3660,8 +3831,10 @@ export class AimAssistPresetSettings {
      *
      * @privilege no-restricted-execution - 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
@@ -3669,8 +3842,10 @@ export class AimAssistPresetSettings {
      *
      * @privilege no-restricted-execution - 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
@@ -3678,8 +3853,10 @@ export class AimAssistPresetSettings {
      *
      * @privilege no-restricted-execution - 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.
@@ -3690,7 +3867,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
@@ -3701,7 +3878,7 @@ export class AimAssistPresetSettings {
      * @param items
      * An array of item Ids.
      */
-    setLiquidTargetingItems(items?: string[]): void;
+    setLiquidTargetingItems(items?: (keyof typeof minecraftvanilladata.MinecraftItemTypes | string)[]): void;
 }
 
 /**
@@ -3807,6 +3984,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.
  */
@@ -3900,6 +4099,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
@@ -4065,6 +4278,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
@@ -4087,6 +4324,23 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     east(steps?: number): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the named tick events scheduled at this block by the
+     * calling script pack.
+     *
+     * @returns
+     * The scheduled named tick events. Each event contains its
+     * eventName and the number of ticks until it is raised as
+     * tickDelay.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getAllScheduledNamedTicks(): ScheduledNamedTick[];
     /**
      * @remarks
      * Gets a component (that represents additional capabilities)
@@ -4161,6 +4415,15 @@ export class Block {
      * {@link LocationInUnloadedChunkError}
      */
     getLightLevel(): number;
+    /**
+     * @beta
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getMapColor(): RGBA;
     /**
      * @remarks
      * Returns array of all loaded block parts if this block has
@@ -4188,6 +4451,22 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     getRedstonePower(): number | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the number of named tick events scheduled at this
+     * block, regardless of which script pack scheduled them.
+     *
+     * @returns
+     * The number of named tick events currently scheduled at this
+     * block.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getScheduledNamedTickCount(): number;
     /**
      * @remarks
      * Returns the brightness level of light shining from the sky
@@ -4233,6 +4512,15 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     hasComponent(componentId: string): boolean;
+    /**
+     * @beta
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    hasScheduledNamedTick(eventName: string): boolean;
     /**
      * @remarks
      * Checks to see if the permutation of this block has a
@@ -4373,6 +4661,47 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     offset(offset: Vector3): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Removes all scheduled named tick events from this block with
+     * the specified event name.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param eventName
+     * Name of the scheduled event to remove.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    removeScheduledNamedTicks(eventName: string): void;
+    /**
+     * @beta
+     * @remarks
+     * Schedules a named tick event for this block. The event will
+     * be delivered to block custom components registered with the
+     * `onNamedTick` callback after the specified delay.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param eventName
+     * Name of the event to schedule. Up to 31 characters.
+     * @param tickDelay
+     * Number of ticks to wait before the event is raised. Must be
+     * at least 1.
+     * Minimum value: 1
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    scheduleNamedTick(eventName: string, tickDelay: number): void;
     /**
      * @remarks
      * Sets the block in the dimension to the state of the
@@ -4441,6 +4770,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.
+     *
+     * @privilege no-restricted-execution - 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
@@ -4459,79 +4809,210 @@ export class Block {
 }
 
 /**
- * Base type for components associated with blocks.
+ * @beta
+ * Bounding Box Utils is a utility class that provides a number
+ * of useful functions for the creation and utility of
+ * {@link BlockBoundingBox} objects
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockComponent extends Component {
+export class BlockBoundingBoxUtils {
     private constructor();
     /**
      * @remarks
-     * Block instance that this component pertains to.
+     * Create a validated instance of a {@link BlockBoundingBox}
+     * where the min and max components are guaranteed to be (min
+     * <= max)
      *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param min
+     * A corner world location
+     * @param max
+     * A corner world location diametrically opposite
      */
-    readonly block: Block;
-}
-
-/**
- * Contains information regarding a specific block being
- * broken.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockComponentBlockBreakEvent extends BlockEvent {
-    private constructor();
+    static createValid(min: Vector3, max: Vector3): BlockBoundingBox;
     /**
      * @remarks
-     * The block that caused destruction.
+     * 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
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
+     * @returns
+     * Return a new {@link BlockBoundingBox} object representing
+     * the changes
      */
-    readonly blockDestructionSource?: Block;
+    static dilate(box: BlockBoundingBox, size: Vector3): BlockBoundingBox;
     /**
      * @remarks
-     * Returns permutation information about this block before it
-     * was broken.
+     * Check if two {@link BlockBoundingBox} objects are identical
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
      */
-    readonly brokenBlockPermutation: BlockPermutation;
+    static equals(box: BlockBoundingBox, other: BlockBoundingBox): boolean;
     /**
      * @remarks
-     * The Actor that caused destruction.
+     * 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.
+     *
+     * @privilege no-restricted-execution - 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
      */
-    readonly entitySource?: Entity;
-}
-
-/**
- * Contains information regarding a specific block permutation
- * that was changed from a previous permutation.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockComponentBlockStateChangeEvent extends BlockEvent {
-    private constructor();
+    static expand(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox;
     /**
      * @remarks
-     * The previous BlockPermutation.
+     * Calculate the center block of a given
+     * {@link BlockBoundingBox} object.
+     *
+     * @privilege no-restricted-execution - 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)
      */
-    readonly previousPermutation: BlockPermutation;
-}
-
-/**
- * Contains information regarding an event sent by an entity to
- * this block in the world.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockComponentEntityEvent extends BlockEvent {
-    private constructor();
+    static getCenter(box: BlockBoundingBox): Vector3;
     /**
      * @remarks
-     * Returns permutation information about the block receiving
-     * the event.
+     * Calculate the BlockBoundingBox which represents the union
+     * area of two intersecting BlockBoundingBoxes
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
      */
-    readonly blockPermutation: BlockPermutation;
+    static getIntersection(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox | undefined;
     /**
      * @remarks
-     * The entity that sent the event.
+     * Get the Span of each of the BlockBoundingBox Axis components
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     */
+    static getSpan(box: BlockBoundingBox): Vector3;
+    /**
+     * @remarks
+     * Check to see if two BlockBoundingBox objects intersect
+     *
+     * @privilege no-restricted-execution - 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
+     *
+     * @privilege no-restricted-execution - 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))
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     */
+    static isValid(box: BlockBoundingBox): boolean;
+    /**
+     * @remarks
+     * Move a BlockBoundingBox by a given amount
+     *
+     * @privilege no-restricted-execution - 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.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponent extends Component {
+    private constructor();
+    /**
+     * @remarks
+     * Block instance that this component pertains to.
+     *
+     */
+    readonly block: Block;
+}
+
+/**
+ * Contains information regarding a specific block being
+ * broken.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentBlockBreakEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The block that caused destruction.
+     *
+     */
+    readonly blockDestructionSource?: Block;
+    /**
+     * @remarks
+     * Returns permutation information about this block before it
+     * was broken.
+     *
+     */
+    readonly brokenBlockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * The Actor that caused destruction.
+     *
+     */
+    readonly entitySource?: Entity;
+}
+
+/**
+ * Contains information regarding a specific block permutation
+ * that was changed from a previous permutation.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentBlockStateChangeEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The previous BlockPermutation.
+     *
+     */
+    readonly previousPermutation: BlockPermutation;
+}
+
+/**
+ * Contains information regarding an event sent by an entity to
+ * this block in the world.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentEntityEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Returns permutation information about the block receiving
+     * the event.
+     *
+     */
+    readonly blockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * The entity that sent the event.
      *
      */
     readonly entitySource: Entity;
@@ -4564,6 +5045,54 @@ export class BlockComponentEntityFallOnEvent extends BlockEvent {
     readonly fallDistance: number;
 }
 
+/**
+ * @beta
+ * Contains information regarding a named tick event for a
+ * specific block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentNamedTickEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Name of the named tick event.
+     *
+     */
+    readonly name: string;
+    /**
+     * @remarks
+     * Checks whether this named tick event was scheduled by this
+     * pack.
+     *
+     * @returns
+     * True if this named tick event was scheduled by this pack;
+     * otherwise, false.
+     */
+    isMine(): boolean;
+}
+
+/**
+ * @beta
+ * Contains information regarding neighboring block changes for
+ * a specific block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockComponentNeighborChangedAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the neighboring block changes for this event.
+     *
+     * @returns
+     * One entry for each neighboring direction that changed,
+     * ordered by when each direction first changed. If a direction
+     * changed multiple times during the tick, the entry contains
+     * the permutation before the first change and after the last
+     * change. Intermediate permutations are not included.
+     */
+    getChanges(): NeighborChange[];
+}
+
 /**
  * Contains information regarding a specific block that was
  * placed.
@@ -4680,6 +5209,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
@@ -4974,6 +5510,181 @@ export class BlockDynamicPropertiesComponent extends BlockComponent {
     totalByteCount(): number;
 }
 
+/**
+ * @beta
+ * Represents storage for entities associated with a block
+ * entity. This component is available on blocks whose behavior
+ * pack definition enables entity storage with the
+ * `minecraft:block_entity` component. Stored entities are
+ * serialized and removed from the world until they are
+ * released or transferred. A block can store up to four
+ * entities. Entity storage is scoped to the content pack
+ * accessing it.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockEntityStorageComponent extends BlockComponent {
+    private constructor();
+    static readonly componentId = 'minecraft:entity_storage';
+    /**
+     * @remarks
+     * Returns information about the entities stored in this
+     * block's entity storage. The returned entities are not
+     * present in the world while they are stored. Only entities
+     * stored by the current content pack are included.
+     *
+     * @returns
+     * An array of {@link BlockEntityStorageInfo} values containing
+     * the unique ID and definition ID of each stored entity.
+     * Returns an empty array when no entities are stored by the
+     * current content pack.
+     * @throws
+     * Throws if the block entity is invalid or the block's
+     * location is not loaded or is outside the world boundaries.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getEntities(): BlockEntityStorageInfo[];
+    /**
+     * @remarks
+     * Releases a stored entity from this block's entity storage
+     * and spawns it back into the world, at the same location it
+     * was when stored.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entityId
+     * The unique ID of the stored entity. Use the value returned
+     * by {@link BlockEntityStorageComponent.store} or the
+     * `uniqueId` property from {@link BlockEntityStorageInfo}.
+     * @returns
+     * The released {@link Entity}. The released entity receives a
+     * new runtime ID.
+     * @throws
+     * Throws if the entity ID is invalid or does not identify an
+     * entity stored by the current content pack, if the stored
+     * entity cannot be loaded or spawned, or if the block entity
+     * is invalid.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    release(entityId: string): Entity;
+    /**
+     * @remarks
+     * Returns the number of entities stored in this block's entity
+     * storage by the current content pack.
+     *
+     * @returns
+     * The number of entities stored by the current content pack.
+     * @throws
+     * Throws if the block entity is invalid or the block's
+     * location is not loaded or is outside the world boundaries.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    size(): number;
+    /**
+     * @remarks
+     * Serializes and stores an entity in this block's entity
+     * storage. The entity is removed from the world after it is
+     * stored. Only non-player mob entities can be stored. Entities
+     * with passengers or that are passengers cannot be stored.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entity
+     * The {@link Entity} to store.
+     * @returns
+     * The unique ID assigned to the stored entity. Keep this ID to
+     * release, transfer, or inspect the stored entity later.
+     * @throws
+     * Throws if the storage is full, the entity is already stored,
+     * the entity cannot be serialized, or the block entity is
+     * invalid.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    store(entity: Entity): string;
+    /**
+     * @remarks
+     * Moves a stored entity from this block's entity storage to
+     * the target block's entity storage without releasing it into
+     * the world.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entityId
+     * The unique ID of the stored entity. Use the value returned
+     * by {@link BlockEntityStorageComponent.store} or the
+     * `uniqueId` property from {@link BlockEntityStorageInfo}.
+     * @param targetBlock
+     * The target {@link Block} with an entity storage component.
+     * The target block must be in the same dimension as this
+     * block.
+     * @throws
+     * Throws if the entity ID is invalid or not stored by the
+     * current content pack, if the target block is invalid, in
+     * another dimension, lacks entity storage, or is full, or if
+     * the source and target blocks are the same.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    transfer(entityId: string, targetBlock: Block): void;
+}
+
+/**
+ * @beta
+ * Contains identifying information about an entity stored in a
+ * {@link BlockEntityStorageComponent}. Stored entities are not
+ * present in the world until they are released.
+ */
+export class BlockEntityStorageInfo {
+    private constructor();
+    /**
+     * @remarks
+     * The entity's definition ID, such as `minecraft:pig`.
+     *
+     */
+    readonly definitionId: string;
+    /**
+     * @remarks
+     * The unique ID of the stored entity. Use this ID with
+     * {@link BlockEntityStorageComponent.release} or
+     * {@link BlockEntityStorageComponent.transfer}.
+     *
+     */
+    readonly uniqueId: string;
+}
+
 /**
  * Contains information regarding an event that impacts a
  * specific block.
@@ -5234,6 +5945,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
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
@@ -5633,29 +6356,162 @@ export class BlockPrecipitationInteractionsComponent extends BlockComponent {
 }
 
 /**
- * Represents a block that can play a record.
+ * @beta
+ * Represents a block component that provides access to recipe
+ * crafting.
  */
 // @ts-ignore Class inheritance allowed for native defined classes
-export class BlockRecordPlayerComponent extends BlockComponent {
+export class BlockRecipeCraftingComponent extends BlockComponent {
     private constructor();
-    static readonly componentId = 'minecraft:record_player';
     /**
      * @remarks
-     * Ejects the currently set record of this record-playing
-     * block.
-     *
-     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     * Returns an array of all players currently interacting with
+     * this block.
      *
-     * @throws This function can throw errors.
      */
-    ejectRecord(): void;
+    readonly players: Player[];
+    static readonly componentId = 'minecraft:recipe_crafting';
     /**
      * @remarks
-     * Gets the currently set record of this record-playing block.
+     * Gets the recipe crafting context for a player interacting
+     * with this block.
      *
+     * @param player
+     * The player for whom to retrieve the crafting context.
+     * @returns
+     * The current recipe crafting context for the player, or
+     * undefined if the player isn't crafting.
      * @throws This function can throw errors.
-     */
-    getRecord(): ItemStack | undefined;
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidEntityError}
+     */
+    getCraftingContext(player: Player): RecipeCraftingContext | undefined;
+}
+
+/**
+ * @beta
+ * Represents a block component that provides access to recipe
+ * processing inputs and output.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockRecipeProcessingComponent extends BlockComponent {
+    private constructor();
+    /**
+     * @remarks
+     * The number of addressable input slots for getInputItem,
+     * setInputItem, setInputSlotEnabled, and getInputSlotEnabled.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    readonly inputSlotCount: number;
+    static readonly componentId = 'minecraft:recipe_processing';
+    /**
+     * @remarks
+     * Gets the item in the provided input slot.
+     *
+     * @param slot
+     * The zero-based input slot index.
+     * @returns
+     * The item stack in the input slot, or undefined if the slot
+     * is empty.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    getInputItem(slot: number): ItemStack | undefined;
+    /**
+     * @remarks
+     * Gets whether an input slot is enabled for recipe processing.
+     *
+     * @param slot
+     * The zero-based input slot index.
+     * @returns
+     * Whether the input slot is enabled.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link minecraftcommon.UnsupportedFunctionalityError}
+     */
+    getInputSlotEnabled(slot: number): boolean;
+    /**
+     * @remarks
+     * Gets the item produced by the current recipe processing
+     * inputs.
+     *
+     * @returns
+     * The output item stack, or undefined if the current inputs do
+     * not produce an item.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    getOutputItem(): ItemStack | undefined;
+    /**
+     * @remarks
+     * Sets or clears an item in an input slot.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param slot
+     * The zero-based input slot index.
+     * @param item
+     * The item stack to place in the slot, or undefined to clear
+     * the slot.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    setInputItem(slot: number, item?: ItemStack): void;
+    /**
+     * @remarks
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidBlockComponentError}
+     *
+     * {@link minecraftcommon.UnsupportedFunctionalityError}
+     */
+    setInputSlotEnabled(slot: number, enabled: boolean): void;
+}
+
+/**
+ * Represents a block that can play a record.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockRecordPlayerComponent extends BlockComponent {
+    private constructor();
+    static readonly componentId = 'minecraft:record_player';
+    /**
+     * @remarks
+     * Ejects the currently set record of this record-playing
+     * block.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     */
+    ejectRecord(): void;
+    /**
+     * @remarks
+     * Gets the currently set record of this record-playing block.
+     *
+     * @throws This function can throw errors.
+     */
+    getRecord(): ItemStack | undefined;
     /**
      * @remarks
      * Returns true if the record-playing block is currently
@@ -6054,6 +6910,49 @@ export class BlockTypes {
     static getAll(): BlockType[];
 }
 
+/**
+ * @beta
+ * Represents the vibration properties of a block with a
+ * 'minecraft:vibration_properties' component.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockVibrationPropertiesComponent extends BlockComponent {
+    private constructor();
+    static readonly componentId = 'minecraft:vibration_properties';
+    /**
+     * @remarks
+     * Gets whether this block can dampen vibrations. Vibrations
+     * that occur on this block will be discarded by this block if
+     * it can dampen vibrations. Returns false when the block does
+     * not define a 'minecraft:vibration_properties' component.
+     *
+     * @returns
+     * Whether this block can dampen vibrations.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getCanDampenVibrations(): boolean;
+    /**
+     * @remarks
+     * Gets whether this block can occlude vibrations. Vibrations
+     * that pass through this block will be discarded if this block
+     * can occlude vibrations. Returns false when the block does
+     * not define a 'minecraft:vibration_properties' component.
+     *
+     * @returns
+     * Whether this block can occlude vibrations.
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getCanOccludeVibrations(): boolean;
+}
+
 /**
  * A BlockVolume is a simple interface to an object which
  * represents a 3D rectangle of a given size (in blocks) at a
@@ -6149,6 +7048,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)
@@ -6420,6 +7328,23 @@ export class Camera {
             | CameraSetRotOptions
             | CameraTargetOptions,
     ): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the current active camera with easing.
+     *
+     * @privilege no-restricted-execution - 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
@@ -6454,6 +7379,37 @@ 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;
+    /**
+     * @remarks
+     * If true, and if the block entity supports entity storage,
+     * the function will copy the stored entities from the block
+     * entity to the dropped item without releasing them. Placing
+     * the item restores the stored entities if the placed block
+     * supports entity storage. In loot table JSON, the optional
+     * entity_storage Boolean field defaults to false and is
+     * independent of dynamic_properties. Requires the Upcoming
+     * Creator Features experiment.
+     *
+     */
+    readonly entityStorage: boolean;
+}
+
 /**
  * CatmullRom spline creation.
  */
@@ -6468,6 +7424,165 @@ 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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). This list can be modified
+     * to change the message recipients.
+     *
+     */
+    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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
  */
@@ -6676,7 +7791,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}
      *
@@ -6914,6 +8031,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}
      *
@@ -7544,6 +8663,15 @@ export class Dimension {
      *
      */
     readonly localizationKey: string;
+    /**
+     * @beta
+     * @remarks
+     * Provides access to point-of-interest (POI) managers for this
+     * dimension. This property is available only when the POI
+     * experiment is enabled.
+     *
+     */
+    readonly poiManager: PoiManager;
     /**
      * @remarks
      * Calculates the location of the closest biome of a particular
@@ -7847,10 +8975,14 @@ export class Dimension {
     getBlockFromRay(location: Vector3, direction: Vector3, options?: BlockRaycastOptions): BlockRaycastHit | undefined;
     /**
      * @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.
@@ -7859,7 +8991,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}
@@ -7984,6 +9116,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
@@ -8045,6 +9197,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
@@ -8290,7 +9452,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
@@ -8405,6 +9571,26 @@ export class Dimension {
      * {@link LocationOutOfWorldBoundariesError}
      */
     spawnXp(location: Vector3, amount: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops all sounds from playing for all players.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     */
+    stopAllSounds(): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops a sound from playing for all players.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param soundId
+     * Identifier of the sound.
+     */
+    stopSound(soundId: string): void;
 }
 
 /**
@@ -8889,6 +10075,16 @@ export class Entity {
      * {@link InvalidEntityError}
      */
     readonly isOnGround: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Returns true if the entity is a passenger of a block.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly isPassengerOfBlock: boolean;
     /**
      * @remarks
      * If true, the entity is currently sleeping.
@@ -8988,6 +10184,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,
@@ -9917,6 +11125,47 @@ export class Entity {
      * {@link InvalidEntityError}
      */
     setRotation(rotation: Vector2): void;
+    /**
+     * @beta
+     * @remarks
+     * Starts the entity as being a passenger of a block with the
+     * specified configuration.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param blockPosition
+     * The integer block position to ride.
+     * @param offset
+     * The offset from the block position.
+     * @param rotation
+     * The rotation of the passenger on the block.
+     * @param rotationLimit
+     * The maximum rotation range of the passenger on the block.
+     * @param emote
+     * The pose of the passenger on the block.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    startPassengerOfBlock(
+        blockPosition: Vector3,
+        offset: Vector3,
+        rotation: number,
+        rotationLimit: number,
+        emote: PassengerOfBlockEmoteType,
+    ): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops the entity from being a passenger of a block.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    stopPassengerOfBlock(): void;
     /**
      * @remarks
      * Teleports the selected entity to a new location
@@ -10232,6 +11481,18 @@ export class EntityBaseMovementComponent extends EntityComponent {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityBreathableComponent extends EntityComponent {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The current air supply of the entity.
+     *
+     * @privilege restricted-execution-read-only - 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.
@@ -10260,6 +11521,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
@@ -12232,6 +13501,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.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    defaultScene: string;
+    /**
+     * @remarks
+     * The name of the NPC as it is displayed to players.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    name: string;
+    /**
+     * @remarks
+     * The index of the skin the NPC will use.
+     *
+     * @privilege restricted-execution-read-only - 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
@@ -13290,7 +14595,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.
@@ -14015,6 +15320,13 @@ export class GameRules {
      *
      */
     playersSleepingPercentage: number;
+    /**
+     * @beta
+     * @remarks
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    playerWaypoints: PlayerWaypointsMode;
     /**
      * @remarks
      * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
@@ -14224,6 +15536,137 @@ export class ItemBlockDynamicPropertiesComponent extends ItemComponent {
     totalByteCount(): number;
 }
 
+/**
+ * @beta
+ * Stores serialized non-player mobs on an item stack. Each
+ * calling behavior pack can only access its manifest UUID
+ * bucket. All buckets share a four-entity limit. Available on
+ * item stacks even when empty. Destroying the item discards
+ * its storage without spawning entities. Data is compatible
+ * with entity-storage block carry-over and placement.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class ItemBlockEntityStorageComponent extends ItemComponent {
+    private constructor();
+    static readonly componentId = 'minecraft:block_entity_storage';
+    /**
+     * @remarks
+     * Inspects the serialized entities in the calling pack's
+     * manifest UUID bucket without loading or spawning them.
+     *
+     * @returns
+     * Stored entity IDs and definition IDs, or an empty array for
+     * an empty bucket.
+     * @throws
+     * Throws if the item is invalid or its entity-storage format
+     * is unsupported.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     */
+    getEntities(): BlockEntityStorageInfo[];
+    /**
+     * @remarks
+     * Releases a stored mob at the supplied dimension and world
+     * position. Does not require a block target. The serialized
+     * position is replaced before the actor is loaded. Removes the
+     * entry from this item after spawning it.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entityId
+     * A stored entity ID in the calling pack's bucket.
+     * @param location
+     * The target DimensionLocation. Must be finite, within world
+     * bounds, and in a loaded, ticking chunk.
+     * @returns
+     * The spawned entity.
+     * @throws
+     * Throws for an invalid item, ID, dimension, or location, a
+     * missing entity, or a load or spawn failure. Failed releases
+     * preserve serialized storage.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    release(entityId: string, location: DimensionLocation): Entity;
+    /**
+     * @remarks
+     * Returns the number of serialized entities in the calling
+     * pack's manifest UUID bucket.
+     *
+     * @returns
+     * The number of entities in this pack's bucket, or zero if
+     * empty.
+     * @throws
+     * Throws if the item is invalid or its entity-storage format
+     * is unsupported.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     */
+    size(): number;
+    /**
+     * @remarks
+     * Serializes and despawns a non-player mob into the calling
+     * pack's item storage. Mounted entities and entities with
+     * passengers cannot be stored.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entity
+     * The live mob to store.
+     * @returns
+     * The stored entity ID, used for inspection, release, or
+     * transfer.
+     * @throws
+     * Throws if the item or entity is invalid, storage is full,
+     * the entity is already stored, serialization fails, or the
+     * entity is not allowed. Rejected entities remain in the
+     * world.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     */
+    store(entity: Entity): string;
+    /**
+     * @remarks
+     * Moves serialized ownership from the calling pack's item
+     * bucket into the same bucket of a block's entity-storage
+     * without loading or spawning the entity. The target can be in
+     * any dimension and must have entity storage.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param entityId
+     * A stored entity ID in the calling pack's bucket.
+     * @param targetBlock
+     * A loaded block with an entity-storage component and
+     * available capacity.
+     * @throws
+     * Throws for an invalid item, ID, or target, a missing entity,
+     * full target storage, or an ID already stored at the target.
+     * Failure preserves both owners.
+     *
+     * {@link Error}
+     *
+     * {@link InvalidItemStackError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    transfer(entityId: string, targetBlock: Block): void;
+}
+
 /**
  * When present on an item, this item is a book item. Can
  * access and modify the contents of the book and sign it.
@@ -16932,6 +18375,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.
@@ -17000,6 +18470,49 @@ export class MolangVariableMap {
     setVector3(variableName: string, vector: Vector3): void;
 }
 
+/**
+ * @beta
+ * Pack setting name and value that changed.
+ */
+export class PackSettingChangeAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The name of the setting.
+     *
+     */
+    readonly settingName: string;
+    /**
+     * @remarks
+     * The value of the setting.
+     *
+     */
+    readonly settingValue: string[] | boolean | number | string;
+}
+
+/**
+ * @beta
+ */
+export class PackSettingChangeAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): (arg0: PackSettingChangeAfterEvent) => void;
+    /**
+     * @remarks
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
@@ -17168,34 +18681,91 @@ export class Player extends Entity {
      */
     readonly camera: Camera;
     /**
+     * @beta
      * @remarks
-     * Contains the player's device information.
+     * 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 clientSystemInfo: ClientSystemInfo;
+    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.
+     *
      * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
      *
      */
-    commandPermissionLevel: CommandPermissionLevel;
+    chatMessagePrefix?: string;
     /**
+     * @beta
      * @remarks
-     * Contains methods for manipulating the render distance fog
-     * settings of a Player.
+     * 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.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
      *
      */
-    readonly fogSettings: FogSettings;
+    chatNamePrefix?: string;
     /**
+     * @beta
      * @remarks
-     * Gets the current graphics mode of the player's client. This
-     * can be changed in the Video section of the settings menu
-     * based on what hardware is available.
+     * 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.
      *
-     * @throws This property can throw when used.
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
      *
-     * {@link InvalidEntityError}
+     */
+    chatNameSuffix?: string;
+    /**
+     * @remarks
+     * Contains the player's device information.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly clientSystemInfo: ClientSystemInfo;
+    /**
+     * @remarks
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    commandPermissionLevel: CommandPermissionLevel;
+    /**
+     * @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
+     * can be changed in the Video section of the settings menu
+     * based on what hardware is available.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
      */
     readonly graphicsMode: GraphicsMode;
     /**
@@ -17270,6 +18840,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.
      *
@@ -17343,6 +18926,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.
+     *
+     * @privilege no-restricted-execution - 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.
@@ -17376,6 +18973,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.
@@ -17383,6 +18994,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.
@@ -17402,8 +19028,12 @@ export class Player extends Entity {
      * @param musicOptions
      * Additional options for the music track.
      * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link minecraftcommon.PropertyOutOfBoundsError}
      */
-    playMusic(trackId: string, musicOptions?: MusicOptions): void;
+    playMusic(trackId: SoundDefinition | string, musicOptions?: MusicOptions): SoundInstance | undefined;
     /**
      * @remarks
      * Plays a sound that only this particular player can hear.
@@ -17447,6 +19077,17 @@ export class Player extends Entity {
      * ```
      */
     playSound(soundId: SoundDefinition | string, soundOptions?: PlayerSoundOptions): SoundInstance;
+    /**
+     * @beta
+     * @remarks
+     * This is an internal-facing method for posting a system
+     * message to downstream clients.
+     *
+     * @privilege no-restricted-execution - 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
@@ -17722,6 +19363,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.
+     *
+     * @privilege no-restricted-execution - 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
@@ -17732,6 +19385,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.
+     *
+     * @privilege no-restricted-execution - 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;
 }
 
 /**
@@ -18040,6 +19707,72 @@ export class PlayerCancelBreakingBlockAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerCancelBreakingBlockAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains information regarding a player crafting a recipe.
+ */
+export class PlayerCraftRecipeAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The block where the recipe was crafted, if applicable.
+     *
+     */
+    readonly block?: Block;
+    /**
+     * @remarks
+     * The item stack crafted by the player.
+     *
+     */
+    readonly itemStack?: ItemStack;
+    /**
+     * @remarks
+     * The player who crafted the recipe.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * @beta
+ * Manages callbacks that are connected to when a player crafts
+ * a recipe.
+ */
+export class PlayerCraftRecipeAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player crafts a
+     * recipe.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * Function callback that is called when this event fires.
+     * @param options
+     * Additional filtering options for the event subscription.
+     */
+    subscribe(
+        callback: (arg0: PlayerCraftRecipeAfterEvent) => void,
+        options?: PlayerCraftRecipeEventOptions,
+    ): (arg0: PlayerCraftRecipeAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player crafts a
+     * recipe.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * The callback to remove from the event subscription.
+     */
+    unsubscribe(callback: (arg0: PlayerCraftRecipeAfterEvent) => void): void;
+}
+
 /**
  * Represents the players cursor inventory. Used when moving
  * items between between containers in the inventory UI. Not
@@ -18067,6 +19800,118 @@ export class PlayerCursorInventoryComponent extends EntityComponent {
     clear(): void;
 }
 
+/**
+ * @beta
+ * Contains information about an item moved from a container to
+ * a player's cursor.
+ */
+export class PlayerCursorItemGrabAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The item stack moved to the player's cursor.
+     *
+     */
+    readonly item: ItemStack;
+    /**
+     * @remarks
+     * The player whose cursor item changed.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * @beta
+ * Manages callbacks for items grabbed from a container to a
+ * player's cursor.
+ */
+export class PlayerCursorItemGrabAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that is called when a player grabs an item
+     * from a container to their cursor.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * The callback function invoked when the event fires.
+     */
+    subscribe(callback: (arg0: PlayerCursorItemGrabAfterEvent) => void): (arg0: PlayerCursorItemGrabAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a previously registered event callback.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * The callback function to remove.
+     */
+    unsubscribe(callback: (arg0: PlayerCursorItemGrabAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Contains information about an item moved from a player's
+ * cursor to a container.
+ */
+export class PlayerCursorItemReleaseAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The item stack from the player's cursor.
+     *
+     */
+    readonly item: ItemStack;
+    /**
+     * @remarks
+     * The player whose cursor item changed.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * @beta
+ * Manages callbacks for items released from a player's cursor
+ * to a container.
+ */
+export class PlayerCursorItemReleaseAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that is called when a player releases an
+     * item from their cursor to a container.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * The callback function invoked when the event fires.
+     */
+    subscribe(
+        callback: (arg0: PlayerCursorItemReleaseAfterEvent) => void,
+    ): (arg0: PlayerCursorItemReleaseAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a previously registered event callback.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * The callback function to remove.
+     */
+    unsubscribe(callback: (arg0: PlayerCursorItemReleaseAfterEvent) => void): void;
+}
+
 /**
  * Contains information related to changes to a player's
  * dimension having been changed.
@@ -18891,47 +20736,133 @@ export class PlayerInventoryItemChangeAfterEventSignal {
 }
 
 /**
- * Contains information regarding a player that has joined.
- * See the playerSpawn event for more detailed information that
- * could be returned after the first time a player has spawned
- * within the game.
+ * @beta
+ * Contains information about an attack initiated through a
+ * player item interaction before it causes effects. Set cancel
+ * to true to prevent the attack.
  */
-export class PlayerJoinAfterEvent {
+export class PlayerItemAttackEntityBeforeEvent {
     private constructor();
     /**
      * @remarks
-     * Opaque string identifier of the player that joined the game.
+     * The normalized world-space direction used for the attack.
+     * For standard client-initiated transaction attacks, this
+     * direction is derived from the client-provided hit position
+     * and the player's server-side eye position. Other attack
+     * paths can provide a server-derived direction. This property
+     * is undefined when the attack path does not provide an aim
+     * direction.
      *
      */
-    readonly playerId: string;
+    readonly aimDirection?: Vector3;
     /**
      * @remarks
-     * Name of the player that has joined.
+     * If set to true, the attack does not cause damage or other
+     * authoritative attack effects.
      *
      */
-    readonly playerName: string;
+    cancel: boolean;
+    /**
+     * @remarks
+     * A snapshot of the item held by the attacking player. This
+     * property is undefined when the player holds no item.
+     *
+     */
+    readonly itemStack?: ItemStack;
+    /**
+     * @remarks
+     * The player that initiated the attack.
+     *
+     */
+    readonly player: Player;
+    /**
+     * @remarks
+     * The entity targeted by the attack.
+     *
+     */
+    readonly target: Entity;
 }
 
 /**
- * Manages callbacks that are connected to a player joining the
- * world.
+ * @beta
+ * Manages callbacks that run before a player attacks an entity
+ * through an item interaction.
  */
-export class PlayerJoinAfterEventSignal {
+export class PlayerItemAttackEntityBeforeEventSignal {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a player joins the
-     * world.
+     * Adds a callback that runs before a player attacks an entity
+     * through an item interaction.
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
      * @privilege early-execution-allowed - 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: PlayerJoinAfterEvent) => void): (arg0: PlayerJoinAfterEvent) => void;
+    subscribe(
+        callback: (arg0: PlayerItemAttackEntityBeforeEvent) => void,
+    ): (arg0: PlayerItemAttackEntityBeforeEvent) => void;
     /**
      * @remarks
-     * Removes a callback from being called when a player joins the
+     * Removes a callback from this event signal.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     * @param callback
+     * This closure is called with restricted-execution privilege.
+     */
+    unsubscribe(callback: (arg0: PlayerItemAttackEntityBeforeEvent) => void): void;
+}
+
+/**
+ * Contains information regarding a player that has joined.
+ * See the playerSpawn event for more detailed information that
+ * could be returned after the first time a player has spawned
+ * within the game.
+ */
+export class PlayerJoinAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Opaque string identifier of the player that joined the game.
+     *
+     */
+    readonly playerId: string;
+    /**
+     * @remarks
+     * Name of the player that has joined.
+     *
+     */
+    readonly playerName: string;
+}
+
+/**
+ * Manages callbacks that are connected to a player joining the
+ * world.
+ */
+export class PlayerJoinAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player joins the
+     * world.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PlayerJoinAfterEvent) => void): (arg0: PlayerJoinAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player joins the
      * world.
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
@@ -19091,223 +21022,672 @@ 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
  */
-export class PlayerSpawnAfterEvent {
+export class PlayerSpawnAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * If true, this is the initial spawn of a player after joining
+     * the game.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    initialSpawn: boolean;
+    /**
+     * @remarks
+     * Object that represents the player that joined the game.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    player: Player;
+}
+
+/**
+ * Registers an event when a player is spawned (or re-spawned
+ * after death) and fully ready within the world.
+ */
+export class PlayerSpawnAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Registers a new event receiver for this particular type of
+     * event.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): (arg0: PlayerSpawnAfterEvent) => void;
+    /**
+     * @remarks
+     * De-registers an event receiver for the player spawn event.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): void;
+}
+
+/**
+ * Contains information regarding an event after a player
+ * starts breaking a block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PlayerStartBreakingBlockAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The permutation of the block that the player is starting to
+     * break.
+     *
+     */
+    readonly blockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * The face of the block being broken.
+     *
+     */
+    readonly face: Direction;
+    /**
+     * @remarks
+     * The item stack that the player is using to break the block,
+     * or undefined if empty hand.
+     *
+     */
+    readonly heldItemStack?: ItemStack;
+    /**
+     * @remarks
+     * Player that started breaking the block for this event.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * Manages callbacks that are connected to when a player starts
+ * breaking a block.
+ */
+export class PlayerStartBreakingBlockAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player starts
+     * breaking a block.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: PlayerStartBreakingBlockAfterEvent) => void,
+        options?: PlayerBreakingBlockEventOptions,
+    ): (arg0: PlayerStartBreakingBlockAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player starts
+     * breaking a block.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerStartBreakingBlockAfterEvent) => void): void;
+}
+
+/**
+ * Contains information regarding a player starting to swing
+ * their arm.
+ */
+export class PlayerSwingStartAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The item stack being held by the player at the start of
+     * their swing.
+     *
+     */
+    readonly heldItemStack?: ItemStack;
+    /**
+     * @remarks
+     * Source Player for this event.
+     *
+     */
+    readonly player: Player;
+    /**
+     * @remarks
+     * The source of the Player swing, see
+     * {@link EntitySwingSource}.
+     *
+     */
+    readonly swingSource: EntitySwingSource;
+}
+
+/**
+ * Manages callbacks that are connected to when a player starts
+ * to swing their arm (e.g. attacking, using an item,
+ * interacting).
+ */
+export class PlayerSwingStartAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player starts to
+     * swing their arm (e.g. attacking, using an item,
+     * interacting).
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: PlayerSwingStartAfterEvent) => void,
+        options?: PlayerSwingEventOptions,
+    ): (arg0: PlayerSwingStartAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player starts to
+     * swing their arm (e.g. attacking, using an item,
+     * interacting).
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    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.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    entityNamed: Entity;
+    /**
+     * @remarks
+     * The new name that the player has given to the entity.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    newName: string;
+    /**
+     * @remarks
+     * Handle to the player that used the name tag.
+     *
+     * @privilege restricted-execution-read-only - 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.
+     *
+     * @privilege restricted-execution-read-only - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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 rules such as hidden state and spectator mode.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PlayerWaypoint extends EntityWaypoint {
+    /**
+     * @remarks
+     * The {@link PlayerVisibilityRules} that control when the
+     * waypoint is shown based on the player's state (e.g., hidden,
+     * spectator mode, spectator viewing another spectator).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidWaypointError}
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    readonly playerRules: PlayerVisibilityRules;
+    /**
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidWaypointTextureSelectorError}
+     */
+    constructor(
+        player: Player,
+        textureSelector: WaypointTextureSelector,
+        playerRules: PlayerVisibilityRules,
+        color?: RGB,
+    );
+}
+
+/**
+ * @beta
+ * Describes a block point-of-interest instance returned by a
+ * query.
+ */
+export class PoiBlockInstance {
     private constructor();
     /**
      * @remarks
-     * If true, this is the initial spawn of a player after joining
-     * the game.
-     *
-     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     * Block position of this POI instance.
      *
      */
-    initialSpawn: boolean;
+    readonly position: Vector3;
     /**
      * @remarks
-     * Object that represents the player that joined the game.
+     * Number of tickets currently available to be claimed from
+     * this POI instance.
      *
-     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     */
+    readonly tickets: number;
+    /**
+     * @remarks
+     * Type of this POI instance.
      *
      */
-    player: Player;
+    readonly 'type': PoiBlockType;
 }
 
 /**
- * Registers an event when a player is spawned (or re-spawned
- * after death) and fully ready within the world.
+ * @beta
+ * Provides methods for querying and managing block-based
+ * points of interest in a dimension.
  */
-export class PlayerSpawnAfterEventSignal {
+export class PoiBlockManager {
     private constructor();
     /**
      * @remarks
-     * Registers a new event receiver for this particular type of
-     * event.
+     * Adds a block point of interest at a position. This method is
+     * intended for temporary usage. Will be replaced when chunk is
+     * reloaded
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
-     *
+     * @param position
+     * Block position at which to add the POI.
+     * @param poi
+     * POI type to add, specified by numeric type Id, type name, or
+     * POI type object.
      */
-    subscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): (arg0: PlayerSpawnAfterEvent) => void;
+    addTemporary(position: Vector3, poi: PoiBlockType | string | number): void;
     /**
      * @remarks
-     * De-registers an event receiver for the player spawn event.
+     * Gets the type of the block point of interest at a position.
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
-     *
+     * @param position
+     * Block position to inspect.
+     * @returns
+     * The POI type at the position, or undefined if no POI exists
+     * there.
      */
-    unsubscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): void;
-}
-
-/**
- * Contains information regarding an event after a player
- * starts breaking a block.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PlayerStartBreakingBlockAfterEvent extends BlockEvent {
-    private constructor();
+    at(position: Vector3): PoiBlockType | undefined;
     /**
      * @remarks
-     * The permutation of the block that the player is starting to
-     * break.
+     * Tests whether a block point of interest at a position
+     * matches a type filter.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
+     * @param position
+     * Block position to inspect.
+     * @param filter
+     * Filter used to select the POI type. A callback receives the
+     * POI type and returns whether it matches; a name filter
+     * matches a type name; and a tag filter requires all specified
+     * tags.
+     * @returns
+     * True if a POI exists at the position and its type matches
+     * the filter; otherwise false.
      */
-    readonly blockPermutation: BlockPermutation;
+    exists(position: Vector3, filter: ((arg0: PoiBlockType) => boolean) | PoiNameFilter | PoiTagFilter): boolean;
     /**
      * @remarks
-     * The face of the block being broken.
+     * Returns block points of interest that match the supplied
+     * type and occupancy filters within the specified distance of
+     * a location.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
+     * @param filter
+     * Filter used to select POI types. A callback receives each
+     * POI type and returns whether it should be included; a name
+     * filter matches a type name; and a tag filter requires all
+     * specified tags.
+     * @param center
+     * Center of the search.
+     * @param blockRadius
+     * Maximum three-dimensional distance from the center, in
+     * blocks.
+     * @param occupancyFilter
+     * Optional filter applied to the occupancy state of matching
+     * POIs. If omitted, POIs in any occupancy state are returned.
+     * @returns
+     * The matching POI instances within range. The result order is
+     * not guaranteed.
      */
-    readonly face: Direction;
+    getInRange(
+        filter: ((arg0: PoiBlockType) => boolean) | PoiNameFilter | PoiTagFilter,
+        center: Vector3,
+        blockRadius: number,
+        occupancyFilter?: PoiBlockOccupancyFilter,
+    ): PoiBlockInstance[];
     /**
      * @remarks
-     * The item stack that the player is using to break the block,
-     * or undefined if empty hand.
+     * Returns block points of interest that match the supplied
+     * type and occupancy filters within an axis-aligned square
+     * centered on the specified location, sorted from nearest to
+     * farthest.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
+     * @param filter
+     * Filter used to select POI types. A callback receives each
+     * POI type and returns whether it should be included; a name
+     * filter matches a type name; and a tag filter requires all
+     * specified tags.
+     * @param center
+     * Center of the search and the location from which distances
+     * are calculated.
+     * @param blockRadius
+     * Maximum three-dimensional distance from the center, in
+     * blocks.
+     * @param occupancyFilter
+     * Optional filter applied to the occupancy state of matching
+     * POIs. If omitted, POIs in any occupancy state are returned.
+     * @returns
+     * The matching POI instances and their squared distances from
+     * the center, sorted in ascending distance order.
      */
-    readonly heldItemStack?: ItemStack;
+    getInRangeSorted(
+        filter: ((arg0: PoiBlockType) => boolean) | PoiNameFilter | PoiTagFilter,
+        center: Vector3,
+        blockRadius: number,
+        occupancyFilter?: PoiBlockOccupancyFilter,
+    ): PoiDistancePair[];
     /**
      * @remarks
-     * Player that started breaking the block for this event.
+     * Returns block points of interest that match the supplied
+     * type and occupancy filters within an axis-aligned square
+     * centered on the specified location.
      *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param filter
+     * Filter used to select POI types. A callback receives each
+     * POI type and returns whether it should be included; a name
+     * filter matches a type name; and a tag filter requires all
+     * specified tags.
+     * @param center
+     * Center of the search volume.
+     * @param blockRadius
+     * Half-size of the search volume, in blocks, along each axis.
+     * @param occupancyFilter
+     * Optional filter applied to the occupancy state of matching
+     * POIs. If omitted, POIs in any occupancy state are returned.
+     * @returns
+     * The matching POI instances in the search volume.
      */
-    readonly player: Player;
-}
-
-/**
- * Manages callbacks that are connected to when a player starts
- * breaking a block.
- */
-export class PlayerStartBreakingBlockAfterEventSignal {
-    private constructor();
+    getInSquare(
+        filter: ((arg0: PoiBlockType) => boolean) | PoiNameFilter | PoiTagFilter,
+        center: Vector3,
+        blockRadius: number,
+        occupancyFilter?: PoiBlockOccupancyFilter,
+    ): PoiBlockInstance[];
     /**
      * @remarks
-     * Adds a callback that will be called when a player starts
-     * breaking a block.
+     * Releases one previously claimed ticket at a block point of
+     * interest.
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
-     *
+     * @param center
+     * Block position of the POI whose ticket should be released.
+     * @returns
+     * True if a ticket was released; false if no POI exists at the
+     * position or the POI has no claimed tickets.
      */
-    subscribe(
-        callback: (arg0: PlayerStartBreakingBlockAfterEvent) => void,
-        options?: PlayerBreakingBlockEventOptions,
-    ): (arg0: PlayerStartBreakingBlockAfterEvent) => void;
+    release(center: Vector3): boolean;
     /**
      * @remarks
-     * Removes a callback from being called when a player starts
-     * breaking a block.
+     * Claims one available ticket from a matching block point of
+     * interest within range.
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
-     *
+     * @param filter
+     * Filter used to select the POI type to claim. A callback
+     * receives each POI type and returns whether it should be
+     * included; a name filter matches a type name; and a tag
+     * filter requires all specified tags.
+     * @param center
+     * Center of the search.
+     * @param blockRadius
+     * Maximum three-dimensional distance from the center, in
+     * blocks.
+     * @returns
+     * The block position of the claimed POI, or undefined if no
+     * matching POI has an available ticket.
      */
-    unsubscribe(callback: (arg0: PlayerStartBreakingBlockAfterEvent) => void): void;
+    take(
+        filter: ((arg0: PoiBlockType) => boolean) | PoiNameFilter | PoiTagFilter,
+        center: Vector3,
+        blockRadius: number,
+    ): Vector3 | undefined;
 }
 
 /**
- * Contains information regarding a player starting to swing
- * their arm.
+ * @beta
+ * Describes a block point-of-interest type.
  */
-export class PlayerSwingStartAfterEvent {
+export class PoiBlockType {
     private constructor();
     /**
      * @remarks
-     * The item stack being held by the player at the start of
-     * their swing.
+     * Numeric identifier of this POI type.
      *
      */
-    readonly heldItemStack?: ItemStack;
+    readonly id: number;
     /**
      * @remarks
-     * Source Player for this event.
+     * Namespaced identifier of this POI type.
      *
      */
-    readonly player: Player;
+    readonly name: string;
     /**
      * @remarks
-     * The source of the Player swing, see
-     * {@link EntitySwingSource}.
+     * Maximum number of tickets that can be claimed from each POI
+     * instance of this type.
      *
      */
-    readonly swingSource: EntitySwingSource;
-}
-
-/**
- * Manages callbacks that are connected to when a player starts
- * to swing their arm (e.g. attacking, using an item,
- * interacting).
- */
-export class PlayerSwingStartAfterEventSignal {
-    private constructor();
+    readonly tickets: number;
     /**
      * @remarks
-     * Adds a callback that will be called when a player starts to
-     * swing their arm (e.g. attacking, using an item,
-     * interacting).
+     * Maximum range, in blocks, at which this POI type is
+     * considered usable.
      *
-     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     */
+    readonly usableRange: number;
+    /**
+     * @remarks
+     * Tests whether this object and another object describe the
+     * same POI type.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
+     * @param other
+     * POI type to compare with this type.
+     * @returns
+     * True if both objects describe the same POI type; otherwise
+     * false.
      */
-    subscribe(
-        callback: (arg0: PlayerSwingStartAfterEvent) => void,
-        options?: PlayerSwingEventOptions,
-    ): (arg0: PlayerSwingStartAfterEvent) => void;
+    equals(other: PoiBlockType): boolean;
     /**
      * @remarks
-     * Removes a callback from being called when a player starts to
-     * swing their arm (e.g. attacking, using an item,
-     * interacting).
+     * Tests whether the type has the provided tag attribute
      *
      * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
      *
-     * @privilege early-execution-allowed - This function can be called in early-execution mode.
-     *
+     * @param tag
+     * POI tag to check.
+     * @returns
+     * True if the POI conatains the tag; otherwise false.
      */
-    unsubscribe(callback: (arg0: PlayerSwingStartAfterEvent) => void): void;
+    hasTag(tag: string): boolean;
 }
 
 /**
- * Waypoint that tracks a player's position. Extends
- * {@link EntityWaypoint} with additional player-specific
- * visibility rules such as hidden state and spectator mode.
+ * @beta
+ * Provides access to point-of-interest (POI) data in a
+ * dimension.
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PlayerWaypoint extends EntityWaypoint {
+export class PoiManager {
+    private constructor();
     /**
      * @remarks
-     * The {@link PlayerVisibilityRules} that control when the
-     * waypoint is shown based on the player's state (e.g., hidden,
-     * spectator mode, spectator viewing another spectator).
-     *
-     * @throws This property can throw when used.
-     *
-     * {@link InvalidWaypointError}
-     *
-     * {@link InvalidWaypointTextureSelectorError}
-     */
-    readonly playerRules: PlayerVisibilityRules;
-    /**
-     * @throws This function can throw errors.
+     * Provides access to block-based points of interest in the
+     * dimension.
      *
-     * {@link InvalidWaypointTextureSelectorError}
      */
-    constructor(
-        player: Player,
-        textureSelector: WaypointTextureSelector,
-        playerRules: PlayerVisibilityRules,
-        color?: RGB,
-    );
+    readonly blocks: PoiBlockManager;
 }
 
 /**
@@ -19392,10 +21772,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;
 }
 
 /**
@@ -19530,6 +21910,10 @@ export class PrimitiveShape {
      *
      */
     color: RGBA;
+    /**
+     * @beta
+     */
+    defaultVisibleToAll: boolean;
     /**
      * @remarks
      * The dimension the shape is visible within. If the dimension
@@ -19544,6 +21928,10 @@ export class PrimitiveShape {
      *
      */
     readonly hasDuration: boolean;
+    /**
+     * @beta
+     */
+    hiddenFrom: Player[];
     /**
      * @remarks
      * The location of the shape.
@@ -19933,6 +22321,104 @@ export class RandomRegionalDifficultyChanceCondition extends LootItemCondition {
     readonly maxChance: number;
 }
 
+/**
+ * @beta
+ * Provides access to the slots and recipe of a players active
+ * crafting UI ie. stonecutter.
+ */
+export class RecipeCraftingContext {
+    private constructor();
+    /**
+     * @remarks
+     * The amount of addressable input slots for getInputItem and
+     * setInputItem.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    readonly inputSlotCount: number;
+    /**
+     * @remarks
+     * Whether this recipe crafting context is valid. Invalidates
+     * when the player closes the crafting UI or leaves.
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * @remarks
+     * The identifiers of the recipes that are valid for the
+     * current input items.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    readonly validRecipes: string[];
+    /**
+     * @remarks
+     * Gets the item in the provided input slot.
+     *
+     * @param slot
+     * The zero-based input slot index.
+     * @returns
+     * The item stack in the input slot, or undefined if the slot
+     * is empty.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    getInputItem(slot: number): ItemStack | undefined;
+    /**
+     * @remarks
+     * Gets the item produced by the currently selected recipe.
+     *
+     * @returns
+     * The output item stack, or undefined if there is no output.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    getOutputItem(): ItemStack | undefined;
+    /**
+     * @remarks
+     * Sets or clears an item in an input slot.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param slot
+     * The zero-based input slot index.
+     * @param item
+     * The item stack to place in the slot, or undefined to clear
+     * the slot.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link minecraftcommon.EngineError}
+     */
+    setInputItem(slot: number, item?: ItemStack): void;
+    /**
+     * @remarks
+     * Selects a recipe for the current crafting operation.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @param recipeId
+     * The identifier of a valid recipe to select.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidRecipeError}
+     */
+    setSelectedRecipe(recipeId: string): void;
+}
+
 /**
  * Contains objectives and participants for the scoreboard.
  * @example updateScoreboard.ts
@@ -20610,7 +23096,39 @@ export class Seat {
      * Angle in degrees to rotate riders by.
      *
      */
-    readonly seatRotation: number;
+    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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: MessageReceiveAfterEvent) => void): void;
 }
 
 /**
@@ -20641,6 +23159,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.
@@ -21877,6 +24410,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.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly watchdogTerminate: WatchdogTerminateBeforeEventSignal;
 }
 
 /**
@@ -22309,6 +24855,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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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.
+     *
+     * @privilege no-restricted-execution - This function can't be called in restricted-execution mode.
+     *
+     * @privilege early-execution-allowed - 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
@@ -22524,6 +25135,15 @@ export class World {
      *
      */
     readonly afterEvents: WorldAfterEvents;
+    /**
+     * @beta
+     * @remarks
+     * Enables or disables cheats.
+     *
+     * @privilege restricted-execution-read-only - This property can't be edited in restricted-execution mode.
+     *
+     */
+    allowCheats: boolean;
     /**
      * @remarks
      * Contains a set of events that are applicable to the entirety
@@ -22608,6 +25228,20 @@ export class World {
      *
      */
     readonly tickingAreaManager: TickingAreaManager;
+    /**
+     * @beta
+     * @remarks
+     * A method that is internal-only, used for broadcasting
+     * specific messages between client and server.
+     *
+     * @privilege no-restricted-execution - 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
@@ -22859,6 +25493,8 @@ export class World {
      *
      * @throws This function can throw errors.
      *
+     * {@link minecraftcommon.EngineError}
+     *
      * {@link minecraftcommon.PropertyOutOfBoundsError}
      * @example playMusicAndSound.ts
      * ```typescript
@@ -22889,7 +25525,7 @@ export class World {
      * }
      * ```
      */
-    playMusic(trackId: string, musicOptions?: MusicOptions): void;
+    playMusic(trackId: SoundDefinition | string, musicOptions?: MusicOptions): SoundInstance | undefined;
     /**
      * @remarks
      * Queues an additional music track for players. If a track is
@@ -23113,6 +25749,16 @@ export class WorldAfterEvents {
      *
      */
     readonly buttonPush: ButtonPushAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly chatSend: ChatSendAfterEventSignal;
     /**
      * @remarks
      * This event is fired when an entity event has been triggered
@@ -23356,6 +26002,25 @@ export class WorldAfterEvents {
      *
      */
     readonly leverAction: LeverActionAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is an internal implementation detail, and is
+     * otherwise not currently functional.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly messageReceive: ServerMessageAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered when a pack setting is changed.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly packSettingChange: PackSettingChangeAfterEventSignal;
     /**
      * @remarks
      * This event fires when a piston expands or retracts.
@@ -23389,6 +26054,35 @@ export class WorldAfterEvents {
      *
      */
     readonly playerCancelBreakingBlock: PlayerCancelBreakingBlockAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires when a player crafts a recipe.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly playerCraftRecipe: PlayerCraftRecipeAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * Event signal that fires when a player grabs an item from a
+     * container to their cursor.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly playerCursorItemGrab: PlayerCursorItemGrabAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * Event signal that fires when a player releases an item from
+     * their cursor into a container.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly playerCursorItemRelease: PlayerCursorItemReleaseAfterEventSignal;
     /**
      * @remarks
      * Fires when a player moved to a different dimension.
@@ -23508,6 +26202,16 @@ export class WorldAfterEvents {
      *
      */
     readonly playerSwingStart: PlayerSwingStartAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * An event for when a player uses a named name tag on an
+     * entity.
+     *
+     * @privilege early-execution-readable - 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
@@ -23633,6 +26337,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.
+     *
+     * @privilege early-execution-readable - 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
@@ -23726,6 +26467,13 @@ export class WorldBeforeEvents {
      *
      */
     readonly playerInteractWithEntity: PlayerInteractWithEntityBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly playerItemAttackEntity: PlayerItemAttackEntityBeforeEventSignal;
     /**
      * @remarks
      * Fires when a player leaves the game.
@@ -23734,6 +26482,15 @@ export class WorldBeforeEvents {
      *
      */
     readonly playerLeave: PlayerLeaveBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires before a block is placed by a player.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly playerPlaceBlock: PlayerPlaceBlockBeforeEventSignal;
     /**
      * @remarks
      * @privilege early-execution-readable - This property can be read in early-execution mode.
@@ -24273,7 +27030,9 @@ export interface BiomeSearchOptions {
  * A BlockBoundingBox is an interface to an object which
  * represents an AABB aligned rectangle.
  * The BlockBoundingBox assumes that it was created in a valid
- * state (min <= max) but cannot guarantee it.
+ * state (min <= max) but cannot guarantee it (unless it was
+ * 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
@@ -24360,6 +27119,14 @@ export interface BlockCustomComponent {
      *
      */
     onEntityFallOn?: (arg0: BlockComponentEntityFallOnEvent, arg1: CustomComponentParameters) => void;
+    /**
+     * @beta
+     */
+    onNamedTick?: (arg0: BlockComponentNamedTickEvent, arg1: CustomComponentParameters) => void;
+    /**
+     * @beta
+     */
+    onNeighborChanged?: (arg0: BlockComponentNeighborChangedAfterEvent, arg1: CustomComponentParameters) => void;
     /**
      * @remarks
      * This function will be called when the block that this custom
@@ -24899,6 +27666,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.
@@ -24919,10 +27695,11 @@ export interface CustomCommandParameter {
 export interface CustomCommandResult {
     /**
      * @remarks
-     * Message displayed to chat after command execution.
+     * Message displayed to chat after command execution. Accepts a
+     * {@link RawMessage} or a plain string.
      *
      */
-    message?: string;
+    message?: RawMessage | string;
     /**
      * @remarks
      * Command execution Success or Failure. Determines how the
@@ -24977,6 +27754,14 @@ export interface DefinitionModifier {
      *
      */
     removedComponentGroups: string[];
+    /**
+     * @beta
+     * @remarks
+     * The list of entity definition events that will be fired via
+     * this update.
+     *
+     */
+    triggers: Trigger[];
 }
 
 /**
@@ -26220,6 +29005,35 @@ export interface MusicOptions {
     volume?: number;
 }
 
+/**
+ * @beta
+ * Contains information regarding a block change in one
+ * neighboring direction.
+ */
+export interface NeighborChange {
+    /**
+     * @remarks
+     * The permutation of the neighboring block after its last
+     * change during the tick.
+     *
+     */
+    blockPermutation: BlockPermutation;
+    /**
+     * @remarks
+     * Direction from the block receiving the event to the
+     * neighboring block that changed.
+     *
+     */
+    direction: Direction;
+    /**
+     * @remarks
+     * The permutation of the neighboring block before its first
+     * change during the tick.
+     *
+     */
+    previousPermutation: BlockPermutation;
+}
+
 /**
  * Not equal to operator.
  */
@@ -26328,6 +29142,31 @@ export interface PlayerBreakingBlockEventOptions {
     playerFilter?: EntityFilter;
 }
 
+/**
+ * @beta
+ * Contains options for filtering player craft recipe events.
+ */
+export interface PlayerCraftRecipeEventOptions {
+    /**
+     * @remarks
+     * Filter for the block where the recipe is crafted.
+     *
+     */
+    blockFilter?: BlockFilter;
+    /**
+     * @remarks
+     * Filter for the item crafted by the player.
+     *
+     */
+    itemFilter?: ItemFilter;
+    /**
+     * @remarks
+     * Filter for the player crafting the recipe.
+     *
+     */
+    playerFilter?: EntityFilter;
+}
+
 /**
  * Additional options for how a sound plays for a player.
  */
@@ -26423,6 +29262,56 @@ export interface PlayerVisibilityRules extends EntityVisibilityRules {
     showSpectatorToSpectator?: boolean;
 }
 
+/**
+ * @beta
+ * Associates a block point-of-interest instance with its
+ * squared distance from a query center.
+ */
+export interface PoiDistancePair {
+    /**
+     * @remarks
+     * Squared three-dimensional distance, in blocks squared, from
+     * the query center to the POI position.
+     *
+     */
+    distance: number;
+    /**
+     * @remarks
+     * POI instance at this distance.
+     *
+     */
+    poi: PoiBlockInstance;
+}
+
+/**
+ * @beta
+ * Selects block point-of-interest types by their exact
+ * namespaced identifier.
+ */
+export interface PoiNameFilter {
+    /**
+     * @remarks
+     * Exact namespaced POI type identifier to match.
+     *
+     */
+    name: string;
+}
+
+/**
+ * @beta
+ * Selects block point-of-interest types that have all
+ * specified tags.
+ */
+export interface PoiTagFilter {
+    /**
+     * @remarks
+     * Namespaced POI tags that a matching type must contain. All
+     * tags in the array are required.
+     *
+     */
+    tags: string[];
+}
+
 /**
  * Contains optional filters that control which primitive
  * shapes are returned from a primitive shapes query.
@@ -26747,6 +29636,14 @@ export interface RotationKeyFrame {
     timeSeconds: number;
 }
 
+/**
+ * @beta
+ */
+export interface ScheduledNamedTick {
+    eventName: string;
+    tickDelay: number;
+}
+
 /**
  * Contains additional options for how a scoreboard should be
  * displayed within its display slot.
@@ -27728,6 +30625,23 @@ export class InvalidPotionEffectTypeError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ * Thrown when an invalid recipe identifier is used.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidRecipeError extends Error {
+    private constructor();
+    /**
+     * @remarks
+     * The identifier of the invalid recipe.
+     *
+     * @privilege early-execution-readable - This property can be read in early-execution mode.
+     *
+     */
+    readonly recipeId: string;
+}
+
 /**
  * Thrown when a Structure is invalid. A structure becomes
  * invalid when it is deleted.