@minecraft/server 2.9.0-beta.1.26.30-preview.32 → 2.9.0-rc.1.26.40-preview.23

package/index.d.ts

@@ -7,7 +7,7 @@
    Copyright (c) Microsoft Corporation.
    ***************************************************************************** */
 /**
- * @beta
+ * @preview
  * @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.9.0-beta"
+ *   "version": "2.9.0"
  * }
  * ```
  *
@@ -47,10 +47,6 @@ export enum AimAssistTargetMode {
  * function Block.getComponent.
  */
 export enum BlockComponentTypes {
-    /**
-     * @beta
-     */
-    DynamicProperties = 'minecraft:dynamic_properties',
     FluidContainer = 'minecraft:fluid_container',
     /**
      * @remarks
@@ -233,55 +229,6 @@ export enum CommandPermissionLevel {
     Owner = 4,
 }
 
-/**
- * @beta
- * The Action enum determines how the CompoundBlockVolume
- * considers the associated CompoundBlockVolumeItem when
- * performing inside/outside calculations.
- */
-export enum CompoundBlockVolumeAction {
-    /**
-     * @remarks
-     * The associated BlockVolume is considered a positive space,
-     * and any intersection tests are considered hits
-     *
-     */
-    Add = 0,
-    /**
-     * @remarks
-     * The associated BlockVolume is considered a negative or void
-     * space, and any intersection tests are considered misses.
-     * Using the Subtract action, it is possible to `punch holes`
-     * in block volumes so that any intersection tests may pass
-     * through such spaces
-     *
-     */
-    Subtract = 1,
-}
-
-/**
- * @beta
- * An enum describing the relativity of the
- * CompoundBlockVolumeItem, relative to the parent
- * CompoundVolume.
- */
-export enum CompoundBlockVolumePositionRelativity {
-    /**
-     * @remarks
-     * The locations within the associated BlockVolume are relative
-     * to the CompoundBlockVolume to which they were added
-     *
-     */
-    Relative = 0,
-    /**
-     * @remarks
-     * The locations within the associated BlockVolume are in
-     * absolute world space
-     *
-     */
-    Absolute = 1,
-}
-
 /**
  * Reasons that the {@link
  * @minecraft/server.ContainerRulesError} was thrown.
@@ -384,13 +331,6 @@ export enum CustomCommandErrorReason {
      *
      */
     RegistryReadOnly = 'RegistryReadOnly',
-    /**
-     * @beta
-     * @remarks
-     * Non enum type command parameters cannot use enumName.
-     *
-     */
-    UnexpectedEnumName = 'UnexpectedEnumName',
 }
 
 /**
@@ -1128,14 +1068,6 @@ 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.
@@ -1149,15 +1081,6 @@ export enum EntityComponentTypes {
      *
      */
     Exhaustion = 'minecraft:player.exhaustion',
-    /**
-     * @beta
-     * @remarks
-     * Use this component to access and manipulate the fog
-     * definitions stack of a player. This is only available on
-     * players.
-     *
-     */
-    Fog = 'minecraft:player.fog',
     /**
      * @remarks
      * Use this component to read the hunger of a player. This is
@@ -1629,14 +1552,6 @@ 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
@@ -1906,14 +1821,6 @@ 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
@@ -2705,11 +2612,35 @@ export enum PlayerPermissionLevel {
 }
 
 /**
- * @beta
+ * @rc
+ * The split screen slot of a player.
  */
-export enum PlayerWaypointsMode {
-    Everyone = 'Everyone',
-    Off = 'Off',
+export enum PlayerSplitScreenSlot {
+    /**
+     * @remarks
+     * The first player in the split screen session. This is the
+     * primary player.
+     *
+     */
+    First = 'First',
+    /**
+     * @remarks
+     * The fourth player in the split screen session.
+     *
+     */
+    Fourth = 'Fourth',
+    /**
+     * @remarks
+     * The second player in the split screen session.
+     *
+     */
+    Second = 'Second',
+    /**
+     * @remarks
+     * The third player in the split screen session.
+     *
+     */
+    Third = 'Third',
 }
 
 /**
@@ -3038,29 +2969,6 @@ 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',
-}
-
 /**
  * @rc
  * Enum representing different texture icons that can be
@@ -3123,11 +3031,9 @@ export type BlockComponentReturnType<T extends string> = T extends keyof BlockCo
     : BlockCustomComponentInstance;
 
 export type BlockComponentTypeMap = {
-    dynamic_properties: BlockDynamicPropertiesComponent;
     fluid_container: BlockFluidContainerComponent;
     inventory: BlockInventoryComponent;
     map_color: BlockMapColorComponent;
-    'minecraft:dynamic_properties': BlockDynamicPropertiesComponent;
     'minecraft:fluid_container': BlockFluidContainerComponent;
     'minecraft:inventory': BlockInventoryComponent;
     'minecraft:map_color': BlockMapColorComponent;
@@ -3248,10 +3154,8 @@ 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.fog': EntityFogComponent;
     'minecraft:player.hunger': EntityHungerComponent;
     'minecraft:player.saturation': EntitySaturationComponent;
     'minecraft:projectile': EntityProjectileComponent;
@@ -3283,10 +3187,8 @@ export type EntityComponentTypeMap = {
     'navigation.generic': EntityNavigationGenericComponent;
     'navigation.hover': EntityNavigationHoverComponent;
     'navigation.walk': EntityNavigationWalkComponent;
-    npc: EntityNpcComponent;
     onfire: EntityOnFireComponent;
     'player.exhaustion': EntityExhaustionComponent;
-    'player.fog': EntityFogComponent;
     'player.hunger': EntityHungerComponent;
     'player.saturation': EntitySaturationComponent;
     projectile: EntityProjectileComponent;
@@ -3304,15 +3206,6 @@ 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;
@@ -3338,15 +3231,6 @@ 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.
@@ -3504,9 +3388,7 @@ export class AimAssistCategorySettings {
      * A record mapping block Ids to their priority settings.
      * Larger numbers have greater priority.
      */
-    setBlockPriorities(
-        blockPriorities: Record<keyof typeof minecraftvanilladata.MinecraftBlockTypes | string, number>,
-    ): void;
+    setBlockPriorities(blockPriorities: Record<string, number>): void;
     /**
      * @remarks
      * Sets the priority settings used for block targeting.
@@ -3525,9 +3407,7 @@ export class AimAssistCategorySettings {
      * A record mapping entity Ids to their priority settings.
      * Larger numbers have greater priority.
      */
-    setEntityPriorities(
-        entityPriorities: Record<keyof typeof minecraftvanilladata.MinecraftEntityTypes | string, number>,
-    ): void;
+    setEntityPriorities(entityPriorities: Record<string, number>): void;
     /**
      * @remarks
      * Sets the priority settings used for entity targeting.
@@ -3726,10 +3606,8 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
-     * @param targets
-     * An array of block tags.
      */
-    setExcludedBlockTagTargets(targets?: string[]): void;
+    setExcludedBlockTagTargets(blockTagTargets?: string[]): void;
     /**
      * @remarks
      * Sets the list of block Ids to exclude from aim assist
@@ -3737,10 +3615,8 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
-     * @param targets
-     * An array of block Ids.
      */
-    setExcludedBlockTargets(targets?: (keyof typeof minecraftvanilladata.MinecraftBlockTypes | string)[]): void;
+    setExcludedBlockTargets(blockTargets?: string[]): void;
     /**
      * @remarks
      * Sets the list of entity Ids to exclude from aim assist
@@ -3748,10 +3624,8 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
-     * @param targets
-     * An array of entity Ids.
      */
-    setExcludedEntityTargets(targets?: (keyof typeof minecraftvanilladata.MinecraftEntityTypes | string)[]): void;
+    setExcludedEntityTargets(entityTargets?: string[]): void;
     /**
      * @remarks
      * Sets the list of entity type families to exclude from aim
@@ -3759,10 +3633,8 @@ export class AimAssistPresetSettings {
      *
      * This function can't be called in restricted-execution mode.
      *
-     * @param targets
-     * An array of entity type families.
      */
-    setExcludedEntityTypeFamilyTargets(targets?: string[]): void;
+    setExcludedEntityTypeFamilyTargets(entityTypeFamilyTargets?: string[]): void;
     /**
      * @remarks
      * Sets the per-item aim-assist category Ids.
@@ -3773,7 +3645,7 @@ export class AimAssistPresetSettings {
      * A record mapping item Ids to aim-assist category Ids.
      * Category Ids must have a namespace.
      */
-    setItemSettings(itemSettings: Record<keyof typeof minecraftvanilladata.MinecraftItemTypes | string, string>): void;
+    setItemSettings(itemSettings: Record<string, string>): void;
     /**
      * @remarks
      * Sets the list of item Ids that will target liquid blocks
@@ -3784,7 +3656,7 @@ export class AimAssistPresetSettings {
      * @param items
      * An array of item Ids.
      */
-    setLiquidTargetingItems(items?: (keyof typeof minecraftvanilladata.MinecraftItemTypes | string)[]): void;
+    setLiquidTargetingItems(items?: string[]): void;
 }
 
 /**
@@ -3890,28 +3762,6 @@ 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.
  */
@@ -4005,20 +3855,6 @@ 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
@@ -4184,30 +4020,6 @@ 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
@@ -4305,16 +4117,7 @@ export class Block {
      */
     getLightLevel(): number;
     /**
-     * @beta
-     * @throws This function can throw errors.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
-     */
-    getMapColor(): RGBA;
-    /**
-     * @beta
+     * @rc
      * @remarks
      * Returns array of all loaded block parts if this block has
      * the 'minecraft:multi_block' trait. If it does not have the
@@ -4594,27 +4397,6 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     south(steps?: number): Block | undefined;
-    /**
-     * @beta
-     * @remarks
-     * Tries to set the block in the dimension to the state of the
-     * permutation by first checking if the placement is valid.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param permutation
-     * Permutation that contains a set of property states for the
-     * Block.
-     * @returns
-     * Returns `true` if the block permutation data was
-     * successfully set, else `false`.
-     * @throws This function can throw errors.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
-     */
-    trySetPermutation(permutation: BlockPermutation): boolean;
     /**
      * @remarks
      * Returns the {@link Block} to the west of this block
@@ -4632,137 +4414,6 @@ export class Block {
     west(steps?: number): Block | undefined;
 }
 
-/**
- * @beta
- * Bounding Box Utils is a utility class that provides a number
- * of useful functions for the creation and utility of {@link
- * BlockBoundingBox} objects
- */
-export class BlockBoundingBoxUtils {
-    private constructor();
-    /**
-     * @remarks
-     * Create a validated instance of a {@link BlockBoundingBox}
-     * where the min and max components are guaranteed to be (min
-     * <= max)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param min
-     * A corner world location
-     * @param max
-     * A corner world location diametrically opposite
-     */
-    static createValid(min: Vector3, max: Vector3): BlockBoundingBox;
-    /**
-     * @remarks
-     * Expand a {@link BlockBoundingBox} by a given amount along
-     * each axis.
-     * Sizes can be negative to perform contraction.
-     * Note: corners can be inverted if the contraction size is
-     * greater than the span, but the min/max relationship will
-     * remain correct
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * Return a new {@link BlockBoundingBox} object representing
-     * the changes
-     */
-    static dilate(box: BlockBoundingBox, size: Vector3): BlockBoundingBox;
-    /**
-     * @remarks
-     * Check if two {@link BlockBoundingBox} objects are identical
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static equals(box: BlockBoundingBox, other: BlockBoundingBox): boolean;
-    /**
-     * @remarks
-     * Expand the initial box object bounds to include the 2nd box
-     * argument.  The resultant {@link BlockBoundingBox} object
-     * will be a BlockBoundingBox which exactly encompasses the two
-     * boxes.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * A new {@link BlockBoundingBox} instance representing the
-     * smallest possible bounding box which can encompass both
-     */
-    static expand(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox;
-    /**
-     * @remarks
-     * Calculate the center block of a given {@link
-     * BlockBoundingBox} object.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * Note that {@link BlockBoundingBox} objects represent whole
-     * blocks, so the center of boxes which have odd numbered
-     * bounds are not mathematically centered...
-     * i.e. a BlockBoundingBox( 0,0,0 -> 3,3,3 )  would have a
-     * center of (1,1,1)  (not (1.5, 1.5, 1.5) as expected)
-     */
-    static getCenter(box: BlockBoundingBox): Vector3;
-    /**
-     * @remarks
-     * Calculate the BlockBoundingBox which represents the union
-     * area of two intersecting BlockBoundingBoxes
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static getIntersection(box: BlockBoundingBox, other: BlockBoundingBox): BlockBoundingBox | undefined;
-    /**
-     * @remarks
-     * Get the Span of each of the BlockBoundingBox Axis components
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static getSpan(box: BlockBoundingBox): Vector3;
-    /**
-     * @remarks
-     * Check to see if two BlockBoundingBox objects intersect
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static intersects(box: BlockBoundingBox, other: BlockBoundingBox): boolean;
-    /**
-     * @remarks
-     * Check to see if a given coordinate is inside a
-     * BlockBoundingBox
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static isInside(box: BlockBoundingBox, pos: Vector3): boolean;
-    /**
-     * @remarks
-     * Check to see if a BlockBoundingBox is valid (i.e. (min <=
-     * max))
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    static isValid(box: BlockBoundingBox): boolean;
-    /**
-     * @remarks
-     * Move a BlockBoundingBox by a given amount
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * Return a new BlockBoundingBox object which represents the
-     * change
-     */
-    static translate(box: BlockBoundingBox, delta: Vector3): BlockBoundingBox;
-}
-
 /**
  * Base type for components associated with blocks.
  */
@@ -4986,13 +4637,6 @@ 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
@@ -5189,123 +4833,21 @@ export class BlockCustomComponentInstance extends BlockComponent {
 }
 
 /**
- * @beta
- * Represents the dynamic properties of a block in the world.
- * Only available with block entities. Up to 1KBytes of data
- * can be stored per block entity in their dynamic properties
- * storage.
- * @example rememberPlayerInteraction.ts
- * ```typescript
- * import { system } from '@minecraft/server-wrapper';
- *
- * system.beforeEvents.startup.subscribe(initEvent => {
- *   initEvent.blockComponentRegistry.registerCustomComponent('scripting_demo_pack:block_entity_onPlayerInteract', {
- *     onPlayerInteract: e => {
- *       if (e.player === undefined) {
- *         return;
- *       }
- *
- *       const dynamicProperties = e.block.getComponent('minecraft:dynamic_properties');
- *       if (!dynamicProperties) {
- *         return;
- *       }
- *
- *       const lastInteractorValue = dynamicProperties.get('last_interactor');
- *       const lastVisitor = typeof lastInteractorValue === 'string' ? lastInteractorValue : 'unknown';
- *       const lastTick = Number(dynamicProperties.get('last_interact_tick') ?? system.currentTick);
- *       const ticksAgo = Math.max(0, system.currentTick - lastTick);
- *
- *       if (lastVisitor === e.player.name) {
- *         e.player.sendMessage("do you remember that player? I 'member, it was here " + String(ticksAgo) + ' ticks ago!');
- *       } else {
- *         e.player.sendMessage("oh, I don't remember that player");
- *       }
- *
- *       dynamicProperties.set('last_interactor', e.player.name);
- *       dynamicProperties.set('last_interact_tick', system.currentTick);
- *     },
- *   });
- * });
- * ```
+ * Contains information regarding an event that impacts a
+ * specific block.
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class BlockDynamicPropertiesComponent extends BlockComponent {
+export class BlockEvent {
     private constructor();
-    static readonly componentId = 'minecraft:dynamic_properties';
     /**
      * @remarks
-     * Returns a DynamicProperty that was stored with the provided
-     * key. Keys are unique to each content pack and cannot be used
-     * to retrieve dynamic properties set from other content packs.
-     * Returns undefined if the key was not found.
-     *
-     * @throws This function can throw errors.
-     *
-     * {@link Error}
-     *
-     * {@link InvalidBlockComponentError}
-     *
-     * {@link LocationInUnloadedChunkError}
+     * Block currently in the world at the location of this event.
      *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    get(key: string): boolean | number | string | Vector3 | undefined;
+    readonly block: Block;
     /**
      * @remarks
-     * Sets a dynamic property with the provided key and value.
-     * Keys are unique to each content pack and cannot be used to
-     * set dynamic properties for other content packs. Values can
-     * be either a Number, a String or a Vector3. Setting a
-     * property with an undefined value will remove it from the
-     * storage.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @throws This function can throw errors.
-     *
-     * {@link Error}
-     *
-     * {@link InvalidBlockComponentError}
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
-     */
-    set(key: string, value?: boolean | number | string | Vector3): void;
-    /**
-     * @remarks
-     * Returns the current size, in bytes, of the dynamic
-     * properties storage for this block entity.
-     *
-     * @throws This function can throw errors.
-     *
-     * {@link Error}
-     *
-     * {@link InvalidBlockComponentError}
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
-     */
-    totalByteCount(): number;
-}
-
-/**
- * Contains information regarding an event that impacts a
- * specific block.
- */
-export class BlockEvent {
-    private constructor();
-    /**
-     * @remarks
-     * Block currently in the world at the location of this event.
-     *
-     */
-    readonly block: Block;
-    /**
-     * @remarks
-     * Dimension that contains the block that is the subject of
-     * this event.
+     * Dimension that contains the block that is the subject of
+     * this event.
      *
      */
     readonly dimension: Dimension;
@@ -5499,18 +5041,6 @@ export class BlockLocationIterator implements Iterable<Vector3> {
      *
      */
     [Symbol.iterator](): Iterator<Vector3>;
-    /**
-     * @beta
-     * @remarks
-     * Checks if the underlining block volume has been invalidated.
-     * Will return false if the block volume was modified between
-     * creating the iterator and iterating it, and true otherwise.
-     *
-     * @throws This function can throw errors.
-     *
-     * {@link minecraftcommon.EngineError}
-     */
-    isValid(): boolean;
     /**
      * @remarks
      * This function can't be called in restricted-execution mode.
@@ -6427,15 +5957,6 @@ 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)
@@ -6666,23 +6187,6 @@ export class Camera {
             | CameraSetRotOptions
             | CameraTargetOptions,
     ): void;
-    /**
-     * @beta
-     * @remarks
-     * Sets the current active camera with easing.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param cameraPreset
-     * Identifier of a camera preset file defined within JSON.
-     * @param easeOptions
-     * Options to ease the camera from the previous camera to the
-     * current one.
-     * @throws
-     * Throws when easing to minecraft:first_person presets
-     * currently without the experimental cameras toggle enabled.
-     */
-    setCameraWithEase(cameraPreset: string, easeOptions: EaseOptions): void;
     /**
      * @remarks
      * Sets the current active camera for the specified player and
@@ -6722,164 +6226,6 @@ export class CatmullRomSpline {
     controlPoints: Vector3[];
 }
 
-/**
- * @beta
- * An event that fires as players enter chat messages.
- */
-export class ChatSendAfterEvent {
-    private constructor();
-    /**
-     * @remarks
-     * Message that is being broadcast.
-     *
-     */
-    readonly message: string;
-    /**
-     * @remarks
-     * Player that sent the chat message.
-     *
-     */
-    readonly sender: Player;
-    /**
-     * @remarks
-     * Optional list of players that will receive this message. If
-     * defined, this message is directly targeted to one or more
-     * players (i.e., is not broadcast.)
-     *
-     */
-    readonly targets?: Player[];
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to chat messages being
- * sent.
- */
-export class ChatSendAfterEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called when new chat messages
-     * are sent.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    subscribe(callback: (arg0: ChatSendAfterEvent) => void): (arg0: ChatSendAfterEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called when new chat messages
-     * are sent.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    unsubscribe(callback: (arg0: ChatSendAfterEvent) => void): void;
-}
-
-/**
- * @beta
- * An event that fires as players enter chat messages.
- */
-export class ChatSendBeforeEvent {
-    private constructor();
-    /**
-     * @remarks
-     * If set to true in a beforeChat event handler, this message
-     * is not broadcast out.
-     *
-     */
-    cancel: boolean;
-    /**
-     * @remarks
-     * Message that is being broadcast.
-     *
-     */
-    readonly message: string;
-    /**
-     * @remarks
-     * Player that sent the chat message.
-     *
-     */
-    readonly sender: Player;
-    /**
-     * @remarks
-     * Optional list of players that will receive this message. If
-     * defined, this message is directly targeted to one or more
-     * players (i.e., is not broadcast.)
-     *
-     */
-    readonly targets?: Player[];
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to an event that fires
- * before chat messages are sent.
- * @example customCommand.ts
- * ```typescript
- * import { world, DimensionLocation } from '@minecraft/server';
- *
- * function customCommand(targetLocation: DimensionLocation) {
- *   const chatCallback = world.beforeEvents.chatSend.subscribe(eventData => {
- *     if (eventData.message.includes('cancel')) {
- *       // Cancel event if the message contains "cancel"
- *       eventData.cancel = true;
- *     } else {
- *       const args = eventData.message.split(' ');
- *
- *       if (args.length > 0) {
- *         switch (args[0].toLowerCase()) {
- *           case 'echo':
- *             // Send a modified version of chat message
- *             world.sendMessage(`Echo '${eventData.message.substring(4).trim()}'`);
- *             break;
- *           case 'help':
- *             world.sendMessage(`Available commands: echo <message>`);
- *             break;
- *         }
- *       }
- *     }
- *   });
- * }
- * ```
- */
-export class ChatSendBeforeEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called before new chat messages
-     * are sent.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     * @returns
-     * Closure that is called with restricted-execution privilege.
-     */
-    subscribe(callback: (arg0: ChatSendBeforeEvent) => void): (arg0: ChatSendBeforeEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called before new chat
-     * messages are sent.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     */
-    unsubscribe(callback: (arg0: ChatSendBeforeEvent) => void): void;
-}
-
 /**
  * Contains the device information for a client instance.
  */
@@ -6953,363 +6299,111 @@ export class Component {
 }
 
 /**
- * @beta
- * The Compound Block Volume is a collection of individual
- * block volume definitions which, as a collection, define a
- * larger volume of (sometimes non-contiguous) irregular
- * shapes.
- * This class is loosely based on the concept of CSG
- * (Computational Solid Geometry) and allows a user to create
- * complex volumes by building a stack of volumes and voids to
- * make a larger single volume.
- * For example - normally a creator would create a hollow cube
- * by creating 6 "wall" surfaces for each face.
- * With a Compound Block Volume, a creator can define a hollow
- * cube by creating a single outer solid cube, and then
- * defining a further single 'void' cube inside the larger one.
- * Similarly, the Compound Block Volume can represent irregular
- * shaped volumes (e.g. a tree consists of a trunk and lots of
- * leaf cubes which are not necessarily contiguously placed).
- * Each of the volumes added to the CompoundBlockVolume are (by
- * default) relative to the origin set (either at construction
- * or via one of the set functions).
- * However, it is also possible to push volumes to the compound
- * collection which are absolute in nature and are not affected
- * by origin changes.
+ * Represents a container that can hold sets of items. Used
+ * with entities such as Players, Chest Minecarts, Llamas, and
+ * more.
+ * @example containers.ts
+ * ```typescript
+ * import { ItemStack, EntityInventoryComponent, BlockInventoryComponent, DimensionLocation } from '@minecraft/server';
+ * import { MinecraftBlockTypes, MinecraftItemTypes, MinecraftEntityTypes } from '@minecraft/vanilla-data';
+ *
+ * function containers(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
+ *   const xLocation = targetLocation; // left chest location
+ *   const xPlusTwoLocation = { x: targetLocation.x + 2, y: targetLocation.y, z: targetLocation.z }; // right chest
+ *
+ *   const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
+ *     x: targetLocation.x + 4,
+ *     y: targetLocation.y,
+ *     z: targetLocation.z,
+ *   });
+ *
+ *   const xChestBlock = targetLocation.dimension.getBlock(xLocation);
+ *   const xPlusTwoChestBlock = targetLocation.dimension.getBlock(xPlusTwoLocation);
+ *
+ *   if (!xChestBlock || !xPlusTwoChestBlock) {
+ *     log('Could not retrieve chest blocks.');
+ *     return;
+ *   }
+ *
+ *   xChestBlock.setType(MinecraftBlockTypes.Chest);
+ *   xPlusTwoChestBlock.setType(MinecraftBlockTypes.Chest);
+ *
+ *   const xPlusTwoChestInventoryComp = xPlusTwoChestBlock.getComponent('inventory') as BlockInventoryComponent;
+ *   const xChestInventoryComponent = xChestBlock.getComponent('inventory') as BlockInventoryComponent;
+ *   const chestCartInventoryComp = chestCart.getComponent('inventory') as EntityInventoryComponent;
+ *
+ *   const xPlusTwoChestContainer = xPlusTwoChestInventoryComp.container;
+ *   const xChestContainer = xChestInventoryComponent.container;
+ *   const chestCartContainer = chestCartInventoryComp.container;
+ *
+ *   if (!xPlusTwoChestContainer || !xChestContainer || !chestCartContainer) {
+ *     log('Could not retrieve chest containers.');
+ *     return;
+ *   }
+ *
+ *   xPlusTwoChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Apple, 10));
+ *   if (xPlusTwoChestContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
+ *     log('Expected apple in x+2 container slot index 0', -1);
+ *   }
+ *
+ *   xPlusTwoChestContainer.setItem(1, new ItemStack(MinecraftItemTypes.Emerald, 10));
+ *   if (xPlusTwoChestContainer.getItem(1)?.typeId !== MinecraftItemTypes.Emerald) {
+ *     log('Expected emerald in x+2 container slot index 1', -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.size !== 27) {
+ *     log('Unexpected size: ' + xPlusTwoChestContainer.size, -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.emptySlotsCount !== 25) {
+ *     log('Unexpected emptySlotsCount: ' + xPlusTwoChestContainer.emptySlotsCount, -1);
+ *   }
+ *
+ *   xChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Cake, 10));
+ *
+ *   xPlusTwoChestContainer.transferItem(0, chestCartContainer); // transfer the apple from the xPlusTwo chest to a chest cart
+ *   xPlusTwoChestContainer.swapItems(1, 0, xChestContainer); // swap the cake from x and the emerald from xPlusTwo
+ *
+ *   if (chestCartContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
+ *     log('Expected apple in minecraft chest container slot index 0', -1);
+ *   }
+ *
+ *   if (xChestContainer.getItem(0)?.typeId === MinecraftItemTypes.Emerald) {
+ *     log('Expected emerald in x container slot index 0', -1);
+ *   }
+ *
+ *   if (xPlusTwoChestContainer.getItem(1)?.typeId === MinecraftItemTypes.Cake) {
+ *     log('Expected cake in x+2 container slot index 1', -1);
+ *   }
+ * }
+ * ```
  */
-export class CompoundBlockVolume {
+export class Container {
+    private constructor();
     /**
      * @remarks
-     * Return the 'capacity' of the bounding rectangle which
-     * represents the collection of volumes in the stack
+     * If these rules are defined other container operations will
+     * throw if they cause these rules to be invalidated. For
+     * example, adding a shulker box to a vanilla bundle.
      *
      */
-    readonly capacity: number;
-    readonly items: CompoundBlockVolumeItem[];
-    readonly itemsAbsolute: CompoundBlockVolumeItem[];
+    readonly containerRules?: ContainerRules;
     /**
      * @remarks
-     * Return the number of volumes (positive and negative) in the
-     * volume stack
+     * Count of the slots in the container that are empty.
      *
+     * @throws
+     * Throws if the container is invalid.
      */
-    readonly volumeCount: number;
+    readonly emptySlotsCount: number;
     /**
      * @remarks
-     * Create a CompoundBlockVolume object
+     * Returns whether a container object (or the entity or block
+     * that this container is associated with) is still available
+     * for use in this context.
      *
-     * @param origin
-     * An optional world space origin on which to center the
-     * compound volume.
-     * If not specified, the origin is set to (0,0,0)
      */
-    constructor(origin?: Vector3);
-    /**
-     * @remarks
-     * Clear the contents of the volume stack
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    clear(): void;
-    /**
-     * @remarks
-     * Fetch a Block Location Iterator for the Compound Block
-     * Volume.  This iterator will allow a creator to iterate
-     * across all of the selected volumes within the larger
-     * bounding area.
-     * Areas of a volume which have been overridden by a
-     * subtractive volume will not be included in the iterator
-     * step.
-     * (i.e. if you push a cube to the stack, and then push a
-     * subtractive volume to the same location, then the iterator
-     * will step over the initial volume because it is considered
-     * negative space)
-     * Note that the Block Locations returned by this iterator are
-     * in absolute world space (irrespective of whether the
-     * compound volume items pushed are absolute or relative)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    getBlockLocationIterator(): BlockLocationIterator;
-    /**
-     * @remarks
-     * Get the largest bounding box that represents a container for
-     * all of the volumes on the stack
-     * Note that the bounding box returned is represented in
-     * absolute world space  (irrespective of whether the compound
-     * volume items pushed are absolute or relative)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    getBoundingBox(): BlockBoundingBox;
-    /**
-     * @remarks
-     * Get the max block location of the outermost bounding
-     * rectangle which represents the volumes on the stack.
-     * Note that the max location returned is in absolute world
-     * space (irrespective of whether the compound volume items
-     * pushed are absolute or relative)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    getMax(): Vector3;
-    /**
-     * @remarks
-     * Get the min block location of the outermost bounding
-     * rectangle which represents the volumes on the stack.
-     * Note that the min location returned is in absolute world
-     * space (irrespective of whether the compound volume items
-     * pushed are absolute or relative)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    getMin(): Vector3;
-    /**
-     * @remarks
-     * Fetch the origin in world space of the compound volume
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    getOrigin(): Vector3;
-    /**
-     * @remarks
-     * Return a boolean which signals if there are any volume items
-     * pushed to the volume
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    isEmpty(): boolean;
-    /**
-     * @remarks
-     * Return a boolean representing whether or not a given
-     * absolute world space block location is inside a positive
-     * block volume.
-     * E.g. if the stack contains a large cube followed by a
-     * slightly smaller negative cube, and the test location is
-     * within the negative cube - the function will return false
-     * because it's not 'inside' a volume (it IS inside the
-     * bounding rectangle, but it is not inside a positively
-     * defined location)
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    isInside(worldLocation: Vector3): boolean;
-    /**
-     * @remarks
-     * Inspect the last entry pushed to the volume stack without
-     * affecting the stack contents.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param forceRelativity
-     * Determine whether the function returns a
-     * CompoundBlockVolumeItem which is forced into either relative
-     * or absolute coordinate system.
-     * `true` = force returned item to be relative to volume origin
-     * `false` = force returned item to be absolute world space
-     * location
-     *
-     * If no flag is specified, the item returned retains whatever
-     * relativity it had when it was pushed
-     * @returns
-     * Returns undefined if the stack is empty
-     */
-    peekLastVolume(forceRelativity?: CompoundBlockVolumePositionRelativity): CompoundBlockVolumeItem | undefined;
-    /**
-     * @remarks
-     * Remove the last entry from the volume stack.  This will
-     * reduce the stack size by one
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    popVolume(): boolean;
-    /**
-     * @remarks
-     * Push a volume item to the stack.  The volume item contains
-     * an 'action' parameter which determines whether this volume
-     * is a positive or negative space.
-     * The item also contains a `locationRelativity` which
-     * determines whether it is relative or absolute to the
-     * compound volume origin
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param item
-     * Item to push to the end of the stack
-     */
-    pushVolume(item: CompoundBlockVolumeItem): void;
-    /**
-     * @remarks
-     * If the volume stack is empty, this function will push the
-     * specified item to the stack.
-     * If the volume stack is NOT empty, this function will replace
-     * the last item on the stack with the new item.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param item
-     * Item to add or replace
-     */
-    replaceOrAddLastVolume(item: CompoundBlockVolumeItem): boolean;
-    /**
-     * @remarks
-     * Set the origin of the compound volume to an absolute world
-     * space location
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param preserveExistingVolumes
-     * This optional boolean flag determines whether the relative
-     * `CompoundBlockVolumeItem`'s are frozen in place, or are
-     * affected by the new origin.
-     * Imagine a scenario where you have a series of relative
-     * locations around an origin which make up a sphere; all of
-     * these locations are in the range of -2 to 2.
-     * Push each of these locations to the compound volume as
-     * relative items.
-     * Now, move the origin and all of the locations representing
-     * the sphere move accordingly.
-     * However, let's say you want to add a 2nd sphere next to the
-     * 1st.
-     * In this case, set the new origin a few locations over, but
-     * 'preserveExistingVolumes' = true.
-     * This will set a new origin, but the existing sphere
-     * locations will remain relative to the original origin.
-     * Now, you can push the relative sphere locations again (this
-     * time they will be relative to the new origin) - resulting in
-     * 2 spheres next to each other.
-     */
-    setOrigin(position: Vector3, preserveExistingVolumes?: boolean): void;
-    /**
-     * @remarks
-     * Similar to {@link CompoundBlockVolume.setOrigin} - this
-     * function will translate the origin by a given delta to a new
-     * position
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param preserveExistingVolumes
-     * See the description for the arguments to {@link
-     * CompoundBlockVolume.setOrigin}
-     */
-    translateOrigin(delta: Vector3, preserveExistingVolumes?: boolean): void;
-}
-
-/**
- * Represents a container that can hold sets of items. Used
- * with entities such as Players, Chest Minecarts, Llamas, and
- * more.
- * @example containers.ts
- * ```typescript
- * import { ItemStack, EntityInventoryComponent, BlockInventoryComponent, DimensionLocation } from '@minecraft/server';
- * import { MinecraftBlockTypes, MinecraftItemTypes, MinecraftEntityTypes } from '@minecraft/vanilla-data';
- *
- * function containers(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
- *   const xLocation = targetLocation; // left chest location
- *   const xPlusTwoLocation = { x: targetLocation.x + 2, y: targetLocation.y, z: targetLocation.z }; // right chest
- *
- *   const chestCart = targetLocation.dimension.spawnEntity(MinecraftEntityTypes.ChestMinecart, {
- *     x: targetLocation.x + 4,
- *     y: targetLocation.y,
- *     z: targetLocation.z,
- *   });
- *
- *   const xChestBlock = targetLocation.dimension.getBlock(xLocation);
- *   const xPlusTwoChestBlock = targetLocation.dimension.getBlock(xPlusTwoLocation);
- *
- *   if (!xChestBlock || !xPlusTwoChestBlock) {
- *     log('Could not retrieve chest blocks.');
- *     return;
- *   }
- *
- *   xChestBlock.setType(MinecraftBlockTypes.Chest);
- *   xPlusTwoChestBlock.setType(MinecraftBlockTypes.Chest);
- *
- *   const xPlusTwoChestInventoryComp = xPlusTwoChestBlock.getComponent('inventory') as BlockInventoryComponent;
- *   const xChestInventoryComponent = xChestBlock.getComponent('inventory') as BlockInventoryComponent;
- *   const chestCartInventoryComp = chestCart.getComponent('inventory') as EntityInventoryComponent;
- *
- *   const xPlusTwoChestContainer = xPlusTwoChestInventoryComp.container;
- *   const xChestContainer = xChestInventoryComponent.container;
- *   const chestCartContainer = chestCartInventoryComp.container;
- *
- *   if (!xPlusTwoChestContainer || !xChestContainer || !chestCartContainer) {
- *     log('Could not retrieve chest containers.');
- *     return;
- *   }
- *
- *   xPlusTwoChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Apple, 10));
- *   if (xPlusTwoChestContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
- *     log('Expected apple in x+2 container slot index 0', -1);
- *   }
- *
- *   xPlusTwoChestContainer.setItem(1, new ItemStack(MinecraftItemTypes.Emerald, 10));
- *   if (xPlusTwoChestContainer.getItem(1)?.typeId !== MinecraftItemTypes.Emerald) {
- *     log('Expected emerald in x+2 container slot index 1', -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.size !== 27) {
- *     log('Unexpected size: ' + xPlusTwoChestContainer.size, -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.emptySlotsCount !== 25) {
- *     log('Unexpected emptySlotsCount: ' + xPlusTwoChestContainer.emptySlotsCount, -1);
- *   }
- *
- *   xChestContainer.setItem(0, new ItemStack(MinecraftItemTypes.Cake, 10));
- *
- *   xPlusTwoChestContainer.transferItem(0, chestCartContainer); // transfer the apple from the xPlusTwo chest to a chest cart
- *   xPlusTwoChestContainer.swapItems(1, 0, xChestContainer); // swap the cake from x and the emerald from xPlusTwo
- *
- *   if (chestCartContainer.getItem(0)?.typeId !== MinecraftItemTypes.Apple) {
- *     log('Expected apple in minecraft chest container slot index 0', -1);
- *   }
- *
- *   if (xChestContainer.getItem(0)?.typeId === MinecraftItemTypes.Emerald) {
- *     log('Expected emerald in x container slot index 0', -1);
- *   }
- *
- *   if (xPlusTwoChestContainer.getItem(1)?.typeId === MinecraftItemTypes.Cake) {
- *     log('Expected cake in x+2 container slot index 1', -1);
- *   }
- * }
- * ```
- */
-export class Container {
-    private constructor();
-    /**
-     * @remarks
-     * If these rules are defined other container operations will
-     * throw if they cause these rules to be invalidated. For
-     * example, adding a shulker box to a vanilla bundle.
-     *
-     */
-    readonly containerRules?: ContainerRules;
-    /**
-     * @remarks
-     * Count of the slots in the container that are empty.
-     *
-     * @throws
-     * Throws if the container is invalid.
-     */
-    readonly emptySlotsCount: number;
-    /**
-     * @remarks
-     * Returns whether a container object (or the entity or block
-     * that this container is associated with) is still available
-     * for use in this context.
-     *
-     */
-    readonly isValid: boolean;
+    readonly isValid: boolean;
     /**
      * @remarks
      * The number of slots in this container. For example, a
@@ -7341,9 +6435,7 @@ export class Container {
      *
      * @param itemStack
      * The stack of items to add.
-     * @throws
-     * Won't throw {@link ContainerRules} error for over weight
-     * limit but will instead add items up to the weight limit.
+     * @throws This function can throw errors.
      *
      * {@link ContainerRulesError}
      *
@@ -7581,8 +6673,6 @@ 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}
      *
@@ -8365,30 +7455,6 @@ export class Dimension {
         block: BlockPermutation | BlockType | string,
         options?: BlockFillOptions,
     ): ListBlockVolume;
-    /**
-     * @beta
-     * @remarks
-     * Finds the location of the closest biome of a particular
-     * type. Note that the findClosestBiome operation can take some
-     * time to complete, so avoid using many of these calls within
-     * a particular tick.
-     *
-     * @param pos
-     * Starting location to look for a biome to find.
-     * @param biomeToFind
-     * Identifier of the biome to look for.
-     * @param options
-     * Additional selection criteria for a biome search.
-     * @returns
-     * Returns a location of the biome, or undefined if a biome
-     * could not be found.
-     * @throws This function can throw errors.
-     *
-     * {@link minecraftcommon.EngineError}
-     *
-     * {@link Error}
-     */
-    findClosestBiome(pos: Vector3, biomeToFind: BiomeType | string, options?: BiomeSearchOptions): Vector3 | undefined;
     /**
      * @remarks
      * Returns the biome type at the specified location.
@@ -8490,8 +7556,12 @@ export class Dimension {
      * locations that satisfied the block filter.
      * @throws This function can throw errors.
      *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
      * {@link Error}
      *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
      * {@link UnloadedChunksError}
      */
     getBlocks(volume: BlockVolumeBase, filter: BlockFilter, allowUnloadedChunks?: boolean): ListBlockVolume;
@@ -8608,26 +7678,6 @@ 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
@@ -8689,16 +7739,6 @@ 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
@@ -8944,11 +7984,7 @@ export class Dimension {
      * }
      * ```
      */
-    spawnEntity<T = never>(
-        identifier: EntityIdentifierType<NoInfer<T>>,
-        location: Vector3,
-        options?: SpawnEntityOptions,
-    ): Entity;
+    spawnEntity(identifier: EntityType | string, location: Vector3, options?: SpawnEntityOptions): Entity;
     /**
      * @remarks
      * Creates a new item stack as an entity at the specified
@@ -9043,71 +8079,31 @@ export class Dimension {
      * ```
      */
     spawnParticle(effectName: string, location: Vector3, molangVariables?: MolangVariableMap): void;
+}
+
+/**
+ * @rc
+ * Provides the functionality for registering custom
+ * dimensions. Custom dimensions can only be registered during
+ * the system startup event.
+ */
+export class DimensionRegistry {
+    private constructor();
     /**
-     * @beta
      * @remarks
-     * Spawns an experience orb at a specified location in the
-     * dimension.
+     * Registers a new custom dimension type. Must be called during
+     * the system startup event. The dimension will be created
+     * using the void generator.
      *
-     * This function can't be called in restricted-execution mode.
+     * This function can be called in early-execution mode.
      *
-     * @param location
-     * The location at which to spawn the experience orb.
-     * @param amount
-     * The amount of experience to give the experience orb.
-     * Bounds: [1, 12000]
+     * @param typeId
+     * The namespaced identifier for the custom dimension (e.g.,
+     * 'mypack:my_dimension'). Must include a namespace and use
+     * only valid identifier characters.
      * @throws This function can throw errors.
      *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
-     */
-    spawnXp(location: Vector3, amount: number): void;
-    /**
-     * @beta
-     * @remarks
-     * Stops all sounds from playing for all players.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     */
-    stopAllSounds(): void;
-    /**
-     * @beta
-     * @remarks
-     * Stops a sound from playing for all players.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param soundId
-     * Identifier of the sound.
-     */
-    stopSound(soundId: string): void;
-}
-
-/**
- * @rc
- * Provides the functionality for registering custom
- * dimensions. Custom dimensions can only be registered during
- * the system startup event.
- */
-export class DimensionRegistry {
-    private constructor();
-    /**
-     * @remarks
-     * Registers a new custom dimension type. Must be called during
-     * the system startup event. The dimension will be created
-     * using the void generator.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param typeId
-     * The namespaced identifier for the custom dimension (e.g.,
-     * 'mypack:my_dimension'). Must include a namespace and use
-     * only valid identifier characters.
-     * @throws This function can throw errors.
-     *
-     * {@link CustomDimensionAlreadyRegisteredError}
+     * {@link CustomDimensionAlreadyRegisteredError}
      *
      * {@link CustomDimensionInvalidRegistryError}
      *
@@ -9635,7 +8631,7 @@ export class Entity {
      */
     readonly location: Vector3;
     /**
-     * @beta
+     * @rc
      * @remarks
      * Boolean which determines if the player nameplate should be
      * depth tested for visibility.
@@ -9645,7 +8641,7 @@ export class Entity {
      */
     nameplateDepthTested: boolean;
     /**
-     * @beta
+     * @rc
      * @remarks
      * Float that determines the render distance of this entity's
      * nameplate.
@@ -9669,18 +8665,6 @@ 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,
@@ -10921,18 +9905,6 @@ export class EntityBaseMovementComponent extends EntityComponent {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityBreathableComponent extends EntityComponent {
     private constructor();
-    /**
-     * @beta
-     * @remarks
-     * The current air supply of the entity.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     * @throws
-     * Will throw an error if the air supply is out of bounds
-     * [suffocationTime, maxAirSupply].
-     */
-    airSupply: number;
     /**
      * @remarks
      * If true, this entity can breathe in air.
@@ -10961,14 +9933,6 @@ 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
@@ -11444,140 +10408,6 @@ export class EntityFlyingSpeedComponent extends EntityComponent {
     static readonly componentId = 'minecraft:flying_speed';
 }
 
-/**
- * @beta
- * Provides access to the fog definitions stack of a player
- * entity, allowing scripts to push, pop, remove, and query
- * active fog definitions.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class EntityFogComponent extends EntityComponent {
-    private constructor();
-    static readonly componentId = 'minecraft:player.fog';
-    /**
-     * @remarks
-     * Sets the player's fog stack to the given list of fog
-     * identifiers, replacing any existing entries.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param fogIds
-     * A stack of fog definition identifiers to set on the player's
-     * fog stack (e.g. ['minecraft:fog_bamboo_jungle']). Maximum of
-     * 16 entries.
-     * @param tag
-     * An optional tag to associate with the new entries, used to
-     * target them with pop or remove.
-     * @throws
-     * Throws if the entity is invalid, if more than 16 fog
-     * identifiers are provided, or if any fog identifier is
-     * invalid.
-     *
-     * {@link EntityFogComponentError}
-     *
-     * {@link InvalidEntityError}
-     */
-    applyStack(fogIds: string[], tag?: string): void;
-    /**
-     * @remarks
-     * Returns the list of fog identifiers currently on the
-     * player's fog stack, ordered from bottom to top.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * An array of fog definition identifiers currently on the
-     * stack.
-     * @throws
-     * Throws if the entity is invalid.
-     *
-     * {@link InvalidEntityError}
-     */
-    getStack(): string[];
-    /**
-     * @remarks
-     * Returns the list of tags currently present on the player's
-     * fog stack.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * An array of tag strings associated with fog settings on the
-     * stack.
-     * @throws
-     * Throws if the entity is invalid.
-     *
-     * {@link InvalidEntityError}
-     */
-    getTags(): string[];
-    /**
-     * @remarks
-     * Removes the most recently pushed fog definition from the
-     * player's fog stack.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param tag
-     * An optional tag identifying which entry to pop. If provided,
-     * searches the stack from top to bottom and removes the most
-     * recently pushed entry with this tag. If omitted, removes the
-     * most recently pushed entry regardless of tag.
-     * @returns
-     * Returns the identifier of the popped fog definition, or
-     * undefined if the stack was unchanged.
-     * @throws
-     * Throws if the entity is invalid.
-     *
-     * {@link InvalidEntityError}
-     */
-    pop(tag?: string): string | undefined;
-    /**
-     * @remarks
-     * Pushes a new fog definition onto the player's fog stack.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param fogId
-     * The identifier of the fog definition to push onto the stack
-     * (e.g. 'minecraft:fog_bamboo_jungle').
-     * @param tag
-     * An optional tag used to label this fog definition on the
-     * stack, allowing it to be targeted by pop or remove. If
-     * omitted, the entry is stored with the tag 'untagged'.
-     * @returns
-     * Returns the zero-based index at which the fog definition was
-     * inserted into the stack.
-     * @throws
-     * Throws if the entity is invalid, the fog identifier is
-     * invalid, or if the stack limit of 16 has been exceeded.
-     *
-     * {@link EntityFogComponentError}
-     *
-     * {@link InvalidEntityError}
-     */
-    push(fogId: string, tag?: string): number;
-    /**
-     * @remarks
-     * Removes all fog definitions with the given tag from the
-     * player's fog stack. If no tag is provided, clears all fog
-     * definitions.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param tag
-     * An optional tag identifying which the entries to remove. If
-     * omitted, clears all fog definitions regardless of tag.
-     * @returns
-     * Returns true if at least one entry was removed, or false if
-     * the stack was unchanged.
-     * @throws
-     * Throws if the entity is invalid.
-     *
-     * {@link InvalidEntityError}
-     */
-    remove(tag?: string): boolean;
-}
-
 /**
  * Defines how much friction affects this entity.
  */
@@ -13058,42 +11888,6 @@ export class EntityNavigationWalkComponent extends EntityNavigationComponent {
     static readonly componentId = 'minecraft:navigation.walk';
 }
 
-/**
- * @beta
- * Adds NPC capabilities to an entity such as custom skin,
- * name, and dialogue interactions.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class EntityNpcComponent extends EntityComponent {
-    private constructor();
-    /**
-     * @remarks
-     * The DialogueScene that is opened when players first interact
-     * with the NPC.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    defaultScene: string;
-    /**
-     * @remarks
-     * The name of the NPC as it is displayed to players.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    name: string;
-    /**
-     * @remarks
-     * The index of the skin the NPC will use.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    skinIndex: number;
-    static readonly componentId = 'minecraft:npc';
-}
-
 /**
  * When present on an entity, this entity is on fire.
  * @example setOnFire.ts
@@ -13766,54 +12560,6 @@ export class EntitySpawnAfterEventSignal {
     unsubscribe(callback: (arg0: EntitySpawnAfterEvent) => void): void;
 }
 
-/**
- * @beta
- * Contains data related to an entity beginning to sneak.
- */
-export class EntityStartSneakingAfterEvent {
-    private constructor();
-    /**
-     * @remarks
-     * Entity that has started sneaking.
-     *
-     */
-    readonly entity: Entity;
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to when an entity
- * begins sneaking.
- */
-export class EntityStartSneakingAfterEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called when an entity begins
-     * sneaking.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    subscribe(
-        callback: (arg0: EntityStartSneakingAfterEvent) => void,
-        options?: EntitySneakingChangedEventOptions,
-    ): (arg0: EntityStartSneakingAfterEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called when an entity begins
-     * sneaking.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    unsubscribe(callback: (arg0: EntityStartSneakingAfterEvent) => void): void;
-}
-
 /**
  * Defines the entity's ability to carry items. An entity with
  * a higher strength would have higher potential carry capacity
@@ -14013,7 +12759,7 @@ export class EntityTypes {
      * Retrieves an entity type using a string-based identifier.
      *
      */
-    static get<T = never>(identifier: EntityIdentifierType<NoInfer<T>>): EntityType | undefined;
+    static get(identifier: string): EntityType | undefined;
     /**
      * @remarks
      * Retrieves a set of all entity types within this world.
@@ -14610,13 +13356,6 @@ export class GameRules {
      *
      */
     playersSleepingPercentage: number;
-    /**
-     * @beta
-     * @remarks
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    playerWaypoints: PlayerWaypointsMode;
     /**
      * @remarks
      * This property can't be edited in restricted-execution mode.
@@ -17120,10 +15859,6 @@ export class LootingEnchantFunction extends LootItemFunction {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class LootItem extends LootPoolEntry {
     private constructor();
-    /**
-     * @beta
-     */
-    readonly conditions: LootItemCondition[];
     readonly functions: LootItemFunction[];
     /**
      * @remarks
@@ -17479,33 +16214,6 @@ 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.
@@ -17575,61 +16283,18 @@ export class MolangVariableMap {
 }
 
 /**
- * @beta
- * Pack setting name and value that changed.
- */
-export class PackSettingChangeAfterEvent {
-    private constructor();
-    /**
-     * @remarks
-     * The name of the setting.
-     *
-     */
-    readonly settingName: string;
-    /**
-     * @remarks
-     * The value of the setting.
-     *
-     */
-    readonly settingValue: boolean | number | string;
-}
-
-/**
- * @beta
+ * Loot item condition that checks whether the looting entity
+ * is currently a passenger of a specific type of entity.
  */
-export class PackSettingChangeAfterEventSignal {
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PassengerOfEntityCondition extends LootItemCondition {
     private constructor();
     /**
      * @remarks
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    subscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): (arg0: PackSettingChangeAfterEvent) => void;
-    /**
-     * @remarks
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
+     * The entity type required for this condition to pass.
      *
      */
-    unsubscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): void;
-}
-
-/**
- * Loot item condition that checks whether the looting entity
- * is currently a passenger of a specific type of entity.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PassengerOfEntityCondition extends LootItemCondition {
-    private constructor();
-    /**
-     * @remarks
-     * The entity type required for this condition to pass.
-     *
-     */
-    readonly entityType: string;
+    readonly entityType: string;
 }
 
 /**
@@ -17784,62 +16449,6 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly camera: Camera;
-    /**
-     * @beta
-     * @remarks
-     * The player's chat display name, composed from {@link
-     * Player.chatNamePrefix} + {@link Player.name} + {@link
-     * Player.chatNameSuffix}. This is the name shown as the author
-     * of chat messages sent by this player. To change the name
-     * shown above the player's head, use {@link Entity.nameTag}.
-     *
-     * @throws This property can throw when used.
-     *
-     * {@link InvalidEntityError}
-     */
-    readonly chatDisplayName: string;
-    /**
-     * @beta
-     * @remarks
-     * An optional string that, when set, is prepended to the text
-     * of chat messages sent by this player. Useful for applying
-     * formatting or color codes to a player's messages (e.g., '§a'
-     * to make their messages green). Does not affect the player's
-     * name display - use {@link Player.chatNamePrefix} for the
-     * name shown in chat, or {@link Entity.nameTag} for the name
-     * above the player's head. Set to undefined to clear.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    chatMessagePrefix?: string;
-    /**
-     * @beta
-     * @remarks
-     * An optional string that, when set, is prepended to the
-     * player's name in chat messages. Does not affect the name tag
-     * above the player's head or the player list - use {@link
-     * Entity.nameTag} for that. To prefix the message text itself,
-     * use {@link Player.chatMessagePrefix}. Set to undefined to
-     * clear.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    chatNamePrefix?: string;
-    /**
-     * @beta
-     * @remarks
-     * An optional string that, when set, is appended to the
-     * player's name in chat messages. Does not affect the name tag
-     * above the player's head or the player list - use {@link
-     * Entity.nameTag} for that. See also {@link
-     * Player.chatNamePrefix}. Set to undefined to clear.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    chatNameSuffix?: string;
     /**
      * @remarks
      * Contains the player's device information.
@@ -17943,18 +16552,6 @@ export class Player extends Entity {
      * {@link InvalidEntityError}
      */
     readonly playerPermissionLevel: PlayerPermissionLevel;
-    /**
-     * @beta
-     * @remarks
-     * Gets the player's Playfab ID.
-     *
-     * @throws This property can throw when used.
-     *
-     * {@link minecraftcommon.EngineError}
-     *
-     * {@link InvalidEntityError}
-     */
-    readonly playfabId: string;
     /**
      * @remarks
      * This property can't be edited in restricted-execution mode.
@@ -18022,20 +16619,6 @@ export class Player extends Entity {
      * Throws if the Entity or Entity ID is invalid.
      */
     clearPropertyOverridesForEntity(targetEntity: Entity | string): void;
-    /**
-     * @beta
-     * @remarks
-     * Eats an item, providing the item's hunger and saturation
-     * effects to the player. Can only be used on food items.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param itemStack
-     * The item to eat.
-     * @throws
-     * Throws if the item is not a food item.
-     */
-    eatItem(itemStack: ItemStack): void;
     /**
      * @remarks
      * The player's aim-assist settings.
@@ -18069,22 +16652,6 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     getItemCooldown(cooldownCategory: string): number;
-    /**
-     * @beta
-     * @remarks
-     * Gets the player's ping in milliseconds.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @returns
-     * The player's ping in milliseconds.
-     * @throws This function can throw errors.
-     *
-     * {@link minecraftcommon.EngineError}
-     *
-     * {@link InvalidEntityError}
-     */
-    getPing(): number;
     /**
      * @remarks
      * Gets the current spawn point of the player.
@@ -18156,17 +16723,6 @@ export class Player extends Entity {
      * ```
      */
     playSound(soundId: string, soundOptions?: PlayerSoundOptions): SoundInstance;
-    /**
-     * @beta
-     * @remarks
-     * This is an internal-facing method for posting a system
-     * message to downstream clients.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @throws This function can throw errors.
-     */
-    postClientMessage(id: string, value: string): void;
     /**
      * @remarks
      * Queues an additional music track that only this particular
@@ -18442,18 +16998,6 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     startItemCooldown(cooldownCategory: string, tickDuration: number): void;
-    /**
-     * @beta
-     * @remarks
-     * Stops all sounds from playing for this particular player.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @throws This function can throw errors.
-     *
-     * {@link InvalidEntityError}
-     */
-    stopAllSounds(): void;
     /**
      * @remarks
      * Stops any music tracks from playing for this particular
@@ -18464,20 +17008,6 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     stopMusic(): void;
-    /**
-     * @beta
-     * @remarks
-     * Stops a sound from playing for this particular player.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param soundId
-     * Identifier of the sound.
-     * @throws This function can throw errors.
-     *
-     * {@link InvalidEntityError}
-     */
-    stopSound(soundId: string): void;
 }
 
 /**
@@ -18711,83 +17241,6 @@ export class PlayerButtonInputAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerButtonInputAfterEvent) => void): void;
 }
 
-/**
- * @beta
- * Contains information regarding an event after a player
- * cancels breaking a block.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PlayerCancelBreakingBlockAfterEvent extends BlockEvent {
-    private constructor();
-    /**
-     * @remarks
-     * The permutation of the block that the player cancelled
-     * breaking.
-     *
-     */
-    readonly blockPermutation: BlockPermutation;
-    /**
-     * @remarks
-     * The progress of breaking the block when the player cancelled
-     * in the exclusive range (0, 1).
-     *
-     */
-    readonly breakProgress: number;
-    /**
-     * @remarks
-     * The face of the block that was being broken.
-     *
-     */
-    readonly face: Direction;
-    /**
-     * @remarks
-     * The item stack that the player was using to break the block,
-     * or undefined if empty hand.
-     *
-     */
-    readonly heldItemStack?: ItemStack;
-    /**
-     * @remarks
-     * Player that cancelled breaking the block for this event.
-     *
-     */
-    readonly player: Player;
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to when a player
- * cancels breaking a block.
- */
-export class PlayerCancelBreakingBlockAfterEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called when a player cancels
-     * breaking a block.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    subscribe(
-        callback: (arg0: PlayerCancelBreakingBlockAfterEvent) => void,
-        options?: PlayerBreakingBlockEventOptions,
-    ): (arg0: PlayerCancelBreakingBlockAfterEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called when a player cancels
-     * breaking a block.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    unsubscribe(callback: (arg0: PlayerCancelBreakingBlockAfterEvent) => void): void;
-}
-
 /**
  * Represents the players cursor inventory. Used when moving
  * items between between containers in the inventory UI. Not
@@ -19839,88 +18292,6 @@ export class PlayerPlaceBlockAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerPlaceBlockAfterEvent) => void): void;
 }
 
-/**
- * @beta
- * Contains information regarding an event before a player
- * places a block.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PlayerPlaceBlockBeforeEvent extends BlockEvent {
-    private constructor();
-    /**
-     * @remarks
-     * If set to true, cancels the block place event.
-     *
-     */
-    cancel: boolean;
-    /**
-     * @remarks
-     * The face of the block that the new block is being placed on.
-     *
-     */
-    readonly face: Direction;
-    /**
-     * @remarks
-     * Location relative to the bottom north-west corner of the
-     * block where the new block is being placed onto.
-     *
-     */
-    readonly faceLocation: Vector3;
-    /**
-     * @remarks
-     * The block permutation that will be placed if the event is
-     * not cancelled.
-     *
-     */
-    readonly permutationToPlace: BlockPermutation;
-    /**
-     * @remarks
-     * Player that is placing the block for this event.
-     *
-     */
-    readonly player: Player;
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to before a block is
- * placed by a player.
- */
-export class PlayerPlaceBlockBeforeEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called before a block is placed
-     * by a player.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     * @returns
-     * Closure that is called with restricted-execution privilege.
-     */
-    subscribe(
-        callback: (arg0: PlayerPlaceBlockBeforeEvent) => void,
-        options?: BlockEventOptions,
-    ): (arg0: PlayerPlaceBlockBeforeEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called before an block is
-     * placed by a player.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     */
-    unsubscribe(callback: (arg0: PlayerPlaceBlockBeforeEvent) => void): void;
-}
-
 /**
  * An event that contains more information about a player
  * spawning.
@@ -19975,76 +18346,6 @@ export class PlayerSpawnAfterEventSignal {
     unsubscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): void;
 }
 
-/**
- * @beta
- * 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;
-}
-
-/**
- * @beta
- * 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.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * 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.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * 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.
@@ -20060,127 +18361,53 @@ export class PlayerSwingStartAfterEvent {
     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).
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * 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).
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * 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.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    entityNamed: Entity;
-    /**
-     * @remarks
-     * The new name that the player has given to the entity.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    newName: string;
-    /**
-     * @remarks
-     * Handle to the player that used the name tag.
-     *
-     * This property can't be edited in restricted-execution mode.
+     * Source Player for this event.
      *
      */
-    player: Player;
+    readonly player: Player;
     /**
      * @remarks
-     * The previous name of the entity before the player used the
-     * name tag. This will be undefined if the entity was not
-     * previously named.
-     *
-     * This property can't be edited in restricted-execution mode.
+     * The source of the Player swing, see {@link
+     * EntitySwingSource}.
      *
      */
-    previousName?: string;
+    readonly swingSource: EntitySwingSource;
 }
 
 /**
- * @beta
- * Manages callbacks that are connected to when a player
- * successfully names an Entity with a named Name Tag item.
+ * Manages callbacks that are connected to when a player starts
+ * to swing their arm (e.g. attacking, using an item,
+ * interacting).
  */
-export class PlayerUseNameTagAfterEventSignal {
+export class PlayerSwingStartAfterEventSignal {
     private constructor();
     /**
      * @remarks
-     * Subscribes the specified callback to a player use name tag
-     * after event.
+     * Adds a callback that will be called when a player starts to
+     * swing their arm (e.g. attacking, using an item,
+     * interacting).
      *
      * This function can't be called in restricted-execution mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): (arg0: PlayerUseNameTagAfterEvent) => void;
+    subscribe(
+        callback: (arg0: PlayerSwingStartAfterEvent) => void,
+        options?: PlayerSwingEventOptions,
+    ): (arg0: PlayerSwingStartAfterEvent) => void;
     /**
      * @remarks
-     * Removes the specified callback from a player use name tag
-     * after event.
+     * Removes a callback from being called when a player starts to
+     * swing their arm (e.g. attacking, using an item,
+     * interacting).
      *
      * This function can't be called in restricted-execution mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): void;
+    unsubscribe(callback: (arg0: PlayerSwingStartAfterEvent) => void): void;
 }
 
 /**
@@ -20299,10 +18526,10 @@ export class Potions {
      *
      * {@link InvalidPotionEffectTypeError}
      */
-    static resolve<
-        T extends string = minecraftvanilladata.MinecraftPotionEffectTypes,
-        U extends string = minecraftvanilladata.MinecraftPotionDeliveryTypes,
-    >(potionEffectType: PotionEffectType | T, potionDeliveryType: PotionDeliveryType | U): ItemStack;
+    static resolve(
+        potionEffectType: PotionEffectType | string,
+        potionDeliveryType: PotionDeliveryType | string,
+    ): ItemStack;
 }
 
 /**
@@ -21511,38 +19738,6 @@ export class Seat {
     readonly seatRotation: number;
 }
 
-/**
- * @beta
- * Manages callbacks that are message passing to a server. This
- * event is not currently fully implemented, and should not be
- * used.
- */
-export class ServerMessageAfterEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called when an internal message
-     * is passed.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    subscribe(callback: (arg0: MessageReceiveAfterEvent) => void): (arg0: MessageReceiveAfterEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called when an internal
-     * message is passed.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     */
-    unsubscribe(callback: (arg0: MessageReceiveAfterEvent) => void): void;
-}
-
 /**
  * Loot item function that modifies the trim on a dropped armor
  * item.
@@ -21571,21 +19766,6 @@ 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.
@@ -21831,14 +20011,20 @@ export class SmeltItemFunction extends LootItemFunction {
 }
 
 /**
- * @beta
- * Represents a handle to a sound that has been played.
+ * Represents a handle to a sound that has been played. The
+ * handle is required to control the sound while it is playing
+ * (for example, to call `stop`, `setVolume`, `setPitch`,
+ * `fade`, or `seekTo`). Infinitely-looping sounds (started
+ * with `loop: -1`) stop automatically when the last
+ * `SoundInstance` reference is dropped; retain the handle for
+ * as long as the sound should keep playing.
  */
 export class SoundInstance {
     private constructor();
     /**
+     * @rc
      * @remarks
-     * Stops this sound from playing.
+     * Stops this sound instance from playing.
      *
      * This function can't be called in restricted-execution mode.
      *
@@ -22561,19 +20747,6 @@ export class SystemBeforeEvents {
      *
      */
     readonly startup: StartupBeforeEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * Fires when the scripting watchdog shuts down the server. The
-     * can be due to using too much memory, or by causing
-     * significant slowdown or hang.
-     * To prevent shutdown, set the event's cancel property to
-     * true.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly watchdogTerminate: WatchdogTerminateBeforeEventSignal;
 }
 
 /**
@@ -22960,71 +21133,6 @@ export class TripWireTripAfterEventSignal {
     unsubscribe(callback: (arg0: TripWireTripAfterEvent) => void): void;
 }
 
-/**
- * @beta
- * Contains information related to a script watchdog
- * termination.
- */
-export class WatchdogTerminateBeforeEvent {
-    private constructor();
-    /**
-     * @remarks
-     * If set to true, cancels the termination of the script
-     * runtime. Note that depending on server configuration
-     * settings, cancellation of the termination may not be
-     * allowed.
-     *
-     */
-    cancel: boolean;
-    /**
-     * @remarks
-     * Contains the reason why a script runtime is to be
-     * terminated.
-     *
-     */
-    readonly terminateReason: WatchdogTerminateReason;
-}
-
-/**
- * @beta
- * Manages callbacks that are connected to a callback that will
- * be called when a script runtime is being terminated due to a
- * violation of the performance watchdog system.
- */
-export class WatchdogTerminateBeforeEventSignal {
-    private constructor();
-    /**
-     * @remarks
-     * Adds a callback that will be called when a script runtime is
-     * being terminated due to a violation of the performance
-     * watchdog system.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     * @returns
-     * Closure that is called with restricted-execution privilege.
-     */
-    subscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): (arg0: WatchdogTerminateBeforeEvent) => void;
-    /**
-     * @remarks
-     * Removes a callback from being called when a script runtime
-     * is being terminated due to a violation of the performance
-     * watchdog system.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * This function can be called in early-execution mode.
-     *
-     * @param callback
-     * This closure is called with restricted-execution privilege.
-     */
-    unsubscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): void;
-}
-
 /**
  * @rc
  * Base class for waypoints displayed on the player's locator
@@ -23241,15 +21349,6 @@ export class World {
      *
      */
     readonly afterEvents: WorldAfterEvents;
-    /**
-     * @beta
-     * @remarks
-     * Enables or disables cheats.
-     *
-     * This property can't be edited in restricted-execution mode.
-     *
-     */
-    allowCheats: boolean;
     /**
      * @remarks
      * Contains a set of events that are applicable to the entirety
@@ -23328,20 +21427,6 @@ export class World {
      *
      */
     readonly tickingAreaManager: TickingAreaManager;
-    /**
-     * @beta
-     * @remarks
-     * A method that is internal-only, used for broadcasting
-     * specific messages between client and server.
-     *
-     * This function can't be called in restricted-execution mode.
-     *
-     * @param id
-     * The message identifier.
-     * @param value
-     * The message.
-     */
-    broadcastClientMessage(id: string, value: string): void;
     /**
      * @remarks
      * Clears the set of dynamic properties declared for this
@@ -23834,16 +21919,6 @@ export class WorldAfterEvents {
      *
      */
     readonly buttonPush: ButtonPushAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event is triggered after a chat message has been
-     * broadcast or sent to players.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly chatSend: ChatSendAfterEventSignal;
     /**
      * @remarks
      * This event is fired when an entity event has been triggered
@@ -23970,15 +22045,6 @@ export class WorldAfterEvents {
      *
      */
     readonly entitySpawn: EntitySpawnAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event fires when an entity starts sneaking.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly entityStartSneaking: EntityStartSneakingAfterEventSignal;
     /**
      * @rc
      * @remarks
@@ -24075,25 +22141,6 @@ export class WorldAfterEvents {
      *
      */
     readonly leverAction: LeverActionAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event is an internal implementation detail, and is
-     * otherwise not currently functional.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly messageReceive: ServerMessageAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event is triggered when a pack setting is changed.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly packSettingChange: PackSettingChangeAfterEventSignal;
     /**
      * @remarks
      * This event fires when a piston expands or retracts.
@@ -24119,15 +22166,6 @@ export class WorldAfterEvents {
      *
      */
     readonly playerButtonInput: PlayerButtonInputAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event fires when a player cancels breaking a block.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly playerCancelBreakingBlock: PlayerCancelBreakingBlockAfterEventSignal;
     /**
      * @remarks
      * Fires when a player moved to a different dimension.
@@ -24233,31 +22271,12 @@ export class WorldAfterEvents {
      *
      */
     readonly playerSpawn: PlayerSpawnAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event fires when a player starts breaking a block.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly playerStartBreakingBlock: PlayerStartBreakingBlockAfterEventSignal;
     /**
      * @remarks
      * This property can be read in early-execution mode.
      *
      */
     readonly playerSwingStart: PlayerSwingStartAfterEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * An event for when a player uses a named name tag on an
-     * entity.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly playerUseNameTag: PlayerUseNameTagAfterEventSignal;
     /**
      * @remarks
      * A pressure plate has popped back up (i.e., there are no
@@ -24334,43 +22353,6 @@ export class WorldAfterEvents {
  */
 export class WorldBeforeEvents {
     private constructor();
-    /**
-     * @beta
-     * @remarks
-     * This event is triggered after a chat message has been
-     * broadcast or sent to players.
-     *
-     * This property can be read in early-execution mode.
-     *
-     * @example customCommand.ts
-     * ```typescript
-     * import { world, DimensionLocation } from '@minecraft/server';
-     *
-     * function customCommand(targetLocation: DimensionLocation) {
-     *   const chatCallback = world.beforeEvents.chatSend.subscribe(eventData => {
-     *     if (eventData.message.includes('cancel')) {
-     *       // Cancel event if the message contains "cancel"
-     *       eventData.cancel = true;
-     *     } else {
-     *       const args = eventData.message.split(' ');
-     *
-     *       if (args.length > 0) {
-     *         switch (args[0].toLowerCase()) {
-     *           case 'echo':
-     *             // Send a modified version of chat message
-     *             world.sendMessage(`Echo '${eventData.message.substring(4).trim()}'`);
-     *             break;
-     *           case 'help':
-     *             world.sendMessage(`Available commands: echo <message>`);
-     *             break;
-     *         }
-     *       }
-     *     }
-     *   });
-     * }
-     * ```
-     */
-    readonly chatSend: ChatSendBeforeEventSignal;
     /**
      * @remarks
      * This event is triggered after an event has been added to an
@@ -24464,15 +22446,6 @@ export class WorldBeforeEvents {
      *
      */
     readonly playerLeave: PlayerLeaveBeforeEventSignal;
-    /**
-     * @beta
-     * @remarks
-     * This event fires before a block is placed by a player.
-     *
-     * This property can be read in early-execution mode.
-     *
-     */
-    readonly playerPlaceBlock: PlayerPlaceBlockBeforeEventSignal;
     /**
      * @remarks
      * This property can be read in early-execution mode.
@@ -24550,27 +22523,13 @@ export interface BiomeFilter {
     includeTags?: string[];
 }
 
-/**
- * @beta
- * Contains additional options for searches for the
- * dimension.findNearestBiome API.
- */
-export interface BiomeSearchOptions {
-    /**
-     * @remarks
-     * Bounding volume size to look within.
-     *
-     */
-    boundingSize?: Vector3;
-}
-
 /**
  * A BlockBoundingBox is an interface to an object which
  * represents an AABB aligned rectangle.
  * The BlockBoundingBox assumes that it was created in a valid
  * state (min <= max) but cannot guarantee it (unless it was
- * created using the associated {@link BlockBoundingBoxUtils}
- * utility functions.
+ * created using the associated {@link
+ * @minecraft/server.BlockBoundingBoxUtils} utility functions.
  * The min/max coordinates represent the diametrically opposite
  * corners of the rectangle.
  * The BlockBoundingBox is not a representation of blocks - it
@@ -25021,40 +22980,6 @@ export interface CameraTargetOptions {
     targetEntity: Entity;
 }
 
-/**
- * @beta
- * This interface defines an entry into the {@link
- * CompoundBlockVolume} which represents a volume of positive
- * or negative space.
- *
- */
-export interface CompoundBlockVolumeItem {
-    /**
-     * @remarks
-     * The 'action' defines how the block volume is represented in
-     * the compound block volume stack.
-     * 'Add' creates a block volume which is positively selected
-     * 'Subtract' creates a block volume which represents a hole or
-     * negative space in the overall compound block volume.
-     *
-     */
-    action?: CompoundBlockVolumeAction;
-    /**
-     * @remarks
-     * The relativity enumeration determines whether the
-     * BlockVolume specified is positioned relative to the parent
-     * compound block volume origin, or in absolute world space.
-     *
-     */
-    locationRelativity?: CompoundBlockVolumePositionRelativity;
-    /**
-     * @remarks
-     * The volume of space
-     *
-     */
-    volume: BlockVolume;
-}
-
 /**
  * @rc
  * Represents the source of a container access.
@@ -25166,15 +23091,6 @@ 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.
@@ -25256,14 +23172,6 @@ export interface DefinitionModifier {
      *
      */
     removedComponentGroups: string[];
-    /**
-     * @beta
-     * @remarks
-     * The list of entity definition events that will be fired via
-     * this update.
-     *
-     */
-    triggers: Trigger[];
 }
 
 /**
@@ -26065,15 +23973,6 @@ export interface EntityRaycastOptions extends EntityFilter {
     maxDistance?: number;
 }
 
-/**
- * @beta
- * Options used to filter entity start sneaking and stop
- * sneaking events.
- */
-export interface EntitySneakingChangedEventOptions {
-    entityFilter?: EntityFilter;
-}
-
 /**
  * @rc
  * Controls when a waypoint is visible based on the state of
@@ -26580,33 +24479,6 @@ export interface PlayerAimAssistSettings {
     viewAngle?: Vector2;
 }
 
-/**
- * @beta
- * An interface that is passed into {@link
- * PlayerStartBreakingBlockAfterEventSignal.subscribe} or
- * {@link PlayerCancelBreakingBlockAfterEventSignal.subscribe}
- * that filters out which events are passed to the provided
- * callback.
- */
-export interface PlayerBreakingBlockEventOptions {
-    /**
-     * @remarks
-     * The {@link BlockFilter} that the callback should be called
-     * for. If undefined, the callback will be called for all
-     * blocks.
-     *
-     */
-    blockFilter?: BlockFilter;
-    /**
-     * @remarks
-     * The {@link EntityFilter} that the callback should be called
-     * for. If undefined, the callback will be called for all
-     * players.
-     *
-     */
-    playerFilter?: EntityFilter;
-}
-
 /**
  * Additional options for how a sound plays for a player.
  */
@@ -27632,17 +25504,6 @@ export class EnchantmentTypeUnknownIdError extends Error {
     private constructor();
 }
 
-/**
- * @beta
- * Error thrown by {@link EntityFogComponent} operations when
- * the fog stack limit is exceeded or an invalid fog identifier
- * is provided.
- */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class EntityFogComponentError extends Error {
-    private constructor();
-}
-
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntitySpawnError extends Error {
     private constructor();