@minecraft/server 2.3.0-rc.1.21.120-preview.21 → 2.4.0-beta.1.21.120-preview.21

package/index.d.ts

@@ -7,7 +7,7 @@
    Copyright (c) Microsoft Corporation.
    ***************************************************************************** */
 /**
- * @preview
+ * @beta
  * @packageDocumentation
  * Contains many types related to manipulating a Minecraft
  * world, including entities, blocks, dimensions, and more.
@@ -16,7 +16,7 @@
  * ```json
  * {
  *   "module_name": "@minecraft/server",
- *   "version": "2.3.0"
+ *   "version": "2.4.0-beta"
  * }
  * ```
  *
@@ -24,6 +24,25 @@
 import * as minecraftcommon from '@minecraft/common';
 // @ts-ignore Optional types-only package, will decay to any if @minecraft/vanilla-data isn't installed
 import type * as minecraftvanilladata from '@minecraft/vanilla-data';
+/**
+ * @beta
+ * Specifies different targeting modes for use in aim-assist.
+ */
+export enum AimAssistTargetMode {
+    /**
+     * @remarks
+     * Angle based targeting.
+     *
+     */
+    Angle = 'Angle',
+    /**
+     * @remarks
+     * Distance based targeting.
+     *
+     */
+    Distance = 'Distance',
+}
+
 /**
  * The types of block components that are accessible via
  * function Block.getComponent.
@@ -187,6 +206,113 @@ 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,
+}
+
+/**
+ * @beta
+ * Reasons that the {@link
+ * @minecraft/server.ContainerRulesError} was thrown.
+ */
+export enum ContainerRulesErrorReason {
+    /**
+     * @remarks
+     * Thrown when trying to add item that was defined in {@link
+     * ContainerRules.bannedItems}.
+     *
+     */
+    BannedItem = 'BannedItem',
+    /**
+     * @remarks
+     * Thrown when trying to add item with `Storage Item` component
+     * to container with {@link
+     * ContainerRules.allowNestedStorageItems} set to false.
+     *
+     */
+    NestedStorageItem = 'NestedStorageItem',
+    /**
+     * @remarks
+     * Thrown when trying to add item not defined in non-empty
+     * {@link ContainerRules.allowedItems}.
+     *
+     */
+    NotAllowedItem = 'NotAllowedItem',
+    /**
+     * @remarks
+     * Thrown when trying to add item that pushed the containers
+     * weight over the {@link ContainerRules.weightLimit}.
+     *
+     */
+    OverWeightLimit = 'OverWeightLimit',
+    /**
+     * @remarks
+     * Thrown when trying to add item with zero weight defined by
+     * the `Storage Weight Modifier` component to container with a
+     * defined {@link ContainerRules.weightLimit}
+     *
+     */
+    ZeroWeightItem = 'ZeroWeightItem',
+}
+
+/**
+ * @beta
+ * Control Scheme types which define how the player moves in
+ * response to player inputs.
+ */
+export enum ControlScheme {
+    CameraRelative = 'CameraRelative',
+    CameraRelativeStrafe = 'CameraRelativeStrafe',
+    LockedPlayerRelativeStrafe = 'LockedPlayerRelativeStrafe',
+    PlayerRelative = 'PlayerRelative',
+    PlayerRelativeStrafe = 'PlayerRelativeStrafe',
+}
+
 /**
  * Reason why custom command registration failed.
  */
@@ -231,6 +357,13 @@ export enum CustomCommandErrorReason {
      *
      */
     RegistryReadOnly = 'RegistryReadOnly',
+    /**
+     * @beta
+     * @remarks
+     * Non enum type command parameters cannot use enumName.
+     *
+     */
+    UnexpectedEnumName = 'UnexpectedEnumName',
 }
 
 /**
@@ -944,6 +1077,14 @@ export enum EntityComponentTypes {
      *
      */
     NavigationWalk = 'minecraft:navigation.walk',
+    /**
+     * @beta
+     * @remarks
+     * Adds NPC capabilities to an entity such as custom skin,
+     * name, and dialogue interactions.
+     *
+     */
+    Npc = 'minecraft:npc',
     /**
      * @remarks
      * When present on an entity, this entity is on fire.
@@ -1336,6 +1477,14 @@ export enum EntityInitializationCause {
  * 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
@@ -1578,6 +1727,10 @@ export enum GameRule {
      *
      */
     KeepInventory = 'keepInventory',
+    /**
+     * @beta
+     */
+    LocatorBar = 'locatorBar',
     /**
      * @remarks
      * The maximum number of chained commands that can execute per
@@ -1751,6 +1904,26 @@ export enum GraphicsMode {
     Simple = 'Simple',
 }
 
+/**
+ * @beta
+ * Specifies options related to the item currently being held
+ * by an entity.
+ */
+export enum HeldItemOption {
+    /**
+     * @remarks
+     * Any item is being held.
+     *
+     */
+    AnyItem = 'AnyItem',
+    /**
+     * @remarks
+     * No item is being held.
+     *
+     */
+    NoItem = 'NoItem',
+}
+
 export enum HudElement {
     PaperDoll = 0,
     Armor = 1,
@@ -1968,6 +2141,14 @@ export enum ItemComponentTypes {
      *
      */
     Food = 'minecraft:food',
+    /**
+     * @beta
+     */
+    Inventory = 'minecraft:inventory',
+    /**
+     * @beta
+     */
+    Potion = 'minecraft:potion',
 }
 
 /**
@@ -1995,6 +2176,28 @@ export enum ItemLockMode {
     slot = 'slot',
 }
 
+/**
+ * @beta
+ * Specifies how to handle waterloggable blocks overlapping
+ * with existing liquid.
+ */
+export enum LiquidSettings {
+    /**
+     * @remarks
+     * Causes a waterloggable block to become waterlogged, if it
+     * overlaps with existing liquid.
+     *
+     */
+    ApplyWaterlogging = 'ApplyWaterlogging',
+    /**
+     * @remarks
+     * Do not waterlog any waterloggable blocks that overlap
+     * existing liquid.
+     *
+     */
+    IgnoreWaterlogging = 'IgnoreWaterlogging',
+}
+
 /**
  * Represents the type of liquid that can be placed on a block
  * or flow dynamically in the world.
@@ -2618,6 +2821,29 @@ export enum TintMethod {
     Water = 'Water',
 }
 
+/**
+ * @beta
+ * An enumeration with the reason that a watchdog is deciding
+ * to terminate execution of a behavior packs' script.
+ */
+export enum WatchdogTerminateReason {
+    /**
+     * @remarks
+     * Script runtime for a behavior pack is terminated due to
+     * non-responsiveness from script (a hang or infinite loop).
+     *
+     */
+    Hang = 'Hang',
+    /**
+     * @remarks
+     * Script runtime for a behavior pack is terminated due to a
+     * stack overflow (a long, and potentially infinite) chain of
+     * function calls.
+     *
+     */
+    StackOverflow = 'StackOverflow',
+}
+
 /**
  * Used to specify the type of weather condition within the
  * world.
@@ -2657,10 +2883,12 @@ export type BlockComponentTypeMap = {
     'minecraft:movable': BlockMovableComponent;
     'minecraft:piston': BlockPistonComponent;
     'minecraft:record_player': BlockRecordPlayerComponent;
+    'minecraft:redstone_producer': BlockRedstoneProducerComponent;
     'minecraft:sign': BlockSignComponent;
     movable: BlockMovableComponent;
     piston: BlockPistonComponent;
     record_player: BlockRecordPlayerComponent;
+    redstone_producer: BlockRedstoneProducerComponent;
     sign: BlockSignComponent;
 };
 
@@ -2765,6 +2993,7 @@ export type EntityComponentTypeMap = {
     'minecraft:navigation.generic': EntityNavigationGenericComponent;
     'minecraft:navigation.hover': EntityNavigationHoverComponent;
     'minecraft:navigation.walk': EntityNavigationWalkComponent;
+    'minecraft:npc': EntityNpcComponent;
     'minecraft:onfire': EntityOnFireComponent;
     'minecraft:player.exhaustion': EntityExhaustionComponent;
     'minecraft:player.hunger': EntityHungerComponent;
@@ -2798,6 +3027,7 @@ export type EntityComponentTypeMap = {
     'navigation.generic': EntityNavigationGenericComponent;
     'navigation.hover': EntityNavigationHoverComponent;
     'navigation.walk': EntityNavigationWalkComponent;
+    npc: EntityNpcComponent;
     onfire: EntityOnFireComponent;
     'player.exhaustion': EntityExhaustionComponent;
     'player.hunger': EntityHungerComponent;
@@ -2817,6 +3047,15 @@ export type EntityComponentTypeMap = {
     wants_jockey: EntityWantsJockeyComponent;
 };
 
+/**
+ * @beta
+ */
+export type EntityIdentifierType<T> = [T] extends [never]
+    ? VanillaEntityIdentifier
+    : T extends string
+      ? VanillaEntityIdentifier | T
+      : never;
+
 export type ItemComponentReturnType<T extends string> = T extends keyof ItemComponentTypeMap
     ? ItemComponentTypeMap[T]
     : ItemCustomComponentInstance;
@@ -2829,6 +3068,7 @@ export type ItemComponentTypeMap = {
     dyeable: ItemDyeableComponent;
     enchantable: ItemEnchantableComponent;
     food: ItemFoodComponent;
+    inventory: ItemInventoryComponent;
     'minecraft:book': ItemBookComponent;
     'minecraft:compostable': ItemCompostableComponent;
     'minecraft:cooldown': ItemCooldownComponent;
@@ -2836,182 +3076,637 @@ export type ItemComponentTypeMap = {
     'minecraft:dyeable': ItemDyeableComponent;
     'minecraft:enchantable': ItemEnchantableComponent;
     'minecraft:food': ItemFoodComponent;
+    'minecraft:inventory': ItemInventoryComponent;
+    'minecraft:potion': ItemPotionComponent;
+    potion: ItemPotionComponent;
 };
 
 /**
- * @rc
- * Describes a type of biome.
+ * @beta
  */
-export class BiomeType {
-    private constructor();
-    /**
-     * @remarks
-     * Identifier of the biome type.
-     *
-     */
-    readonly id: string;
-}
+export type VanillaEntityIdentifier =
+    | EntityType
+    | minecraftvanilladata.MinecraftEntityTypes
+    | `${minecraftvanilladata.MinecraftEntityTypes}`
+    | `${minecraftvanilladata.MinecraftEntityTypes}<${string}>`;
 
 /**
- * Represents a block in a dimension. A block represents a
- * unique X, Y, and Z within a dimension and get/sets the state
- * of the block at that location. This type was significantly
- * updated in version 1.17.10.21.
+ * @beta
+ * Handle to an aim-assist category that exists in the
+ * world.aimAssist registry.
  */
-export class Block {
+export class AimAssistCategory {
     private constructor();
     /**
      * @remarks
-     * Returns the dimension that the block is within.
+     * Default targeting priority used for block types not found in
+     * getBlockPriorities.
      *
+     * @throws This property can throw when used.
      */
-    readonly dimension: Dimension;
+    readonly defaultBlockPriority: number;
     /**
      * @remarks
-     * Returns true if this block is an air block (i.e., empty
-     * space).
+     * Default targeting priority used for entity types not found
+     * in getEntityPriorities.
      *
      * @throws This property can throw when used.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly isAir: boolean;
+    readonly defaultEntityPriority: number;
     /**
      * @remarks
-     * Returns true if this block is a liquid block - (e.g., a
-     * water block and a lava block are liquid, while an air block
-     * and a stone block are not. Water logged blocks are not
-     * liquid blocks).
+     * The unique Id associated with the category.
      *
-     * @throws This property can throw when used.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly isLiquid: boolean;
+    readonly identifier: string;
     /**
      * @remarks
-     * Returns true if this reference to a block is still valid
-     * (for example, if the block is unloaded, references to that
-     * block will no longer be valid.)
+     * Gets the priority settings used for block targeting.
      *
+     * @returns
+     * The record mapping block Ids to their priority settings.
+     * Larger numbers have greater priority.
+     * @throws This function can throw errors.
      */
-    readonly isValid: boolean;
+    getBlockPriorities(): Record<string, number>;
     /**
      * @remarks
-     * Returns or sets whether this block has water on it.
+     * Gets the priority settings used for entity targeting.
      *
-     * @throws This property can throw when used.
+     * @returns
+     * The record mapping entity Ids to their priority settings.
+     * Larger numbers have greater priority.
+     * @throws This function can throw errors.
+     */
+    getEntityPriorities(): Record<string, number>;
+}
+
+/**
+ * @beta
+ * Settings used with AimAssistRegistry.addCategory for
+ * creation of the AimAssistCategory.
+ */
+export class AimAssistCategorySettings {
+    /**
+     * @remarks
+     * Optional. Default targeting priority used for block types
+     * not provided to setBlockPriorities.
      *
-     * {@link LocationInUnloadedChunkError}
+     * This property can't be edited in read-only mode.
      *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly isWaterlogged: boolean;
+    defaultBlockPriority: number;
     /**
      * @remarks
-     * Key for the localization of this block's name used in .lang
-     * files.
-     *
-     * @throws This property can throw when used.
+     * Optional. Default targeting priority used for entity types
+     * not provided to setEntityPriorities.
      *
-     * {@link LocationInUnloadedChunkError}
+     * This property can't be edited in read-only mode.
      *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    readonly localizationKey: string;
+    defaultEntityPriority: number;
     /**
      * @remarks
-     * Coordinates of the specified block.
+     * The unique Id used to register the category with. Must have
+     * a namespace.
      *
-     * @throws This property can throw when used.
      */
-    readonly location: Vector3;
+    readonly identifier: string;
     /**
      * @remarks
-     * Additional block configuration data that describes the
-     * block.
+     * Constructor that takes a unique Id to associate with the
+     * created AimAssistCategory. Must have a namespace.
      *
-     * @throws This property can throw when used.
-     *
-     * {@link LocationInUnloadedChunkError}
+     */
+    constructor(identifier: string);
+    /**
+     * @remarks
+     * Gets the priority settings used for block targeting.
      *
-     * {@link LocationOutOfWorldBoundariesError}
+     * @returns
+     * The record mapping block Ids to their priority settings.
+     * Larger numbers have greater priority.
      */
-    readonly permutation: BlockPermutation;
+    getBlockPriorities(): Record<string, number>;
     /**
      * @remarks
-     * Gets the type of block.
+     * Gets the priority settings used for entity targeting.
      *
-     * @throws This property can throw when used.
+     * @returns
+     * The record mapping entity Ids to their priority settings.
+     * Larger numbers have greater priority.
+     */
+    getEntityPriorities(): Record<string, number>;
+    /**
+     * @remarks
+     * Sets the priority settings used for block targeting.
      *
-     * {@link LocationInUnloadedChunkError}
+     * This function can't be called in read-only mode.
      *
-     * {@link LocationOutOfWorldBoundariesError}
+     * @param blockPriorities
+     * A record mapping block Ids to their priority settings.
+     * Larger numbers have greater priority.
      */
-    readonly 'type': BlockType;
+    setBlockPriorities(
+        blockPriorities: Record<keyof typeof minecraftvanilladata.MinecraftBlockTypes | string, number>,
+    ): void;
     /**
      * @remarks
-     * Identifier of the type of block for this block. Warning:
-     * Vanilla block names can be changed in future releases, try
-     * using 'Block.matches' instead for block comparison.
-     *
-     * @throws This property can throw when used.
+     * Sets the priority settings used for entity targeting.
      *
-     * {@link LocationInUnloadedChunkError}
+     * This function can't be called in read-only mode.
      *
-     * {@link LocationOutOfWorldBoundariesError}
+     * @param entityPriorities
+     * A record mapping entity Ids to their priority settings.
+     * Larger numbers have greater priority.
      */
-    readonly typeId: string;
+    setEntityPriorities(
+        entityPriorities: Record<keyof typeof minecraftvanilladata.MinecraftEntityTypes | string, number>,
+    ): void;
+}
+
+/**
+ * @beta
+ * Handle to an aim-assist preset that exists in the
+ * world.aimAssist registry.
+ */
+export class AimAssistPreset {
+    private constructor();
     /**
      * @remarks
-     * X coordinate of the block.
+     * Optional. Default aim-assist category Id used for items not
+     * provided to setItemSettings.
      *
+     * @throws This property can throw when used.
      */
-    readonly x: number;
+    readonly defaultItemSettings?: string;
     /**
      * @remarks
-     * Y coordinate of the block.
+     * Optional. Aim-assist category Id used for an empty hand.
      *
+     * @throws This property can throw when used.
      */
-    readonly y: number;
+    readonly handSettings?: string;
     /**
      * @remarks
-     * Z coordinate of the block.
+     * The unique Id associated with the preset.
      *
      */
-    readonly z: number;
+    readonly identifier: string;
     /**
      * @remarks
-     * Returns the {@link Block} above this block (positive in the
-     * Y direction).
+     * Gets the list of block/entity Ids to exclude from aim assist
+     * targeting.
      *
-     * @param steps
-     * Number of steps above to step before returning.
-     * Defaults to: 1
+     * @returns
+     * The array of block/entity Ids.
      * @throws This function can throw errors.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
      */
-    above(steps?: number): Block | undefined;
+    getExcludedTargets(): string[];
     /**
      * @remarks
-     * Returns the {@link Block} below this block (negative in the
-     * Y direction).
+     * Gets the per-item aim-assist category Ids.
      *
-     * @param steps
-     * Number of steps below to step before returning.
-     * Defaults to: 1
+     * @returns
+     * The record mapping item Ids to aim-assist category Ids.
      * @throws This function can throw errors.
-     *
-     * {@link LocationInUnloadedChunkError}
-     *
-     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getItemSettings(): Record<string, string>;
+    /**
+     * @remarks
+     * Gets the list of item Ids that will target liquid blocks
+     * with aim-assist when being held.
+     *
+     * @returns
+     * The array of item Ids.
+     * @throws This function can throw errors.
+     */
+    getLiquidTargetingItems(): string[];
+}
+
+/**
+ * @beta
+ * Settings used with AimAssistRegistry.addPreset for creation
+ * of the AimAssistPreset.
+ */
+export class AimAssistPresetSettings {
+    /**
+     * @remarks
+     * Optional. Default aim-assist category Id used for items not
+     * provided to setItemSettings.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    defaultItemSettings?: string;
+    /**
+     * @remarks
+     * Optional. Aim-assist category Id used for an empty hand.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    handSettings?: string;
+    /**
+     * @remarks
+     * The unique Id used to register the preset with. Must have a
+     * namespace.
+     *
+     */
+    readonly identifier: string;
+    /**
+     * @remarks
+     * Constructor that takes a unique Id to associate with the
+     * created AimAssistPreset. Must have a namespace.
+     *
+     */
+    constructor(identifier: string);
+    /**
+     * @remarks
+     * Gets the list of block/entity Ids to exclude from aim assist
+     * targeting.
+     *
+     * @returns
+     * The array of block/entity Ids.
+     */
+    getExcludedTargets(): string[] | undefined;
+    /**
+     * @remarks
+     * Gets the per-item aim-assist category Ids.
+     *
+     * @returns
+     * The record mapping item Ids to aim-assist category Ids.
+     */
+    getItemSettings(): Record<string, string>;
+    /**
+     * @remarks
+     * Gets the list of item Ids that will target liquid blocks
+     * with aim-assist when being held.
+     *
+     * @returns
+     * The array of item Ids.
+     */
+    getLiquidTargetingItems(): string[] | undefined;
+    /**
+     * @remarks
+     * Sets the list of block/entity Ids to exclude from aim assist
+     * targeting.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param targets
+     * An array of block/entity Ids.
+     */
+    setExcludedTargets(
+        targets?: (
+            | keyof typeof minecraftvanilladata.MinecraftBlockTypes
+            | keyof typeof minecraftvanilladata.MinecraftEntityTypes
+            | string
+        )[],
+    ): void;
+    /**
+     * @remarks
+     * Sets the per-item aim-assist category Ids.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param itemSettings
+     * 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;
+    /**
+     * @remarks
+     * Sets the list of item Ids that will target liquid blocks
+     * with aim-assist when being held.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param items
+     * An array of item Ids.
+     */
+    setLiquidTargetingItems(items?: (keyof typeof minecraftvanilladata.MinecraftItemTypes | string)[]): void;
+}
+
+/**
+ * @beta
+ * A container for APIs related to the world's aim-assist
+ * settings.
+ */
+export class AimAssistRegistry {
+    private constructor();
+    /**
+     * @remarks
+     * The default aim-assist category Id that is used when not
+     * otherwise specified.
+     *
+     */
+    static readonly DefaultCategoryId = 'minecraft:default';
+    /**
+     * @remarks
+     * The default aim-assist preset Id that is used when not
+     * otherwise specified.
+     *
+     */
+    static readonly DefaultPresetId = 'minecraft:aim_assist_default';
+    /**
+     * @remarks
+     * Adds an aim-assist category to the registry.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param category
+     * The category settings used to create the new category.
+     * @returns
+     * The created category handle.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link NamespaceNameError}
+     */
+    addCategory(category: AimAssistCategorySettings): AimAssistCategory;
+    /**
+     * @remarks
+     * Adds an aim-assist preset to the registry.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param preset
+     * The preset settings used to create the new preset.
+     * @returns
+     * The created preset handle.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link NamespaceNameError}
+     */
+    addPreset(preset: AimAssistPresetSettings): AimAssistPreset;
+    /**
+     * @remarks
+     * Gets all available categories in the registry.
+     *
+     * @returns
+     * An array of all available category objects.
+     */
+    getCategories(): AimAssistCategory[];
+    /**
+     * @remarks
+     * Gets the category associated with the provided Id.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * The category object if it exists, otherwise returns
+     * undefined.
+     */
+    getCategory(categoryId: string): AimAssistCategory | undefined;
+    /**
+     * @remarks
+     * Gets the preset associated with the provided Id.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param presetId
+     * The Id of the preset to retrieve. Must have a namespace.
+     * @returns
+     * The preset object if it exists, otherwise returns undefined.
+     */
+    getPreset(presetId: string): AimAssistPreset | undefined;
+    /**
+     * @remarks
+     * Gets all available presets in the registry.
+     *
+     * @returns
+     * An array of all available preset objects.
+     */
+    getPresets(): AimAssistPreset[];
+}
+
+/**
+ * @rc
+ * Describes a type of biome.
+ */
+export class BiomeType {
+    private constructor();
+    /**
+     * @remarks
+     * Identifier of the biome type.
+     *
+     */
+    readonly id: string;
+}
+
+/**
+ * @beta
+ * Supports a catalog of available biome types registered
+ * within Minecraft.
+ */
+export class BiomeTypes {
+    private constructor();
+    /**
+     * @remarks
+     * Returns a specific biome type.
+     *
+     * @param typeName
+     * Identifier of the biome.  Generally, namespaced identifiers
+     * (e.g., minecraft:frozen_peaks) should be used.
+     * @returns
+     * If the biome exists, a BiomeType object is returned. If not,
+     * undefined is returned.
+     */
+    static get(typeName: string): BiomeType | undefined;
+    /**
+     * @remarks
+     * Returns all registered biome types within Minecraft
+     *
+     */
+    static getAll(): BiomeType[];
+}
+
+/**
+ * Represents a block in a dimension. A block represents a
+ * unique X, Y, and Z within a dimension and get/sets the state
+ * of the block at that location. This type was significantly
+ * updated in version 1.17.10.21.
+ */
+export class Block {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the dimension that the block is within.
+     *
+     */
+    readonly dimension: Dimension;
+    /**
+     * @remarks
+     * Returns true if this block is an air block (i.e., empty
+     * space).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly isAir: boolean;
+    /**
+     * @remarks
+     * Returns true if this block is a liquid block - (e.g., a
+     * water block and a lava block are liquid, while an air block
+     * and a stone block are not. Water logged blocks are not
+     * liquid blocks).
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@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
+     * (for example, if the block is unloaded, references to that
+     * block will no longer be valid.)
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * @remarks
+     * Returns or sets whether this block has water on it.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly isWaterlogged: boolean;
+    /**
+     * @remarks
+     * Key for the localization of this block's name used in .lang
+     * files.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly localizationKey: string;
+    /**
+     * @remarks
+     * Coordinates of the specified block.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly location: Vector3;
+    /**
+     * @remarks
+     * Additional block configuration data that describes the
+     * block.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly permutation: BlockPermutation;
+    /**
+     * @remarks
+     * Gets the type of block.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly 'type': BlockType;
+    /**
+     * @remarks
+     * Identifier of the type of block for this block. Warning:
+     * Vanilla block names can be changed in future releases, try
+     * using 'Block.matches' instead for block comparison.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    readonly typeId: string;
+    /**
+     * @remarks
+     * X coordinate of the block.
+     *
+     */
+    readonly x: number;
+    /**
+     * @remarks
+     * Y coordinate of the block.
+     *
+     */
+    readonly y: number;
+    /**
+     * @remarks
+     * Z coordinate of the block.
+     *
+     */
+    readonly z: number;
+    /**
+     * @remarks
+     * Returns the {@link Block} above this block (positive in the
+     * Y direction).
+     *
+     * @param steps
+     * Number of steps above to step before returning.
+     * Defaults to: 1
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    above(steps?: number): Block | undefined;
+    /**
+     * @remarks
+     * Returns the {@link Block} below this block (negative in the
+     * Y direction).
+     *
+     * @param steps
+     * Number of steps below to step before returning.
+     * Defaults to: 1
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
      */
     below(steps?: number): Block | undefined;
     /**
@@ -3057,6 +3752,30 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     canContainLiquid(liquidType: LiquidType): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Checks to see whether it is valid to place the specified
+     * block type or block permutation, on a specified face on this
+     * block.
+     *
+     * @param blockToPlace
+     * Block type or block permutation to check placement for.
+     * @param faceToPlaceOn
+     * Optional specific face of this block to check placement
+     * against.
+     * @returns
+     * Returns `true` if the block type or permutation can be
+     * placed on this block, else `false`.
+     * @throws This function can throw errors.
+     *
+     * {@link Error}
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    canPlace(blockToPlace: BlockPermutation | BlockType | string, faceToPlaceOn?: Direction): boolean;
     /**
      * @remarks
      * Returns the {@link Vector3} of the center of this block on
@@ -3124,6 +3843,32 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     getItemStack(amount?: number, withData?: boolean): ItemStack | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the total brightness level of light shining on a
+     * certain block.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * The brightness level on the block.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     */
+    getLightLevel(): number;
+    /**
+     * @beta
+     * @throws This function can throw errors.
+     *
+     * {@link LocationInUnloadedChunkError}
+     *
+     * {@link LocationOutOfWorldBoundariesError}
+     */
+    getMapColor(): RGBA;
     /**
      * @remarks
      * Returns the net redstone power of this block.
@@ -3138,6 +3883,23 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     getRedstonePower(): number | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns the brightness level of light shining from the sky
+     * on a certain block.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * The brightness level on the block.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     */
+    getSkyLightLevel(): number;
     /**
      * @remarks
      * Returns a set of tags for a block.
@@ -3359,6 +4121,27 @@ export class Block {
      * {@link LocationOutOfWorldBoundariesError}
      */
     south(steps?: number): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Tries to set the block in the dimension to the state of the
+     * permutation by first checking if the placement is valid.
+     *
+     * This function can't be called in read-only 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
@@ -3376,6 +4159,137 @@ export class Block {
     west(steps?: number): Block | undefined;
 }
 
+/**
+ * @beta
+ * Bounding Box Utils is a utility class that provides a number
+ * of useful functions for the creation and utility of {@link
+ * BlockBoundingBox} objects
+ */
+export class BlockBoundingBoxUtils {
+    private constructor();
+    /**
+     * @remarks
+     * Create a validated instance of a {@link BlockBoundingBox}
+     * where the min and max components are guaranteed to be (min
+     * <= max)
+     *
+     * This function can't be called in read-only 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 read-only 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 read-only 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 read-only 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 read-only 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 read-only 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 read-only mode.
+     *
+     */
+    static getSpan(box: BlockBoundingBox): Vector3;
+    /**
+     * @remarks
+     * Check to see if two BlockBoundingBox objects intersect
+     *
+     * This function can't be called in read-only 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 read-only 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 read-only mode.
+     *
+     */
+    static isValid(box: BlockBoundingBox): boolean;
+    /**
+     * @remarks
+     * Move a BlockBoundingBox by a given amount
+     *
+     * This function can't be called in read-only 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.
  */
@@ -3797,10 +4711,22 @@ export class BlockLocationIterator implements Iterable<Vector3> {
     private constructor();
     /**
      * @remarks
-     * This function can't be called in read-only mode.
+     * This function can't be called in read-only mode.
+     *
+     */
+    [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}
      */
-    [Symbol.iterator](): Iterator<Vector3>;
+    isValid(): boolean;
     /**
      * @remarks
      * This function can't be called in read-only mode.
@@ -4204,6 +5130,45 @@ export class BlockRecordPlayerComponent extends BlockComponent {
     setRecord(recordItemType?: ItemType | string, startPlaying?: boolean): void;
 }
 
+/**
+ * @beta
+ * Represents a block that can output a redstone signal.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class BlockRedstoneProducerComponent extends BlockComponent {
+    private constructor();
+    /**
+     * @remarks
+     * Gets the power that this block outputs to circuit system.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    readonly power: number;
+    static readonly componentId = 'minecraft:redstone_producer';
+    /**
+     * @remarks
+     * Gets the faces of this block that can connect to the circuit
+     * and output power.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    getConnectedFaces(): Direction[];
+    /**
+     * @remarks
+     * Gets the block face that strongly powers the block touching
+     * it.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidBlockComponentError}
+     */
+    getStronglyPoweredFace(): Direction | undefined;
+}
+
 /**
  * Represents a block that can display text on it.
  * @example addSign.ts
@@ -4597,6 +5562,15 @@ export class BlockVolumeBase {
      *
      */
     getBlockLocationIterator(): BlockLocationIterator;
+    /**
+     * @beta
+     * @remarks
+     * Return a {@link BlockBoundingBox} object which represents
+     * the validated min and max coordinates of the volume
+     *
+     * @throws This function can throw errors.
+     */
+    getBoundingBox(): BlockBoundingBox;
     /**
      * @remarks
      * Return the capacity (volume) of the BlockVolume (W*D*H)
@@ -4808,6 +5782,23 @@ export class Camera {
             | CameraSetRotOptions
             | CameraTargetOptions,
     ): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the current active camera with easing.
+     *
+     * This function can't be called in read-only 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
@@ -4834,6 +5825,158 @@ export class Camera {
     setFov(fovCameraOptions?: CameraFovOptions): void;
 }
 
+/**
+ * @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 read-only 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 read-only 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 read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    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 read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: ChatSendBeforeEvent) => void): void;
+}
+
 /**
  * Contains the device information for a client instance.
  */
@@ -4842,53 +5985,305 @@ export class ClientSystemInfo extends SystemInfo {
     private constructor();
     /**
      * @remarks
-     * The max render distance for the device in chunks.
+     * The max render distance for the device in chunks.
+     *
+     */
+    readonly maxRenderDistance: number;
+    /**
+     * @remarks
+     * The platform type of the device.
+     *
+     */
+    readonly platformType: PlatformType;
+}
+
+/**
+ * Contains return data on the result of a command execution.
+ */
+export class CommandResult {
+    private constructor();
+    /**
+     * @remarks
+     * If the command operates against a number of entities,
+     * blocks, or items, this returns the number of successful
+     * applications of this command.
+     *
+     */
+    readonly successCount: number;
+}
+
+/**
+ * Base class for downstream Component implementations.
+ */
+export class Component {
+    private constructor();
+    /**
+     * @remarks
+     * Returns whether the component is valid. A component is
+     * considered valid if its owner is valid, in addition to any
+     * addition to any additional validation required by the
+     * component.
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * @remarks
+     * Identifier of the component.
+     *
+     */
+    readonly typeId: string;
+}
+
+/**
+ * @beta
+ * The Compound Block Volume is a collection of individual
+ * block volume definitions which, as a collection, define a
+ * larger volume of (sometimes non-contiguous) irregular
+ * shapes.
+ * This class is loosely based on the concept of CSG
+ * (Computational Solid Geometry) and allows a user to create
+ * complex volumes by building a stack of volumes and voids to
+ * make a larger single volume.
+ * For example - normally a creator would create a hollow cube
+ * by creating 6 "wall" surfaces for each face.
+ * With a Compound Block Volume, a creator can define a hollow
+ * cube by creating a single outer solid cube, and then
+ * defining a further single 'void' cube inside the larger one.
+ * Similarly, the Compound Block Volume can represent irregular
+ * shaped volumes (e.g. a tree consists of a trunk and lots of
+ * leaf cubes which are not necessarily contiguously placed).
+ * Each of the volumes added to the CompoundBlockVolume are (by
+ * default) relative to the origin set (either at construction
+ * or via one of the set functions).
+ * However, it is also possible to push volumes to the compound
+ * collection which are absolute in nature and are not affected
+ * by origin changes.
+ */
+export class CompoundBlockVolume {
+    /**
+     * @remarks
+     * Return the 'capacity' of the bounding rectangle which
+     * represents the collection of volumes in the stack
+     *
+     */
+    readonly capacity: number;
+    readonly items: CompoundBlockVolumeItem[];
+    readonly itemsAbsolute: CompoundBlockVolumeItem[];
+    /**
+     * @remarks
+     * Return the number of volumes (positive and negative) in the
+     * volume stack
+     *
+     */
+    readonly volumeCount: number;
+    /**
+     * @remarks
+     * Create a CompoundBlockVolume object
+     *
+     * @param origin
+     * An optional world space origin on which to center the
+     * compound volume.
+     * If not specified, the origin is set to (0,0,0)
+     */
+    constructor(origin?: Vector3);
+    /**
+     * @remarks
+     * Clear the contents of the volume stack
+     *
+     * This function can't be called in read-only 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 read-only 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 read-only 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 read-only 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 read-only mode.
+     *
+     */
+    getMin(): Vector3;
+    /**
+     * @remarks
+     * Fetch the origin in world space of the compound volume
+     *
+     * This function can't be called in read-only 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 read-only 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 read-only 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 read-only 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
      */
-    readonly maxRenderDistance: number;
+    peekLastVolume(forceRelativity?: CompoundBlockVolumePositionRelativity): CompoundBlockVolumeItem | undefined;
     /**
      * @remarks
-     * The platform type of the device.
+     * Remove the last entry from the volume stack.  This will
+     * reduce the stack size by one
+     *
+     * This function can't be called in read-only mode.
      *
      */
-    readonly platformType: PlatformType;
-}
-
-/**
- * Contains return data on the result of a command execution.
- */
-export class CommandResult {
-    private constructor();
+    popVolume(): boolean;
     /**
      * @remarks
-     * If the command operates against a number of entities,
-     * blocks, or items, this returns the number of successful
-     * applications of this command.
+     * 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 read-only mode.
+     *
+     * @param item
+     * Item to push to the end of the stack
      */
-    readonly successCount: number;
-}
-
-/**
- * Base class for downstream Component implementations.
- */
-export class Component {
-    private constructor();
+    pushVolume(item: CompoundBlockVolumeItem): void;
     /**
      * @remarks
-     * Returns whether the component is valid. A component is
-     * considered valid if its owner is valid, in addition to any
-     * addition to any additional validation required by the
-     * component.
+     * 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 read-only mode.
      *
+     * @param item
+     * Item to add or replace
      */
-    readonly isValid: boolean;
+    replaceOrAddLastVolume(item: CompoundBlockVolumeItem): boolean;
     /**
      * @remarks
-     * Identifier of the component.
+     * Set the origin of the compound volume to an absolute world
+     * space location
+     *
+     * This function can't be called in read-only 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.
      */
-    readonly typeId: string;
+    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 read-only mode.
+     *
+     * @param preserveExistingVolumes
+     * See the description for the arguments to {@link
+     * CompoundBlockVolume.setOrigin}
+     */
+    translateOrigin(delta: Vector3, preserveExistingVolumes?: boolean): void;
 }
 
 /**
@@ -4973,6 +6368,10 @@ export class Component {
  */
 export class Container {
     private constructor();
+    /**
+     * @beta
+     */
+    readonly containerRules?: ContainerRules;
     /**
      * @remarks
      * Count of the slots in the container that are empty.
@@ -5000,6 +6399,16 @@ export class Container {
      * Throws if the container is invalid.
      */
     readonly size: number;
+    /**
+     * @beta
+     * @remarks
+     * The combined weight of all items in the container.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidContainerError}
+     */
+    readonly weight: number;
     /**
      * @remarks
      * Adds an item to the container. The item is placed in the
@@ -5011,7 +6420,9 @@ export class Container {
      *
      * @param itemStack
      * The stack of items to add.
-     * @throws This function can throw errors.
+     * @throws
+     * Won't throw {@link ContainerRules} error for over weight
+     * limit but will instead add items up to the weight limit.
      *
      * {@link ContainerRulesError}
      *
@@ -5243,6 +6654,8 @@ export class Container {
      * @throws
      * Throws if either this container or `toContainer` are invalid
      * or if the `fromSlot` or `toSlot` indices out of bounds.
+     * Won't throw {@link ContainerRules} error for over weight
+     * limit but will instead add items up to the weight limit.
      *
      * {@link ContainerRulesError}
      *
@@ -5598,6 +7011,23 @@ export class ContainerSlot {
      * {@link InvalidContainerSlotError}
      */
     setCanPlaceOn(blockIdentifiers?: string[]): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets multiple dynamic properties with specific values.
+     *
+     * @param values
+     * A Record of key value pairs of the dynamic properties to
+     * set.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidContainerSlotError}
+     *
+     * {@link minecraftcommon.UnsupportedFunctionalityError}
+     */
+    setDynamicProperties(values: Record<string, boolean | number | string | Vector3>): void;
     /**
      * @remarks
      * Sets a specified property to a value.
@@ -5750,6 +7180,22 @@ export class CustomComponentParameters {
     readonly params: unknown;
 }
 
+/**
+ * @beta
+ * Loot item condition that checks whether the loot source was
+ * damaged by a specific type of entity.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class DamagedByEntityCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The entity type required for this condition to pass.
+     *
+     */
+    readonly entityType: string;
+}
+
 /**
  * Contains information related to firing of a data driven
  * entity event - for example, the minecraft:ageable_grow_up
@@ -5954,6 +7400,30 @@ export class Dimension {
         block: BlockPermutation | BlockType | string,
         options?: BlockFillOptions,
     ): ListBlockVolume;
+    /**
+     * @beta
+     * @remarks
+     * Finds the location of the closest biome of a particular
+     * type. Note that the findClosestBiome operation can take some
+     * time to complete, so avoid using many of these calls within
+     * a particular tick.
+     *
+     * @param pos
+     * Starting location to look for a biome to find.
+     * @param biomeToFind
+     * Identifier of the biome to look for.
+     * @param options
+     * Additional selection criteria for a biome search.
+     * @returns
+     * Returns a location of the biome, or undefined if a biome
+     * could not be found.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     */
+    findClosestBiome(pos: Vector3, biomeToFind: BiomeType | string, options?: BiomeSearchOptions): Vector3 | undefined;
     /**
      * @rc
      * @remarks
@@ -6174,6 +7644,43 @@ 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)[];
+    /**
+     * @beta
+     * @remarks
+     * Returns the total brightness level of light shining on a
+     * certain block position.
+     *
+     * @param location
+     * Location of the block we want to check the brightness of.
+     * @returns
+     * The brightness level on the block.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     */
+    getLightLevel(location: Vector3): number;
     /**
      * @remarks
      * Returns a set of players based on a set of conditions
@@ -6191,6 +7698,23 @@ export class Dimension {
      * {@link minecraftcommon.InvalidArgumentError}
      */
     getPlayers(options?: EntityQueryOptions): Player[];
+    /**
+     * @beta
+     * @remarks
+     * Returns the brightness level of light shining from the sky
+     * on a certain block position.
+     *
+     * @param location
+     * Position of the block we want to check the brightness of.
+     * @returns
+     * The brightness level on the block.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link LocationInUnloadedChunkError}
+     */
+    getSkyLightLevel(location: Vector3): number;
     /**
      * @remarks
      * Returns the highest block at the given XZ location.
@@ -6203,6 +7727,26 @@ 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;
+    /**
+     * @beta
+     * @remarks
+     * Returns true if the chunk at the given location is loaded
+     * (and valid for use with scripting).
+     *
+     * @param location
+     * Location to check if the chunk is loaded.
+     */
+    isChunkLoaded(location: Vector3): boolean;
     /**
      * @remarks
      * Places the given feature into the dimension at the specified
@@ -6436,7 +7980,11 @@ export class Dimension {
      * }
      * ```
      */
-    spawnEntity(identifier: EntityType | string, location: Vector3, options?: SpawnEntityOptions): Entity;
+    spawnEntity<T = never>(
+        identifier: EntityIdentifierType<NoInfer<T>>,
+        location: Vector3,
+        options?: SpawnEntityOptions,
+    ): Entity;
     /**
      * @remarks
      * Creates a new item stack as an entity at the specified
@@ -6531,6 +8079,26 @@ export class Dimension {
      * ```
      */
     spawnParticle(effectName: string, location: Vector3, molangVariables?: MolangVariableMap): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops all sounds from playing for all players.
+     *
+     * This function can't be called in read-only mode.
+     *
+     */
+    stopAllSounds(): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops a sound from playing for all players.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param soundId
+     * Identifier of the sound.
+     */
+    stopSound(soundId: string): void;
 }
 
 /**
@@ -6779,6 +8347,25 @@ export class EffectTypes {
     static getAll(): EffectType[];
 }
 
+/**
+ * @beta
+ * Represents a completely empty entry in a loot pool. If this
+ * entry is chosen, no items will drop.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EmptyLootItem extends LootPoolEntry {
+    private constructor();
+}
+
+/**
+ * @beta
+ */
+export class EnchantInfo {
+    private constructor();
+    readonly enchantment: string;
+    readonly range: minecraftcommon.NumberRange;
+}
+
 /**
  * Contains information on a type of enchantment.
  */
@@ -6978,6 +8565,18 @@ export class Entity {
      *
      */
     readonly scoreboardIdentity?: ScoreboardIdentity;
+    /**
+     * @beta
+     * @remarks
+     * Retrieves or sets an entity that is used as the target of
+     * AI-related behaviors, like attacking. If the entity
+     * currently has no target returns undefined.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidEntityError}
+     */
+    readonly target?: Entity;
     /**
      * @remarks
      * Identifier of the type of the entity - for example,
@@ -7287,6 +8886,23 @@ export class Entity {
      * ```
      */
     extinguishFire(useEffects?: boolean): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Gets the solid blocks that this entity is directly standing
+     * on. Ignores pressure plates.
+     *
+     * @param options
+     * Additional configuration options for what blocks are
+     * returned.
+     * @returns
+     * The solid blocks that this entity is directly standing on.
+     * Returns an empty list if the entity is jumping or flying.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    getAllBlocksStandingOn(options?: GetBlocksStandingOnOptions): Block[];
     /**
      * @remarks
      * Returns the first intersecting block from the direction that
@@ -7302,6 +8918,24 @@ export class Entity {
      * {@link InvalidEntityError}
      */
     getBlockFromViewDirection(options?: BlockRaycastOptions): BlockRaycastHit | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Gets a single solid block closest to the center of the
+     * entity that this entity is directly standing on. Ignores
+     * pressure plates.
+     *
+     * @param options
+     * Additional configuration options for what block is returned.
+     * @returns
+     * A single solid block closest to the center of the entity
+     * that this entity is directly standing on. Undefined if
+     * entity is flying or jumping.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    getBlockStandingOn(options?: GetBlocksStandingOnOptions): Block | undefined;
     /**
      * @remarks
      * Gets a component (that represents additional capabilities)
@@ -7735,6 +9369,21 @@ export class Entity {
      * {@link InvalidEntityError}
      */
     runCommand(commandString: string): CommandResult;
+    /**
+     * @beta
+     * @remarks
+     * Sets multiple dynamic properties with specific values.
+     *
+     * @param values
+     * A Record of key value pairs of the dynamic properties to
+     * set.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link InvalidEntityError}
+     */
+    setDynamicProperties(values: Record<string, boolean | number | string | Vector3>): void;
     /**
      * @remarks
      * Sets a specified property to a value.
@@ -8148,6 +9797,18 @@ export class EntityBaseMovementComponent extends EntityComponent {
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityBreathableComponent extends EntityComponent {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The current air supply of the entity.
+     *
+     * This property can't be edited in read-only 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.
@@ -8176,6 +9837,14 @@ export class EntityBreathableComponent extends EntityComponent {
      * @throws This property can throw when used.
      */
     readonly breathesWater: boolean;
+    /**
+     * @beta
+     * @remarks
+     * If true, the entity is able to breathe.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly canBreathe: boolean;
     /**
      * @remarks
      * If true, this entity will have visible bubbles while in
@@ -8536,6 +10205,40 @@ export class EntityFrictionModifierComponent extends EntityComponent {
     static readonly componentId = 'minecraft:friction_modifier';
 }
 
+/**
+ * @beta
+ * Loot item condition that checks the value of the mark
+ * variant of a mob as it drops its loot.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityHasMarkVariantCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The mark variant value the mob must have for this condition
+     * to pass.
+     *
+     */
+    readonly value: number;
+}
+
+/**
+ * @beta
+ * Loot item condition that checks the variant value of a mob
+ * as it drops its loot.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityHasVariantCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The variant value the mob must have for this condition to
+     * pass.
+     *
+     */
+    readonly value: number;
+}
+
 /**
  * Defines the interactions with this entity for healing it.
  */
@@ -9073,6 +10776,23 @@ export class EntityItemComponent extends EntityComponent {
     static readonly componentId = 'minecraft:item';
 }
 
+/**
+ * @beta
+ * Loot item condition that checks the entity type of the
+ * entity dropping its loot.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityKilledCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The entity type required for this condition to pass.
+     * Example: 'minecraft:skeleton'.
+     *
+     */
+    readonly entityType: string;
+}
+
 /**
  * Defines the base movement speed in lava of this entity.
  */
@@ -9569,13 +11289,49 @@ export class EntityNavigationHoverComponent extends EntityNavigationComponent {
 }
 
 /**
- * Allows this entity to generate paths by walking around and
- * jumping up and down a block like regular mobs.
+ * Allows this entity to generate paths by walking around and
+ * jumping up and down a block like regular mobs.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class EntityNavigationWalkComponent extends EntityNavigationComponent {
+    private constructor();
+    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 EntityNavigationWalkComponent extends EntityNavigationComponent {
+export class EntityNpcComponent extends EntityComponent {
     private constructor();
-    static readonly componentId = 'minecraft:navigation.walk';
+    /**
+     * @remarks
+     * The DialogueScene that is opened when players first interact
+     * with the NPC.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    defaultScene: string;
+    /**
+     * @remarks
+     * The name of the NPC as it is displayed to players.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    name: string;
+    /**
+     * @remarks
+     * The index of the skin the NPC will use.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    skinIndex: number;
+    static readonly componentId = 'minecraft:npc';
 }
 
 /**
@@ -10444,7 +12200,7 @@ export class EntityTypes {
      * Retrieves an entity type using a string-based identifier.
      *
      */
-    static get(identifier: string): EntityType | undefined;
+    static get<T = never>(identifier: EntityIdentifierType<NoInfer<T>>): EntityType | undefined;
     /**
      * @remarks
      * Retrieves a set of all entity types within this world.
@@ -10855,6 +12611,13 @@ export class GameRules {
      *
      */
     keepInventory: boolean;
+    /**
+     * @beta
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    locatorBar: boolean;
     /**
      * @remarks
      * This property can't be edited in read-only mode.
@@ -11013,6 +12776,16 @@ export class InputInfo {
     getMovementVector(): Vector2;
 }
 
+/**
+ * @beta
+ * Loot item condition that checks whether or not the entity
+ * dropping loot is a baby.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class IsBabyCondition extends LootItemCondition {
+    private constructor();
+}
+
 /**
  * @rc
  * When present on an item, this item is a book item. Can
@@ -11911,6 +13684,56 @@ export class ItemFoodComponent extends ItemComponent {
     static readonly componentId = 'minecraft:food';
 }
 
+/**
+ * @beta
+ * This component is added to items with the `Storage Item`
+ * component. Can access and modify this items inventory
+ * container.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class ItemInventoryComponent extends ItemComponent {
+    private constructor();
+    /**
+     * @throws This property can throw when used.
+     *
+     * {@link InvalidContainerError}
+     */
+    readonly container: Container;
+    static readonly componentId = 'minecraft:inventory';
+}
+
+/**
+ * @beta
+ * When present on an item, this item is a potion item.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class ItemPotionComponent extends ItemComponent {
+    private constructor();
+    /**
+     * @remarks
+     * The PotionDeliveryType associated with the potion item.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     */
+    readonly potionDeliveryType: PotionDeliveryType;
+    /**
+     * @remarks
+     * The PotionEffectType associated with the potion item.
+     *
+     * @throws This property can throw when used.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     */
+    readonly potionEffectType: PotionEffectType;
+    static readonly componentId = 'minecraft:potion';
+}
+
 /**
  * Contains information related to a chargeable item when the
  * player has finished using the item and released the build
@@ -12124,6 +13947,16 @@ export class ItemStack {
      *
      */
     readonly typeId: string;
+    /**
+     * @beta
+     * @remarks
+     * The total weight of all items in the stack plus the weight
+     * of all items in the items container which is defined with
+     * the `Storage Item` component. The weight per item can be
+     * modified by the `Storage Weight Modifier` component.
+     *
+     */
+    readonly weight: number;
     /**
      * @remarks
      * Creates a new instance of a stack of items for use in the
@@ -12408,6 +14241,21 @@ export class ItemStack {
      * ```
      */
     setCanPlaceOn(blockIdentifiers?: string[]): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets multiple dynamic properties with specific values.
+     *
+     * @param values
+     * A Record of key value pairs of the dynamic properties to
+     * set.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link minecraftcommon.UnsupportedFunctionalityError}
+     */
+    setDynamicProperties(values: Record<string, boolean | number | string | Vector3>): void;
     /**
      * @remarks
      * Sets a specified property to a value. Note: This function
@@ -12870,6 +14718,44 @@ export class ItemUseOnEvent {
     readonly itemStack: ItemStack;
 }
 
+/**
+ * @beta
+ * Loot item condition that checks whether or not the drop
+ * source was killed by a specific type of entity.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class KilledByEntityCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The entity type required for this condition to pass.
+     * Example: 'minecraft:skeleton'.
+     *
+     */
+    readonly entityType: string;
+}
+
+/**
+ * @beta
+ * Loot item condition that checks whether or not the source of
+ * the loot drop was killed by the player.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class KilledByPlayerCondition extends LootItemCondition {
+    private constructor();
+}
+
+/**
+ * @beta
+ * Loot item condition that checks whether or not the source of
+ * the loot drop was killed by the player or any of the
+ * player's pets.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class KilledByPlayerOrPetsCondition extends LootItemCondition {
+    private constructor();
+}
+
 /**
  * Contains information related to changes to a lever
  * activating or deactivating.
@@ -12907,118 +14793,289 @@ export class ItemUseOnEvent {
  * }
  * ```
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class LeverActionAfterEvent extends BlockEvent {
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LeverActionAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * True if the lever is activated (that is, transmitting
+     * power).
+     *
+     */
+    readonly isPowered: boolean;
+    /**
+     * @remarks
+     * Optional player that triggered the lever activation.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * Manages callbacks that are connected to lever moves
+ * (activates or deactivates).
+ * @example leverActionEvent.ts
+ * ```typescript
+ * import { world, system, BlockPermutation, LeverActionAfterEvent, DimensionLocation } from "@minecraft/server";
+ * import { MinecraftBlockTypes } from "@minecraft/vanilla-data";
+ *
+ * function leverActionEvent(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
+ *   // set up a lever
+ *   const cobblestone = targetLocation.dimension.getBlock(targetLocation);
+ *   const lever = targetLocation.dimension.getBlock({
+ *     x: targetLocation.x,
+ *     y: targetLocation.y + 1,
+ *     z: targetLocation.z,
+ *   });
+ *
+ *   if (cobblestone === undefined || lever === undefined) {
+ *     log("Could not find block at location.");
+ *     return -1;
+ *   }
+ *
+ *   cobblestone.setPermutation(BlockPermutation.resolve(MinecraftBlockTypes.Cobblestone));
+ *   lever.setPermutation(
+ *     BlockPermutation.resolve(MinecraftBlockTypes.Lever).withState("lever_direction", "up_north_south")
+ *   );
+ *
+ *   world.afterEvents.leverAction.subscribe((leverActionEvent: LeverActionAfterEvent) => {
+ *     const eventLoc = leverActionEvent.block.location;
+ *
+ *     if (eventLoc.x === targetLocation.x && eventLoc.y === targetLocation.y + 1 && eventLoc.z === targetLocation.z) {
+ *       log("Lever activate event at tick " + system.currentTick);
+ *     }
+ *   });
+ * }
+ * ```
+ */
+export class LeverActionAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a lever is moved
+     * (activates or deactivates).
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: LeverActionAfterEvent) => void): (arg0: LeverActionAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a lever is moved
+     * (activates or deactivates).
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: LeverActionAfterEvent) => void): void;
+}
+
+/**
+ * Volume composed of an unordered container of unique block
+ * locations.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class ListBlockVolume extends BlockVolumeBase {
+    /**
+     * @remarks
+     * Creates a new instance of ListBlockVolume.
+     *
+     * @param locations
+     * Initial array of block locations that ListBlockVolume will
+     * be constructed with.
+     */
+    constructor(locations: Vector3[]);
+    /**
+     * @remarks
+     * Insert block locations into container.
+     *
+     * @param locations
+     * Array of block locations to be inserted into container.
+     */
+    add(locations: Vector3[]): void;
+    /**
+     * @remarks
+     * Remove block locations from container.
+     *
+     * @param locations
+     * Array of block locations to be removed from container.
+     */
+    remove(locations: Vector3[]): void;
+}
+
+/**
+ * @beta
+ * Represents a loot pool entry containing an item to drop.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LootItem extends LootPoolEntry {
+    private constructor();
+    /**
+     * @remarks
+     * The name of the item contained in this entry.
+     *
+     */
+    readonly name?: ItemType;
+}
+
+/**
+ * @beta
+ * An abstract base class from which all loot item conditions
+ * are derived. A loot item condition is a set of rules or
+ * requirements which must be met for a loot drop to happen.
+ */
+export class LootItemCondition {
+    private constructor();
+}
+
+/**
+ * @beta
+ * A collection of entries which individually determine loot
+ * drops. Can contain values determining drop outcomes,
+ * including rolls, bonus rolls and tiers.
+ */
+export class LootPool {
+    private constructor();
+    /**
+     * @remarks
+     * Returns the number of extra times a loot pool will be rolled
+     * based on the player's luck level, represented as a range
+     * from minimum to maximum rolls.
+     *
+     */
+    readonly bonusRolls: minecraftcommon.NumberRange;
+    readonly conditions: LootItemCondition[];
+    /**
+     * @remarks
+     * Gets a complete list of all loot pool entries contained in
+     * the loot pool.
+     *
+     */
+    readonly entries: LootPoolEntry[];
+    /**
+     * @remarks
+     * Returns the number of times a loot pool will be rolled,
+     * represented as a range from minimum to maximum rolls.
+     *
+     */
+    readonly rolls: minecraftcommon.NumberRange;
+    /**
+     * @remarks
+     * Gets the loot pool tier values for a given table if they
+     * exist.
+     *
+     */
+    readonly tiers?: LootPoolTiers;
+}
+
+/**
+ * @beta
+ * Represents one entry within Loot Table, which describes one
+ * possible drop when a loot drop occurs. Can contain an item,
+ * another loot table, a path to another loot table, or an
+ * empty drop.
+ */
+export class LootPoolEntry {
     private constructor();
     /**
      * @remarks
-     * True if the lever is activated (that is, transmitting
-     * power).
+     * Gets the quality of a given loot pool entry.
      *
      */
-    readonly isPowered: boolean;
+    readonly quality: number;
     /**
      * @remarks
-     * Optional player that triggered the lever activation.
+     * Gets the subtable of a given loot pool entry.
      *
      */
-    readonly player: Player;
+    readonly subTable?: LootPoolEntry;
+    /**
+     * @remarks
+     * Gets the weight of a given loot pool entry.
+     *
+     */
+    readonly weight: number;
 }
 
 /**
- * Manages callbacks that are connected to lever moves
- * (activates or deactivates).
- * @example leverActionEvent.ts
- * ```typescript
- * import { world, system, BlockPermutation, LeverActionAfterEvent, DimensionLocation } from "@minecraft/server";
- * import { MinecraftBlockTypes } from "@minecraft/vanilla-data";
- *
- * function leverActionEvent(log: (message: string, status?: number) => void, targetLocation: DimensionLocation) {
- *   // set up a lever
- *   const cobblestone = targetLocation.dimension.getBlock(targetLocation);
- *   const lever = targetLocation.dimension.getBlock({
- *     x: targetLocation.x,
- *     y: targetLocation.y + 1,
- *     z: targetLocation.z,
- *   });
- *
- *   if (cobblestone === undefined || lever === undefined) {
- *     log("Could not find block at location.");
- *     return -1;
- *   }
- *
- *   cobblestone.setPermutation(BlockPermutation.resolve(MinecraftBlockTypes.Cobblestone));
- *   lever.setPermutation(
- *     BlockPermutation.resolve(MinecraftBlockTypes.Lever).withState("lever_direction", "up_north_south")
- *   );
- *
- *   world.afterEvents.leverAction.subscribe((leverActionEvent: LeverActionAfterEvent) => {
- *     const eventLoc = leverActionEvent.block.location;
- *
- *     if (eventLoc.x === targetLocation.x && eventLoc.y === targetLocation.y + 1 && eventLoc.z === targetLocation.z) {
- *       log("Lever activate event at tick " + system.currentTick);
- *     }
- *   });
- * }
- * ```
+ * @beta
+ * Represents the values which determine loot drops in a tiered
+ * loot pool. Potential drops from tiered loot pools are
+ * ordered, and chosen via logic controlled by the values in
+ * this object.
  */
-export class LeverActionAfterEventSignal {
+export class LootPoolTiers {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a lever is moved
-     * (activates or deactivates).
-     *
-     * This function can't be called in read-only mode.
-     *
-     * This function can be called in early-execution mode.
+     * The chance for each bonus roll attempt to upgrade the tier
+     * of the dropped item.
      *
      */
-    subscribe(callback: (arg0: LeverActionAfterEvent) => void): (arg0: LeverActionAfterEvent) => void;
+    readonly bonusChance: number;
     /**
      * @remarks
-     * Removes a callback from being called when a lever is moved
-     * (activates or deactivates).
+     * The number of attempts for the loot drop to upgrade its
+     * tier, thereby incrementing its position in the loot pool
+     * entry array, resulting in a higher tier drop.
      *
-     * This function can't be called in read-only mode.
-     *
-     * This function can be called in early-execution mode.
+     */
+    readonly bonusRolls: number;
+    /**
+     * @remarks
+     * Represents the upper bound for the starting point in
+     * determining which tier of loot to drop. The lower bound is
+     * always 1. For example, a value of 3 would result in the tier
+     * drop logic starting at a randomly selected position in the
+     * loot pool entry array between 1 and 3.
      *
      */
-    unsubscribe(callback: (arg0: LeverActionAfterEvent) => void): void;
+    readonly initialRange: number;
 }
 
 /**
- * Volume composed of an unordered container of unique block
- * locations.
+ * @beta
+ * Represents a single Loot Table, which determines what items
+ * are generated when killing a mob, breaking a block, filling
+ * a container, and more.
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class ListBlockVolume extends BlockVolumeBase {
+export class LootTable {
+    private constructor();
     /**
      * @remarks
-     * Creates a new instance of ListBlockVolume.
+     * Returns the path to the JSON file that represents this loot
+     * table. Does not include file extension, or 'loot_tables/'
+     * folder prefix. Example: `entities/creeper`.
      *
-     * @param locations
-     * Initial array of block locations that ListBlockVolume will
-     * be constructed with.
      */
-    constructor(locations: Vector3[]);
+    readonly path: string;
     /**
      * @remarks
-     * Insert block locations into container.
+     * Returns the array of loot pools on a given loot table.
      *
-     * @param locations
-     * Array of block locations to be inserted into container.
      */
-    add(locations: Vector3[]): void;
+    readonly pools: LootPool[];
+}
+
+/**
+ * @beta
+ * Represents a loot pool entry containing another separate,
+ * nested loot table.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LootTableEntry extends LootPoolEntry {
+    private constructor();
     /**
      * @remarks
-     * Remove block locations from container.
+     * Gets the loot table stored as a subtable in the parent loot
+     * pool.
      *
-     * @param locations
-     * Array of block locations to be removed from container.
      */
-    remove(locations: Vector3[]): void;
+    readonly lootTable: LootTable;
 }
 
 /**
@@ -13105,6 +15162,137 @@ export class LootTableManager {
      * Can be empty if no loot dropped.
      */
     generateLootFromEntityType(entityType: EntityType, tool?: ItemStack): ItemStack[] | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Generates loot from a given LootTable.
+     *
+     * @param tool
+     * Optional. The tool to use in the looting operation.
+     * @returns
+     * An array of item stacks dropped from the loot drop event.
+     * Can be empty if no loot dropped, or undefined if the
+     * provided tool is insufficient to mine the block.
+     */
+    generateLootFromTable(lootTable: LootTable, tool?: ItemStack): ItemStack[] | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Retrieves a single loot table from the level's current
+     * registry.
+     *
+     * @param path
+     * Path to the table to retrieve. Does not include file
+     * extension, or 'loot_tables/' folder prefix. Example:
+     * `entities/creeper`.
+     * @returns
+     * Returns a LootTable if one is found, or `undefined` if the
+     * provided path does not correspond to an existing loot table.
+     */
+    getLootTable(path: string): LootTable | undefined;
+}
+
+/**
+ * @beta
+ * Represents a loot pool entry containing a reference to
+ * another loot table, described by its path.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class LootTableReference extends LootPoolEntry {
+    private constructor();
+    /**
+     * @remarks
+     * The path to the referenced loot table. Example:
+     * `loot_tables/chests/village/village_bundle.json`
+     *
+     */
+    readonly path: string;
+}
+
+/**
+ * @beta
+ * Loot item condition that checks whether an appropriate tool
+ * was used to trigger the loot event. Can describe item type,
+ * count, durability, enchantments, or arrays of item tags to
+ * compare against.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class MatchToolCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The stack size, or count, required for this condition to
+     * pass.
+     *
+     */
+    readonly count: minecraftcommon.NumberRange;
+    /**
+     * @remarks
+     * The durability value required for this condition to pass.
+     *
+     */
+    readonly durability: minecraftcommon.NumberRange;
+    /**
+     * @remarks
+     * Array of enchantments required for this condition to pass.
+     *
+     */
+    readonly enchantments: EnchantInfo[];
+    /**
+     * @remarks
+     * The name of the tool item required for this condition to
+     * pass.
+     *
+     */
+    readonly itemName: string;
+    /**
+     * @remarks
+     * Array of item tags which ALL must be matched for this
+     * condition to pass.
+     *
+     */
+    readonly itemTagsAll: string[];
+    /**
+     * @remarks
+     * Array of item tags, from which at least 1 must be matched
+     * for this condition to pass.
+     *
+     */
+    readonly itemTagsAny: string[];
+    /**
+     * @remarks
+     * Array of item tags, from which exactly zero must match for
+     * this condition to pass.
+     *
+     */
+    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;
 }
 
 /**
@@ -13175,6 +15363,65 @@ export class MolangVariableMap {
     setVector3(variableName: string, vector: Vector3): void;
 }
 
+/**
+ * @beta
+ * Pack setting name and value that changed.
+ */
+export class PackSettingChangeAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The name of the setting.
+     *
+     */
+    readonly settingName: string;
+    /**
+     * @remarks
+     * The value of the setting.
+     *
+     */
+    readonly settingValue: boolean | number | string;
+}
+
+/**
+ * @beta
+ */
+export class PackSettingChangeAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * This function can't be called in read-only 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 read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PackSettingChangeAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Loot item condition that checks whether the looting entity
+ * is currently a passenger of a specific type of entity.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PassengerOfEntityCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The entity type required for this condition to pass.
+     *
+     */
+    readonly entityType: string;
+}
+
 /**
  * Contains information related to changes to a piston
  * expanding or retracting.
@@ -13473,6 +15720,37 @@ export class Player extends Entity {
      * Throws if the entity is invalid.
      */
     clearPropertyOverridesForEntity(targetEntity: Entity): 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 read-only mode.
+     *
+     * @param itemStack
+     * The item to eat.
+     * @throws
+     * Throws if the item is not a food item.
+     */
+    eatItem(itemStack: ItemStack): void;
+    /**
+     * @beta
+     * @remarks
+     * The player's aim-assist settings.
+     *
+     */
+    getAimAssist(): PlayerAimAssist;
+    /**
+     * @beta
+     * @remarks
+     * Returns the player's current control scheme.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    getControlScheme(): ControlScheme;
     /**
      * @remarks
      * Retrieves the active gamemode for this player, if specified.
@@ -13558,6 +15836,17 @@ export class Player extends Entity {
      * ```
      */
     playSound(soundId: string, soundOptions?: PlayerSoundOptions): void;
+    /**
+     * @beta
+     * @remarks
+     * This is an internal-facing method for posting a system
+     * message to downstream clients.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    postClientMessage(id: string, value: string): void;
     /**
      * @remarks
      * Queues an additional music track that only this particular
@@ -13689,11 +15978,38 @@ export class Player extends Entity {
      * ) {
      *   const players = world.getPlayers();
      *
-     *   players[0].sendMessage({ translate: "authentication.welcome", with: ["Amazing Player 1"] });
-     * }
-     * ```
+     *   players[0].sendMessage({ translate: "authentication.welcome", with: ["Amazing Player 1"] });
+     * }
+     * ```
+     */
+    sendMessage(message: (RawMessage | string)[] | RawMessage | string): void;
+    /**
+     * @beta
+     * @remarks
+     * Set a player's control scheme. The player's active camera
+     * preset must be set by scripts like with camera.setCamera()
+     * or commands.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param controlScheme
+     * Control scheme type. If this argument is undefined, this
+     * method will clear the player's control scheme back to the
+     * player camera's default control scheme.
+     * @returns
+     * Returns nothing if the control scheme was added or updated
+     * successfully. This can throw an InvalidArgumentError if the
+     * control scheme is not allowed by the player's current
+     * camera.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link InvalidEntityError}
      */
-    sendMessage(message: (RawMessage | string)[] | RawMessage | string): void;
+    setControlScheme(controlScheme?: string): void;
     /**
      * @remarks
      * Sets a gamemode override for this player.
@@ -13808,6 +16124,18 @@ export class Player extends Entity {
      * @throws This function can throw errors.
      */
     startItemCooldown(cooldownCategory: string, tickDuration: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops all sounds from playing for this particular player.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    stopAllSounds(): void;
     /**
      * @remarks
      * Stops any music tracks from playing for this particular
@@ -13818,6 +16146,59 @@ 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 read-only mode.
+     *
+     * @param soundId
+     * Identifier of the sound.
+     * @throws This function can throw errors.
+     *
+     * {@link InvalidEntityError}
+     */
+    stopSound(soundId: string): void;
+}
+
+/**
+ * @beta
+ * A container for APIs related to player aim-assist.
+ */
+export class PlayerAimAssist {
+    private constructor();
+    /**
+     * @remarks
+     * The player's currently active aim-assist settings, or
+     * undefined if not active.
+     *
+     */
+    readonly settings?: PlayerAimAssistSettings;
+    /**
+     * @remarks
+     * Sets the player's aim-assist settings.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param settings
+     * Aim-assist settings to activate for the player, if undefined
+     * aim-assist will be disabled.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link Error}
+     *
+     * {@link minecraftcommon.InvalidArgumentError}
+     *
+     * {@link InvalidEntityError}
+     *
+     * {@link NamespaceNameError}
+     */
+    set(settings?: PlayerAimAssistSettings): void;
 }
 
 /**
@@ -14877,215 +17258,515 @@ export class PlayerJoinAfterEventSignal {
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(callback: (arg0: PlayerJoinAfterEvent) => void): (arg0: PlayerJoinAfterEvent) => void;
+    subscribe(callback: (arg0: PlayerJoinAfterEvent) => void): (arg0: PlayerJoinAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player joins the
+     * world.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerJoinAfterEvent) => void): void;
+}
+
+/**
+ * Contains information regarding a player that has left the
+ * world.
+ */
+export class PlayerLeaveAfterEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Opaque string identifier of the player that has left the
+     * event.
+     *
+     */
+    readonly playerId: string;
+    /**
+     * @remarks
+     * Player that has left the world.
+     *
+     */
+    readonly playerName: string;
+}
+
+/**
+ * Manages callbacks that are connected to a player leaving the
+ * world.
+ */
+export class PlayerLeaveAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player leaves the
+     * world.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PlayerLeaveAfterEvent) => void): (arg0: PlayerLeaveAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a player leaves
+     * the world.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerLeaveAfterEvent) => void): void;
+}
+
+/**
+ * Contains information regarding a player that is leaving the
+ * world.
+ */
+export class PlayerLeaveBeforeEvent {
+    private constructor();
+    /**
+     * @remarks
+     * The leaving player.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * Manages callbacks that are connected to a player leaving the
+ * world.
+ */
+export class PlayerLeaveBeforeEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a player leaves the
+     * world.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: PlayerLeaveBeforeEvent) => void): (arg0: PlayerLeaveBeforeEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback that will be called when a player leaves
+     * the world.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: PlayerLeaveBeforeEvent) => void): void;
+}
+
+/**
+ * Contains information regarding an event where a player
+ * places a block.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class PlayerPlaceBlockAfterEvent extends BlockEvent {
+    private constructor();
+    /**
+     * @remarks
+     * Player that placed the block for this event.
+     *
+     */
+    readonly player: Player;
+}
+
+/**
+ * Manages callbacks that are connected to when a block is
+ * placed by a player.
+ */
+export class PlayerPlaceBlockAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a block is placed
+     * by a player.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: PlayerPlaceBlockAfterEvent) => void,
+        options?: BlockEventOptions,
+    ): (arg0: PlayerPlaceBlockAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when an block is placed
+     * by a player.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    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 read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(
+        callback: (arg0: PlayerPlaceBlockBeforeEvent) => void,
+        options?: BlockEventOptions,
+    ): (arg0: PlayerPlaceBlockBeforeEvent) => void;
     /**
      * @remarks
-     * Removes a callback from being called when a player joins the
-     * world.
+     * Removes a callback from being called before an block is
+     * placed by a player.
      *
      * This function can't be called in read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: PlayerJoinAfterEvent) => void): void;
+    unsubscribe(callback: (arg0: PlayerPlaceBlockBeforeEvent) => void): void;
 }
 
 /**
- * Contains information regarding a player that has left the
- * world.
+ * An event that contains more information about a player
+ * spawning.
  */
-export class PlayerLeaveAfterEvent {
+export class PlayerSpawnAfterEvent {
     private constructor();
     /**
      * @remarks
-     * Opaque string identifier of the player that has left the
-     * event.
+     * If true, this is the initial spawn of a player after joining
+     * the game.
+     *
+     * This property can't be edited in read-only mode.
      *
      */
-    readonly playerId: string;
+    initialSpawn: boolean;
     /**
      * @remarks
-     * Player that has left the world.
+     * Object that represents the player that joined the game.
+     *
+     * This property can't be edited in read-only mode.
      *
      */
-    readonly playerName: string;
+    player: Player;
 }
 
 /**
- * Manages callbacks that are connected to a player leaving the
- * world.
+ * Registers an event when a player is spawned (or re-spawned
+ * after death) and fully ready within the world.
  */
-export class PlayerLeaveAfterEventSignal {
+export class PlayerSpawnAfterEventSignal {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a player leaves the
-     * world.
+     * Registers a new event receiver for this particular type of
+     * event.
      *
      * This function can't be called in read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(callback: (arg0: PlayerLeaveAfterEvent) => void): (arg0: PlayerLeaveAfterEvent) => void;
+    subscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): (arg0: PlayerSpawnAfterEvent) => void;
     /**
      * @remarks
-     * Removes a callback from being called when a player leaves
-     * the world.
+     * De-registers an event receiver for the player spawn event.
      *
      * This function can't be called in read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: PlayerLeaveAfterEvent) => void): void;
+    unsubscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): void;
 }
 
 /**
- * Contains information regarding a player that is leaving the
- * world.
+ * @beta
+ * Contains information regarding a player starting to swing
+ * their arm.
  */
-export class PlayerLeaveBeforeEvent {
+export class PlayerSwingStartAfterEvent {
     private constructor();
     /**
      * @remarks
-     * The leaving player.
+     * The item stack being held by the player at the start of
+     * their swing.
+     *
+     */
+    readonly heldItemStack?: ItemStack;
+    /**
+     * @remarks
+     * Source Player for this event.
      *
      */
     readonly player: Player;
 }
 
 /**
- * Manages callbacks that are connected to a player leaving the
- * world.
+ * @beta
+ * Manages callbacks that are connected to when a player starts
+ * to swing their arm (e.g. attacking, using an item,
+ * interacting).
  */
-export class PlayerLeaveBeforeEventSignal {
+export class PlayerSwingStartAfterEventSignal {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a player leaves the
-     * world.
+     * 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 read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(callback: (arg0: PlayerLeaveBeforeEvent) => void): (arg0: PlayerLeaveBeforeEvent) => void;
+    subscribe(
+        callback: (arg0: PlayerSwingStartAfterEvent) => void,
+        options?: PlayerSwingEventOptions,
+    ): (arg0: PlayerSwingStartAfterEvent) => void;
     /**
      * @remarks
-     * Removes a callback that will be called when a player leaves
-     * the world.
+     * 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 read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: PlayerLeaveBeforeEvent) => void): void;
+    unsubscribe(callback: (arg0: PlayerSwingStartAfterEvent) => void): void;
 }
 
 /**
- * Contains information regarding an event where a player
- * places a block.
+ * @beta
+ * Contains information related to when a player successfully
+ * names an Entity with a named Name Tag item.
  */
-// @ts-ignore Class inheritance allowed for native defined classes
-export class PlayerPlaceBlockAfterEvent extends BlockEvent {
+export class PlayerUseNameTagAfterEvent {
     private constructor();
     /**
      * @remarks
-     * Player that placed the block for this event.
+     * The entity that was named by the player.
+     *
+     * This property can't be edited in read-only mode.
      *
      */
-    readonly player: Player;
+    entityNamed: Entity;
+    /**
+     * @remarks
+     * The new name that the player has given to the entity.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    newName: string;
+    /**
+     * @remarks
+     * Handle to the player that used the name tag.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    player: Player;
+    /**
+     * @remarks
+     * The previous name of the entity before the player used the
+     * name tag. This will be undefined if the entity was not
+     * previously named.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    previousName?: string;
 }
 
 /**
- * Manages callbacks that are connected to when a block is
- * placed by a player.
+ * @beta
+ * Manages callbacks that are connected to when a player
+ * successfully names an Entity with a named Name Tag item.
  */
-export class PlayerPlaceBlockAfterEventSignal {
+export class PlayerUseNameTagAfterEventSignal {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a block is placed
-     * by a player.
+     * Subscribes the specified callback to a player use name tag
+     * after event.
      *
      * This function can't be called in read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(
-        callback: (arg0: PlayerPlaceBlockAfterEvent) => void,
-        options?: BlockEventOptions,
-    ): (arg0: PlayerPlaceBlockAfterEvent) => void;
+    subscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): (arg0: PlayerUseNameTagAfterEvent) => void;
     /**
      * @remarks
-     * Removes a callback from being called when an block is placed
-     * by a player.
+     * Removes the specified callback from a player use name tag
+     * after event.
      *
      * This function can't be called in read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: PlayerPlaceBlockAfterEvent) => void): void;
+    unsubscribe(callback: (arg0: PlayerUseNameTagAfterEvent) => void): void;
 }
 
 /**
- * An event that contains more information about a player
- * spawning.
+ * @beta
+ * Represents how the potion effect is delivered.
  */
-export class PlayerSpawnAfterEvent {
+export class PotionDeliveryType {
+    private constructor();
+    readonly id: string;
+}
+
+/**
+ * @beta
+ * Represents a type of potion effect - like healing or
+ * leaping.
+ */
+export class PotionEffectType {
     private constructor();
     /**
      * @remarks
-     * If true, this is the initial spawn of a player after joining
-     * the game.
-     *
-     * This property can't be edited in read-only mode.
-     *
-     */
-    initialSpawn: boolean;
-    /**
-     * @remarks
-     * Object that represents the player that joined the game.
+     * Duration of the effect when applied to an entity in ticks.
+     * Undefined means the effect does not expire.
      *
-     * This property can't be edited in read-only mode.
+     * @throws This property can throw when used.
      *
+     * {@link minecraftcommon.EngineError}
      */
-    player: Player;
+    readonly durationTicks?: number;
+    readonly id: string;
 }
 
 /**
- * Registers an event when a player is spawned (or re-spawned
- * after death) and fully ready within the world.
+ * @beta
+ * Used for accessing all potion effect types, delivery types,
+ * and creating potions.
  */
-export class PlayerSpawnAfterEventSignal {
+export class Potions {
     private constructor();
     /**
      * @remarks
-     * Registers a new event receiver for this particular type of
-     * event.
+     * Retrieves handles for all registered potion delivery types.
      *
-     * This function can't be called in read-only mode.
+     * @returns
+     * Array of all registered delivery type handles.
+     */
+    static getAllDeliveryTypes(): PotionDeliveryType[];
+    /**
+     * @remarks
+     * Retrieves all type handle for all registered potion effects.
      *
-     * This function can be called in early-execution mode.
+     * @returns
+     * Array of all registered effect type handles.
+     */
+    static getAllEffectTypes(): PotionEffectType[];
+    /**
+     * @remarks
+     * Retrieves a type handle for a specified potion delivery id.
      *
+     * @returns
+     * A type handle wrapping the valid delivery id, or undefined
+     * for an invalid delivery id.
      */
-    subscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): (arg0: PlayerSpawnAfterEvent) => void;
+    static getDeliveryType(potionDeliveryId: string): PotionDeliveryType | undefined;
     /**
      * @remarks
-     * De-registers an event receiver for the player spawn event.
+     * Retrieves a type handle for a specified potion effect id.
      *
-     * This function can't be called in read-only mode.
+     * @param potionEffectId
+     * A valid potion effect id. See
+     * @minecraft/vanilla-data.MinecraftPotionEffectTypes
+     * @returns
+     * A type handle wrapping the valid effect id, or undefined for
+     * an invalid effect id.
+     */
+    static getEffectType(potionEffectId: string): PotionEffectType | undefined;
+    /**
+     * @remarks
+     * Creates a potion given an effect and delivery type.
      *
-     * This function can be called in early-execution mode.
+     * @throws This function can throw errors.
      *
+     * {@link minecraftcommon.EngineError}
+     *
+     * {@link InvalidPotionDeliveryTypeError}
+     *
+     * {@link InvalidPotionEffectTypeError}
      */
-    unsubscribe(callback: (arg0: PlayerSpawnAfterEvent) => void): void;
+    static resolve<
+        T extends string = minecraftvanilladata.MinecraftPotionEffectTypes,
+        U extends string = minecraftvanilladata.MinecraftPotionDeliveryTypes,
+    >(potionEffectType: PotionEffectType | T, potionDeliveryType: PotionDeliveryType | U): ItemStack;
 }
 
 /**
@@ -15354,6 +18035,82 @@ export class ProjectileHitEntityAfterEventSignal {
     unsubscribe(callback: (arg0: ProjectileHitEntityAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Loot item condition that applies a given value to the
+ * chances that loot will drop.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class RandomChanceCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The chance, from 0.0-1.0, that loot will drop.
+     *
+     */
+    readonly chance: number;
+}
+
+/**
+ * @beta
+ * Loot item condition that applies a given value to the
+ * chances that loot will drop, modified by the level of
+ * looting enchantment on the tool used.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class RandomChanceWithLootingCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The base chance, from 0.0-1.0, that loot will drop. Will be
+     * modified by the 'lootingMultiplier' value.
+     *
+     */
+    readonly chance: number;
+    /**
+     * @remarks
+     * The increase in drop chance per looting enchant level.
+     *
+     */
+    readonly lootingMultiplier: number;
+}
+
+/**
+ * @beta
+ * Loot item condition that applies given values to the chances
+ * that loot will drop based on the current difficulty level.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class RandomDifficultyChanceCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * A four-element array containing the chance of a loot drop
+     * occurring for each difficulty level, in order: Peaceful,
+     * Easy, Normal, Hard.
+     *
+     */
+    readonly chances: number[];
+}
+
+/**
+ * @beta
+ * Loot item condition that applies a given value to the
+ * chances that loot will drop, modified by the region the drop
+ * is happening within.
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class RandomRegionalDifficultyChanceCondition extends LootItemCondition {
+    private constructor();
+    /**
+     * @remarks
+     * The base chance, from 0.0-1.0, that loot will drop. Will be
+     * modified by the current region's multiplier.
+     *
+     */
+    readonly maxChance: number;
+}
+
 /**
  * Contains objectives and participants for the scoreboard.
  * @example updateScoreboard.ts
@@ -16038,6 +18795,38 @@ export class Seat {
     readonly seatRotation: number;
 }
 
+/**
+ * @beta
+ * Manages callbacks that are message passing to a server. This
+ * event is not currently fully implemented, and should not be
+ * used.
+ */
+export class ServerMessageAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when an internal message
+     * is passed.
+     *
+     * This function can't be called in read-only 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 read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: MessageReceiveAfterEvent) => void): void;
+}
+
 /**
  * Provides an adaptable interface for callers to subscribe to
  * an event that fires before the game world shuts down. This
@@ -16753,6 +19542,19 @@ export class SystemBeforeEvents {
      *
      */
     readonly startup: StartupBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * Fires when the scripting watchdog shuts down the server. The
+     * can be due to using too much memory, or by causing
+     * significant slowdown or hang.
+     * To prevent shutdown, set the event's cancel property to
+     * true.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly watchdogTerminate: WatchdogTerminateBeforeEventSignal;
 }
 
 /**
@@ -16943,30 +19745,89 @@ export class TripWireTripAfterEvent extends BlockEvent {
  * }
  * ```
  */
-export class TripWireTripAfterEventSignal {
+export class TripWireTripAfterEventSignal {
+    private constructor();
+    /**
+     * @remarks
+     * Adds a callback that will be called when a trip wire is
+     * tripped.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    subscribe(callback: (arg0: TripWireTripAfterEvent) => void): (arg0: TripWireTripAfterEvent) => void;
+    /**
+     * @remarks
+     * Removes a callback from being called when a trip wire is
+     * tripped.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    unsubscribe(callback: (arg0: TripWireTripAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Contains information related to a script watchdog
+ * termination.
+ */
+export class WatchdogTerminateBeforeEvent {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a trip wire is
-     * tripped.
+     * 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 read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    subscribe(callback: (arg0: TripWireTripAfterEvent) => void): (arg0: TripWireTripAfterEvent) => void;
+    subscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): (arg0: WatchdogTerminateBeforeEvent) => void;
     /**
      * @remarks
-     * Removes a callback from being called when a trip wire is
-     * tripped.
+     * 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 read-only mode.
      *
      * This function can be called in early-execution mode.
      *
      */
-    unsubscribe(callback: (arg0: TripWireTripAfterEvent) => void): void;
+    unsubscribe(callback: (arg0: WatchdogTerminateBeforeEvent) => void): void;
 }
 
 /**
@@ -17156,6 +20017,20 @@ export class World {
      *
      */
     readonly structureManager: StructureManager;
+    /**
+     * @beta
+     * @remarks
+     * A method that is internal-only, used for broadcasting
+     * specific messages between client and server.
+     *
+     * This function can't be called in read-only 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
@@ -17169,6 +20044,14 @@ export class World {
      *
      */
     getAbsoluteTime(): number;
+    /**
+     * @beta
+     * @remarks
+     * The aim-assist presets and categories that can be used in
+     * the world.
+     *
+     */
+    getAimAssist(): AimAssistRegistry;
     /**
      * @remarks
      * Returns an array of all active players within the world.
@@ -17346,6 +20229,15 @@ export class World {
      *
      */
     getMoonPhase(): MoonPhase;
+    /**
+     * @beta
+     * @remarks
+     * Returns a map of pack setting name and value pairs.
+     *
+     * This function can be called in early-execution mode.
+     *
+     */
+    getPackSettings(): Record<string, boolean | number | string>;
     /**
      * @remarks
      * Returns a set of players based on a set of conditions
@@ -17479,6 +20371,19 @@ export class World {
      * The difficulty we want to set the world to.
      */
     setDifficulty(difficulty: Difficulty): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets multiple dynamic properties with specific values.
+     *
+     * @param values
+     * A Record of key value pairs of the dynamic properties to
+     * set.
+     * @throws This function can throw errors.
+     *
+     * {@link minecraftcommon.ArgumentOutOfBoundsError}
+     */
+    setDynamicProperties(values: Record<string, boolean | number | string | Vector3>): void;
     /**
      * @remarks
      * Sets a specified property to a value.
@@ -17607,6 +20512,16 @@ export class WorldAfterEvents {
      *
      */
     readonly buttonPush: ButtonPushAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly chatSend: ChatSendAfterEventSignal;
     /**
      * @remarks
      * This event is fired when an entity event has been triggered
@@ -17782,6 +20697,25 @@ export class WorldAfterEvents {
      *
      */
     readonly leverAction: LeverActionAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is an internal implementation detail, and is
+     * otherwise not currently functional.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly messageReceive: ServerMessageAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered when a pack setting is changed.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly packSettingChange: PackSettingChangeAfterEventSignal;
     /**
      * @remarks
      * This event fires when a piston expands or retracts.
@@ -17912,6 +20846,23 @@ export class WorldAfterEvents {
      *
      */
     readonly playerSpawn: PlayerSpawnAfterEventSignal;
+    /**
+     * @beta
+     * @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
@@ -17988,6 +20939,43 @@ export class WorldAfterEvents {
  */
 export class WorldBeforeEvents {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     * This property can be read in early-execution mode.
+     *
+     * @example customCommand.ts
+     * ```typescript
+     * import { world, DimensionLocation } from "@minecraft/server";
+     *
+     * function customCommand(targetLocation: DimensionLocation) {
+     *   const chatCallback = world.beforeEvents.chatSend.subscribe((eventData) => {
+     *     if (eventData.message.includes("cancel")) {
+     *       // Cancel event if the message contains "cancel"
+     *       eventData.cancel = true;
+     *     } else {
+     *       const args = eventData.message.split(" ");
+     *
+     *       if (args.length > 0) {
+     *         switch (args[0].toLowerCase()) {
+     *           case "echo":
+     *             // Send a modified version of chat message
+     *             world.sendMessage(`Echo '${eventData.message.substring(4).trim()}'`);
+     *             break;
+     *           case "help":
+     *             world.sendMessage(`Available commands: echo <message>`);
+     *             break;
+     *         }
+     *       }
+     *     }
+     *   });
+     * }
+     * ```
+     */
+    readonly chatSend: ChatSendBeforeEventSignal;
     /**
      * @remarks
      * This event is triggered after an event has been added to an
@@ -18061,6 +21049,15 @@ export class WorldBeforeEvents {
      *
      */
     readonly playerLeave: PlayerLeaveBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event fires before a block is placed by a player.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    readonly playerPlaceBlock: PlayerPlaceBlockBeforeEventSignal;
     /**
      * @remarks
      * This property can be read in early-execution mode.
@@ -18093,13 +21090,27 @@ export class WorldLoadAfterEventSignal {
     unsubscribe(callback: (arg0: WorldLoadAfterEvent) => void): void;
 }
 
+/**
+ * @beta
+ * Contains additional options for searches for the
+ * dimension.findNearestBiome API.
+ */
+export interface BiomeSearchOptions {
+    /**
+     * @remarks
+     * Bounding volume size to look within.
+     *
+     */
+    boundingSize?: Vector3;
+}
+
 /**
  * A BlockBoundingBox is an interface to an object which
  * represents an AABB aligned rectangle.
  * The BlockBoundingBox assumes that it was created in a valid
  * state (min <= max) but cannot guarantee it (unless it was
- * created using the associated {@link
- * @minecraft/server.BlockBoundingBoxUtils} utility functions.
+ * created using the associated {@link BlockBoundingBoxUtils}
+ * utility functions.
  * The min/max coordinates represent the diametrically opposite
  * corners of the rectangle.
  * The BlockBoundingBox is not a representation of blocks - it
@@ -18478,6 +21489,76 @@ 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;
+}
+
+/**
+ * @beta
+ * Rules that if broken on container operations will throw an
+ * error.
+ */
+export interface ContainerRules {
+    /**
+     * @remarks
+     * Defines the items that are exclusively allowed in the
+     * container. If empty all items are allowed in the container.
+     *
+     */
+    allowedItems: string[];
+    /**
+     * @remarks
+     * Determines whether other storage items can be placed into
+     * the container.
+     *
+     */
+    allowNestedStorageItems: boolean;
+    /**
+     * @remarks
+     * Defines the items that are not allowed in the container.
+     *
+     */
+    bannedItems: string[];
+    /**
+     * @remarks
+     * Defines the maximum allowed total weight of all items in the
+     * storage item container. If undefined container has no weight
+     * limit.
+     *
+     */
+    weightLimit?: number;
+}
+
 /**
  * Define the custom command, including name, permissions, and
  * parameters.
@@ -18527,6 +21608,15 @@ export interface CustomCommand {
  * command.
  */
 export interface CustomCommandParameter {
+    /**
+     * @beta
+     * @remarks
+     * Can be used to reference the enum name when {@link
+     * CustomCommandParamType} is 'Enum'. Allows the parameter name
+     * to be different from the enum name.
+     *
+     */
+    enumName?: string;
     /**
      * @remarks
      * The name of parameter as it appears on the command line.
@@ -18579,6 +21669,14 @@ export interface DefinitionModifier {
      *
      */
     removedComponentGroups: string[];
+    /**
+     * @beta
+     * @remarks
+     * The list of entity definition events that will be fired via
+     * this update.
+     *
+     */
+    triggers: Trigger[];
 }
 
 /**
@@ -19318,6 +22416,29 @@ export interface ExplosionOptions {
     source?: Entity;
 }
 
+/**
+ * @beta
+ * Contains additional options for getBlockStandingOn and
+ * getAllBlocksStandingOn.
+ */
+export interface GetBlocksStandingOnOptions {
+    /**
+     * @remarks
+     * When specified, the function will include / exclude what
+     * block(s) are returned based on the block filter.
+     *
+     */
+    blockFilter?: BlockFilter;
+    /**
+     * @remarks
+     * If true, all blocks of height 0.2 or lower like trapdoors
+     * and carpets will be ignored, and the block underneath will
+     * be returned.
+     *
+     */
+    ignoreThinBlocks?: boolean;
+}
+
 /**
  * Greater than operator.
  */
@@ -19509,6 +22630,14 @@ export interface JigsawPlaceOptions {
      *
      */
     keepJigsaws?: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Specifies how to handle waterloggable blocks overlapping
+     * with existing liquid. Defaults to `ApplyWaterlogging`.
+     *
+     */
+    liquidSettings?: LiquidSettings;
 }
 
 /**
@@ -19538,6 +22667,14 @@ export interface JigsawStructurePlaceOptions {
      *
      */
     keepJigsaws?: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Specifies how to handle waterloggable blocks overlapping
+     * with existing liquid. Defaults to `ApplyWaterlogging`.
+     *
+     */
+    liquidSettings?: LiquidSettings;
 }
 
 /**
@@ -19639,6 +22776,38 @@ export interface PlayAnimationOptions {
     stopExpression?: string;
 }
 
+/**
+ * @beta
+ * Settings relating to a player's aim-assist targeting.
+ */
+export interface PlayerAimAssistSettings {
+    /**
+     * @remarks
+     * The view distance limit to use for aim-assist targeting.
+     *
+     */
+    distance?: number;
+    /**
+     * @remarks
+     * The Id of the aim-assist preset to activate. Must have a
+     * namespace.
+     *
+     */
+    presetId: string;
+    /**
+     * @remarks
+     * The mode to use for aim-assist targeting.
+     *
+     */
+    targetMode?: AimAssistTargetMode;
+    /**
+     * @remarks
+     * The view angle limit to use for aim-assist targeting.
+     *
+     */
+    viewAngle?: Vector2;
+}
+
 /**
  * Additional options for how a sound plays for a player.
  */
@@ -19664,6 +22833,24 @@ export interface PlayerSoundOptions {
     volume?: number;
 }
 
+/**
+ * @beta
+ * An interface that is passed into {@link
+ * @minecraft/Server.PlayerSwingStartAfterEvent.subscribe} that
+ * filters out which events are passed to the provided
+ * callback.
+ */
+export interface PlayerSwingEventOptions {
+    /**
+     * @remarks
+     * The held item option that the callback should be called for.
+     * If undefined, the callback will be called whether or not the
+     * player is holding an item in their hand.
+     *
+     */
+    heldItemOption?: HeldItemOption;
+}
+
 /**
  * Optional arguments for
  * @minecraft/server.EntityProjectileComponent.shoot.
@@ -19941,6 +23128,23 @@ export interface ScriptEventMessageFilterOptions {
  * Contains additional options for spawning an Entity.
  */
 export interface SpawnEntityOptions {
+    /**
+     * @beta
+     * @remarks
+     * Optional boolean which determines if this entity should
+     * persist in the game world. Persistence prevents the entity
+     * from automatically despawning.
+     *
+     */
+    initialPersistence?: boolean;
+    /**
+     * @beta
+     * @remarks
+     * Optional initial rotation, in degrees, to set on the entity
+     * when it spawns.
+     *
+     */
+    initialRotation?: number;
     /**
      * @remarks
      * Optional spawn event to send to the entity after it is
@@ -20304,12 +23508,21 @@ export class CommandError extends Error {
 }
 
 /**
- * Error thrown if {@link @minecraft/server.ContainerRules} are
- * broken on container operations.
+ * Error thrown if {@link ContainerRules} are broken on
+ * container operations.
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class ContainerRulesError extends Error {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * The specific reason the error was thrown.
+     *
+     * This property can be read in early-execution mode.
+     *
+     */
+    reason: ContainerRulesErrorReason;
 }
 
 /**
@@ -20364,6 +23577,14 @@ export class EntitySpawnError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidBlockComponentError extends Error {
+    private constructor();
+}
+
 /**
  * The container is invalid. This can occur if the container is
  * missing or deleted.
@@ -20430,6 +23651,22 @@ export class InvalidIteratorError extends Error {
     private constructor();
 }
 
+/**
+ * @beta
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidPotionDeliveryTypeError extends Error {
+    private constructor();
+}
+
+/**
+ * @beta
+ */
+// @ts-ignore Class inheritance allowed for native defined classes
+export class InvalidPotionEffectTypeError extends Error {
+    private constructor();
+}
+
 /**
  * Thrown when a Structure is invalid. A structure becomes
  * invalid when it is deleted.