@minecraft/server 1.2.0-rc.1.20.0-preview.21 → 1.2.0-rc.1.20.0-preview.23

package/index.d.ts

@@ -16,11 +16,48 @@
  * ```json
  * {
  *   "module_name": "@minecraft/server",
- *   "version": "1.3.0-internal.1.20.0-preview.21"
+ *   "version": "1.3.0-internal.1.20.0-preview.23"
  * }
  * ```
  *
  */
+/**
+ * @beta
+ */
+export enum EntityDamageCause {
+    anvil = 'anvil',
+    blockExplosion = 'blockExplosion',
+    charging = 'charging',
+    contact = 'contact',
+    drowning = 'drowning',
+    entityAttack = 'entityAttack',
+    entityExplosion = 'entityExplosion',
+    fall = 'fall',
+    fallingBlock = 'fallingBlock',
+    fire = 'fire',
+    fireTick = 'fireTick',
+    fireworks = 'fireworks',
+    flyIntoWall = 'flyIntoWall',
+    freezing = 'freezing',
+    lava = 'lava',
+    lightning = 'lightning',
+    magic = 'magic',
+    magma = 'magma',
+    none = 'none',
+    override = 'override',
+    piston = 'piston',
+    projectile = 'projectile',
+    stalactite = 'stalactite',
+    stalagmite = 'stalagmite',
+    starve = 'starve',
+    suffocation = 'suffocation',
+    suicide = 'suicide',
+    temperature = 'temperature',
+    thorns = 'thorns',
+    'void' = 'void',
+    wither = 'wither',
+}
+
 /**
  * @beta
  * Represents a game mode for the current world experience.
@@ -60,6 +97,16 @@ export enum GameMode {
      */
     survival = 'survival',
 }
+
+/**
+ * @beta
+ */
+export enum ItemLockMode {
+    inventory = 'inventory',
+    none = 'none',
+    slot = 'slot',
+}
+
 /**
  * @beta
  * Represents a block in a dimension. A block represents a
@@ -122,6 +169,30 @@ export class Block {
      */
     setPermutation(permutation: BlockPermutation): void;
 }
+
+/**
+ * @beta
+ * Represents the inventory of a block in the world. Used with
+ * blocks like chests.
+ */
+export class BlockInventoryComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * The container which holds an {@link ItemStack}.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly container: Container;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:inventory.
+     *
+     */
+    static readonly componentId = 'minecraft:inventory';
+}
+
 /**
  * @beta
  * Contains the combination of type {@link BlockType} and
@@ -153,6 +224,7 @@ export class BlockPermutation {
      */
     static resolve(blockName: string, states?: Record<string, boolean | number | string>): BlockPermutation;
 }
+
 /**
  * Contains return data on the result of a command execution.
  */
@@ -167,6 +239,192 @@ export class CommandResult {
      */
     readonly successCount: number;
 }
+
+/**
+ * @beta
+ * Base class for downstream Component implementations.
+ */
+export class Component {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of the component.
+     *
+     */
+    readonly typeId: string;
+}
+
+/**
+ * @beta
+ * Represents a container that can hold sets of items. Used
+ * with entities such as Players, Chest Minecarts, Llamas, and
+ * more.
+ */
+export class Container {
+    protected constructor();
+    /**
+     * @remarks
+     * Count of the slots in the container that are empty.
+     *
+     * @throws
+     * Throws if the container is invalid.
+     */
+    readonly emptySlotsCount: number;
+    /**
+     * @remarks
+     * The number of slots in this container. For example, a
+     * standard single-block chest has a size of 27. Note, a
+     * player's inventory container contains a total of 36 slots, 9
+     * hotbar slots plus 27 inventory slots.
+     *
+     * @throws
+     * Throws if the container is invalid.
+     */
+    readonly size: number;
+    /**
+     * @remarks
+     * Adds an item to the container. The item is placed in the
+     * first available slot(s) and can be stacked with existing
+     * items of the same type. Note, use {@link Container.setItem}
+     * if you wish to set the item in a particular slot.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param itemStack
+     * The stack of items to add.
+     * @throws This function can throw errors.
+     */
+    addItem(itemStack: ItemStack): ItemStack;
+    /**
+     * @remarks
+     * Clears all inventory items in the container.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws
+     * Throws if the container is invalid.
+     */
+    clearAll(): void;
+    /**
+     * @remarks
+     * Gets an {@link ItemStack} of the item at the specified slot.
+     * If the slot is empty, returns `undefined`. This method does
+     * not change or clear the contents of the specified slot. To
+     * get a reference to a particular slot, see {@link
+     * Container.getSlot}.
+     *
+     * @param slot
+     * Zero-based index of the slot to retrieve items from.
+     * @throws
+     * Throws if the container is invalid or if the `slot` index is
+     * out of bounds.
+     * @example getItem.ts
+     * ```typescript
+     *        // Get a copy of the first item in the player's hotbar
+     *        const inventory = player.getComponent("inventory") as EntityInventoryComponent;
+     *        const itemStack = inventory.container.getItem(0);
+     *
+     * ```
+     */
+    getItem(slot: number): ItemStack | undefined;
+    /**
+     * @remarks
+     * Moves an item from one slot to another, potentially across
+     * containers.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param fromSlot
+     * Zero-based index of the slot to transfer an item from, on
+     * this container.
+     * @param toSlot
+     * Zero-based index of the slot to transfer an item to, on
+     * `toContainer`.
+     * @param toContainer
+     * Target container to transfer to. Note this can be the same
+     * container as the source.
+     * @throws
+     * Throws if either this container or `toContainer` are invalid
+     * or if the `fromSlot` or `toSlot` indices out of bounds.
+     * @example moveItem.ts
+     * ```typescript
+     *        // Move an item from the first slot of fromPlayer's inventory to the fifth slot of toPlayer's inventory
+     *        const fromInventory = fromPlayer.getComponent('inventory') as EntityInventoryComponent;
+     *        const toInventory = toPlayer.getComponent('inventory') as EntityInventoryComponent;
+     *        fromInventory.container.moveItem(0, 4, toInventory.container);
+     *
+     * ```
+     */
+    moveItem(fromSlot: number, toSlot: number, toContainer: Container): void;
+    /**
+     * @remarks
+     * Sets an item stack within a particular slot.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param slot
+     * Zero-based index of the slot to set an item at.
+     * @param itemStack
+     * Stack of items to place within the specified slot. Setting
+     * `itemStack` to undefined will clear the slot.
+     * @throws
+     * Throws if the container is invalid or if the `slot` index is
+     * out of bounds.
+     */
+    setItem(slot: number, itemStack?: ItemStack): void;
+    /**
+     * @remarks
+     * Swaps items between two different slots within containers.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param slot
+     * Zero-based index of the slot to swap from this container.
+     * @param otherSlot
+     * Zero-based index of the slot to swap with.
+     * @param otherContainer
+     * Target container to swap with. Note this can be the same
+     * container as this source.
+     * @throws
+     * Throws if either this container or `otherContainer` are
+     * invalid or if the `slot` or `otherSlot` are out of bounds.
+     * @example swapItems.ts
+     * ```typescript
+     *        // Swaps an item between slots 0 and 4 in the player's inventory
+     *        const inventory = fromPlayer.getComponent('inventory') as EntityInventoryComponent;
+     *        inventory.container.swapItems(0, 4, inventory);
+     *
+     * ```
+     */
+    swapItems(slot: number, otherSlot: number, otherContainer: Container): void;
+    /**
+     * @remarks
+     * Moves an item from one slot to another container, or to the
+     * first available slot in the same container.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param fromSlot
+     * Zero-based index of the slot to transfer an item from, on
+     * this container.
+     * @param toContainer
+     * Target container to transfer to. Note this can be the same
+     * container as the source.
+     * @throws
+     * Throws if either this container or `toContainer` are invalid
+     * or if the `fromSlot` or `toSlot` indices out of bounds.
+     * @example transferItem.ts
+     * ```typescript
+     *        // Transfer an item from the first slot of fromPlayer's inventory to toPlayer's inventory
+     *        const fromInventory = fromPlayer.getComponent('inventory') as EntityInventoryComponent;
+     *        const toInventory = toPlayer.getComponent('inventory') as EntityInventoryComponent;
+     *        fromInventory.container.transferItem(0, toInventory.container);
+     *
+     * ```
+     */
+    transferItem(fromSlot: number, toContainer: Container): ItemStack;
+}
+
 /**
  * A class that represents a particular dimension (e.g., The
  * End) within a world.
@@ -183,8 +441,7 @@ export class Dimension {
     /**
      * @beta
      * @remarks
-     * Returns a block instance at the given location. This method
-     * was introduced as of version 1.17.10.21.
+     * Returns a block instance at the given location.
      *
      * @param location
      * The location at which to return a block.
@@ -192,172 +449,1210 @@ export class Dimension {
      * Block at the specified location.
      * @throws This function can throw errors.
      */
-    getBlock(location: Vector3): Block;
+    getBlock(location: Vector3): Block | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns a set of entities based on a set of conditions
+     * defined via the EntityQueryOptions set of filter criteria.
+     *
+     * @param options
+     * Additional options that can be used to filter the set of
+     * entities returned.
+     * @returns
+     * An entity array.
+     * @throws This function can throw errors.
+     * @example testThatEntityIsFeatherItem.ts
+     * ```typescript
+     *        const query = {
+     *          type: "item",
+     *          location: targetLocation,
+     *        };
+     *        const items = overworld.getEntities(query);
+     *
+     *        for (const item of items) {
+     *          const itemComp = item.getComponent("item") as any;
+     *
+     *          if (itemComp) {
+     *            if (itemComp.itemStack.id.endsWith("feather")) {
+     *              console.log("Success! Found a feather", 1);
+     *            }
+     *          }
+     *        }
+     *
+     * ```
+     */
+    getEntities(options?: EntityQueryOptions): Entity[];
+    /**
+     * @beta
+     * @remarks
+     * Returns a set of entities at a particular location.
+     *
+     * @param location
+     * The location at which to return entities.
+     * @returns
+     * Zero or more entities at the specified location.
+     */
+    getEntitiesAtBlockLocation(location: Vector3): Entity[];
+    /**
+     * @beta
+     * @remarks
+     * Returns a set of players based on a set of conditions
+     * defined via the EntityQueryOptions set of filter criteria.
+     *
+     * @param options
+     * Additional options that can be used to filter the set of
+     * players returned.
+     * @returns
+     * A player array.
+     * @throws This function can throw errors.
+     */
+    getPlayers(options?: EntityQueryOptions): Player[];
+    /**
+     * @beta
+     * @remarks
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    runCommand(commandString: string): CommandResult;
+    /**
+     * @remarks
+     * Runs a particular command asynchronously from the context of
+     * the broader dimension.  Note that there is a maximum queue
+     * of 128 asynchronous commands that can be run in a given
+     * tick.
+     *
+     * @param commandString
+     * Command to run. Note that command strings should not start
+     * with slash.
+     * @returns
+     * For commands that return data, returns a CommandResult with
+     * an indicator of command results.
+     * @throws This function can throw errors.
+     */
+    runCommandAsync(commandString: string): Promise<CommandResult>;
+}
+
+/**
+ * Represents the state of an entity (a mob, the player, or
+ * other moving objects like minecarts) in the world.
+ */
+export class Entity {
+    protected constructor();
+    /**
+     * @beta
+     * @remarks
+     * Dimension that the entity is currently within.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly dimension: Dimension;
+    /**
+     * @remarks
+     * Unique identifier of the entity. This identifier is intended
+     * to be consistent across loads of a world instance. No
+     * meaning should be inferred from the value and structure of
+     * this unique identifier - do not parse or interpret it.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly id: string;
+    /**
+     * @beta
+     * @remarks
+     * Current location of the entity.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly location: Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Given name of the entity.
+     *
+     * This property can't be edited in read-only mode.
+     *
+     */
+    nameTag: string;
+    /**
+     * @remarks
+     * Unique identifier of the type of the entity - for example,
+     * 'minecraft:skeleton'.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly typeId: string;
+    /**
+     * @beta
+     * @remarks
+     * Adds a specified tag to an entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param tag
+     * Content of the tag to add.
+     * @throws This function can throw errors.
+     */
+    addTag(tag: string): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Applies a set of damage to an entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param amount
+     * Amount of damage to apply.
+     * @param options
+     * Additional options about the source of damage, which may add
+     * additional effects or spur additional behaviors on this
+     * entity.
+     * @throws This function can throw errors.
+     */
+    applyDamage(amount: number, options?: EntityApplyDamageByProjectileOptions | EntityApplyDamageOptions): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Applies impulse vector to the current velocity of the
+     * entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param vector
+     * Impulse vector.
+     * @throws This function can throw errors.
+     */
+    applyImpulse(vector: Vector3): void;
+    /**
+     * @beta
+     * @remarks
+     * Applies impulse vector to the current velocity of the
+     * entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param directionX
+     * X direction in horizontal plane.
+     * @param directionZ
+     * Z direction in horizontal plane.
+     * @param horizontalStrength
+     * Knockback strength for the horizontal vector.
+     * @param verticalStrength
+     * Knockback strength for the vertical vector.
+     * @throws This function can throw errors.
+     */
+    applyKnockback(directionX: number, directionZ: number, horizontalStrength: number, verticalStrength: number): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets the current velocity of the Entity to zero. Note that
+     * this method may not have an impact on Players.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    clearVelocity(): void;
+    /**
+     * @beta
+     * @remarks
+     * Gets a component (that represents additional capabilities)
+     * for an entity.
+     *
+     * @param componentId
+     * The identifier of the component (e.g., 'minecraft:rideable')
+     * to retrieve. If no namespace prefix is specified,
+     * 'minecraft:' is assumed. If the component is not present on
+     * the entity, undefined is returned.
+     */
+    getComponent(componentId: string): EntityComponent | undefined;
+    /**
+     * @beta
+     * @remarks
+     * Returns all components that are both present on this entity
+     * and supported by the API.
+     *
+     */
+    getComponents(): EntityComponent[];
+    /**
+     * @beta
+     * @remarks
+     * Returns the current location of the head component of this
+     * entity.
+     *
+     * @throws This function can throw errors.
+     */
+    getHeadLocation(): Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Returns all tags associated with an entity.
+     *
+     * @throws This function can throw errors.
+     */
+    getTags(): string[];
+    /**
+     * @beta
+     * @remarks
+     * Returns the current velocity vector of the entity.
+     *
+     * @throws This function can throw errors.
+     */
+    getVelocity(): Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Returns the current view direction of the entity.
+     *
+     * @throws This function can throw errors.
+     */
+    getViewDirection(): Vector3;
+    /**
+     * @beta
+     * @remarks
+     * Returns true if the specified component is present on this
+     * entity.
+     *
+     * @param componentId
+     * The identifier of the component (e.g., 'minecraft:rideable')
+     * to retrieve. If no namespace prefix is specified,
+     * 'minecraft:' is assumed.
+     */
+    hasComponent(componentId: string): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Tests whether an entity has a particular tag.
+     *
+     * @param tag
+     * Identifier of the tag to test for.
+     * @throws This function can throw errors.
+     */
+    hasTag(tag: string): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Kills this entity. The entity will drop loot as normal.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * Returns true if entity can be killed (even if it is already
+     * dead), otherwise it returns false.
+     * @throws This function can throw errors.
+     */
+    kill(): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Removes a specified tag from an entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param tag
+     * Content of the tag to remove.
+     * @throws This function can throw errors.
+     */
+    removeTag(tag: string): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Runs a synchronous command on the entity.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    runCommand(commandString: string): CommandResult;
+    /**
+     * @remarks
+     * Runs a particular command asynchronously from the context of
+     * this entity. Note that there is a maximum queue of 128
+     * asynchronous commands that can be run in a given tick.
+     *
+     * @param commandString
+     * Command to run. Note that command strings should not start
+     * with slash.
+     * @returns
+     * For commands that return data, returns a JSON structure with
+     * command response values.
+     * @throws This function can throw errors.
+     */
+    runCommandAsync(commandString: string): Promise<CommandResult>;
+}
+
+/**
+ * @beta
+ * Base class for a family of entity movement events.
+ */
+export class EntityBaseMovementComponent extends EntityComponent {
+    protected constructor();
+    readonly maxTurn: number;
+}
+
+/**
+ * @beta
+ * When added, this component signifies that the entity can
+ * climb up ladders.
+ */
+export class EntityCanClimbComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:can_climb.
+     *
+     */
+    static readonly componentId = 'minecraft:can_climb';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that the entity can
+ * fly, and the pathfinder won't be restricted to paths where a
+ * solid block is required underneath it.
+ */
+export class EntityCanFlyComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:can_fly.
+     *
+     */
+    static readonly componentId = 'minecraft:can_fly';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that the entity can
+ * power jump like the horse does within Minecraft.
+ */
+export class EntityCanPowerJumpComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:can_power_jump.
+     *
+     */
+    static readonly componentId = 'minecraft:can_power_jump';
+}
+
+/**
+ * @beta
+ * Defines the entity's color. Only works on certain entities
+ * that have predefined color values (sheep, llama, shulker).
+ */
+export class EntityColorComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:color.
+     *
+     */
+    static readonly componentId = 'minecraft:color';
+}
+
+/**
+ * @beta
+ * Base class for downstream entity components.
+ */
+export class EntityComponent extends Component {
+    protected constructor();
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity
+ * doesn't take damage from fire.
+ */
+export class EntityFireImmuneComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:fire_immune.
+     *
+     */
+    static readonly componentId = 'minecraft:fire_immune';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity can
+ * float in liquid blocks.
+ */
+export class EntityFloatsInLiquidComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:floats_in_liquid.
+     *
+     */
+    static readonly componentId = 'minecraft:floats_in_liquid';
+}
+
+/**
+ * @beta
+ * Represents the flying speed of an entity.
+ */
+export class EntityFlyingSpeedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:flying_speed.
+     *
+     */
+    static readonly componentId = 'minecraft:flying_speed';
+}
+
+/**
+ * @beta
+ * Defines how much friction affects this entity.
+ */
+export class EntityFrictionModifierComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:friction_modifier.
+     *
+     */
+    static readonly componentId = 'minecraft:friction_modifier';
+}
+
+/**
+ * @beta
+ * Sets the offset from the ground that the entity is actually
+ * at.
+ */
+export class EntityGroundOffsetComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:ground_offset.
+     *
+     */
+    static readonly componentId = 'minecraft:ground_offset';
+}
+
+/**
+ * @beta
+ * Defines this entity's inventory properties.
+ */
+export class EntityInventoryComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Number of slots that this entity can gain per extra
+     * strength.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly additionalSlotsPerStrength: number;
+    /**
+     * @remarks
+     * If true, the contents of this inventory can be removed by a
+     * hopper.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly canBeSiphonedFrom: boolean;
+    /**
+     * @remarks
+     * Defines the container for this entity.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly container: Container;
+    /**
+     * @remarks
+     * Type of container this entity has.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly containerType: string;
+    /**
+     * @remarks
+     * Number of slots the container has.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly inventorySize: number;
+    /**
+     * @remarks
+     * If true, the entity will not drop it's inventory on death.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly 'private': boolean;
+    /**
+     * @remarks
+     * If true, the entity's inventory can only be accessed by its
+     * owner or itself.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly restrictToOwner: boolean;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:inventory.
+     *
+     */
+    static readonly componentId = 'minecraft:inventory';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is a
+ * baby.
+ */
+export class EntityIsBabyComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_baby.
+     *
+     */
+    static readonly componentId = 'minecraft:is_baby';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * charged.
+ */
+export class EntityIsChargedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_charged.
+     *
+     */
+    static readonly componentId = 'minecraft:is_charged';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently carrying a chest.
+ */
+export class EntityIsChestedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_chested.
+     *
+     */
+    static readonly componentId = 'minecraft:is_chested';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that dyes can be used
+ * on this entity to change its color.
+ */
+export class EntityIsDyeableComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_dyeable.
+     *
+     */
+    static readonly componentId = 'minecraft:is_dyeable';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity can
+ * hide from hostile mobs while invisible.
+ */
+export class EntityIsHiddenWhenInvisibleComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_hidden_when_invisible.
+     *
+     */
+    static readonly componentId = 'minecraft:is_hidden_when_invisible';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity this
+ * currently on fire.
+ */
+export class EntityIsIgnitedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_ignited.
+     *
+     */
+    static readonly componentId = 'minecraft:is_ignited';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is an
+ * illager captain.
+ */
+export class EntityIsIllagerCaptainComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_illager_captain.
+     *
+     */
+    static readonly componentId = 'minecraft:is_illager_captain';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently saddled.
+ */
+export class EntityIsSaddledComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_saddled.
+     *
+     */
+    static readonly componentId = 'minecraft:is_saddled';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently shaking.
+ */
+export class EntityIsShakingComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_shaking.
+     *
+     */
+    static readonly componentId = 'minecraft:is_shaking';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently sheared.
+ */
+export class EntityIsShearedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_sheared.
+     *
+     */
+    static readonly componentId = 'minecraft:is_sheared';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity can be
+ * stacked.
+ */
+export class EntityIsStackableComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_stackable.
+     *
+     */
+    static readonly componentId = 'minecraft:is_stackable';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently stunned.
+ */
+export class EntityIsStunnedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_stunned.
+     *
+     */
+    static readonly componentId = 'minecraft:is_stunned';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity is
+ * currently tamed.
+ */
+export class EntityIsTamedComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:is_tamed.
+     *
+     */
+    static readonly componentId = 'minecraft:is_tamed';
+}
+
+/**
+ * @beta
+ * If added onto the entity, this indicates that the entity
+ * represents a free-floating item in the world. Lets you
+ * retrieve the actual item stack contents via the itemStack
+ * property.
+ */
+export class EntityItemComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Item stack represented by this entity in the world.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly itemStack: ItemStack;
+    /**
+     * @remarks
+     * Identifier of this component.
+     *
+     */
+    static readonly componentId = 'minecraft:item';
+}
+
+/**
+ * @beta
+ * Additional variant value. Can be used to further
+ * differentiate variants.
+ */
+export class EntityMarkVariantComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:mark_variant.
+     *
+     */
+    static readonly componentId = 'minecraft:mark_variant';
+}
+
+/**
+ * @beta
+ * When added, this movement control allows the mob to swim in
+ * water and walk on land.
+ */
+export class EntityMovementAmphibiousComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.amphibious.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.amphibious';
+}
+
+/**
+ * @beta
+ * This component accents the movement of an entity.
+ */
+export class EntityMovementBasicComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.basic.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.basic';
+}
+
+/**
+ * @beta
+ * When added, this move control causes the mob to fly.
+ */
+export class EntityMovementFlyComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.fly.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.fly';
+}
+
+/**
+ * @beta
+ * When added, this move control allows a mob to fly, swim,
+ * climb, etc.
+ */
+export class EntityMovementGenericComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.generic.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.generic';
+}
+
+/**
+ * @beta
+ * When added, this move control causes the mob to hover.
+ */
+export class EntityMovementHoverComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.hover.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.hover';
+}
+
+/**
+ * @beta
+ * Move control that causes the mob to jump as it moves with a
+ * specified delay between jumps.
+ */
+export class EntityMovementJumpComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.jump.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.jump';
+}
+
+/**
+ * @beta
+ * When added, this move control causes the mob to hop as it
+ * moves.
+ */
+export class EntityMovementSkipComponent extends EntityBaseMovementComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:movement.skip.
+     *
+     */
+    static readonly componentId = 'minecraft:movement.skip';
+}
+
+/**
+ * @beta
+ * Sets the distance through which the entity can push through.
+ */
+export class EntityPushThroughComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:push_through.
+     *
+     */
+    static readonly componentId = 'minecraft:push_through';
+}
+
+/**
+ * @beta
+ * Sets the entity's visual size.
+ */
+export class EntityScaleComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:scale.
+     *
+     */
+    static readonly componentId = 'minecraft:scale';
+}
+
+/**
+ * @beta
+ * Skin Id value. Can be used to differentiate skins, such as
+ * base skins for villagers.
+ */
+export class EntitySkinIdComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * This property can't be edited in read-only mode.
+     *
+     */
+    value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:skin_id.
+     *
+     */
+    static readonly componentId = 'minecraft:skin_id';
+}
+
+/**
+ * @beta
+ * Used to differentiate the component group of a variant of an
+ * entity from others. (e.g. ocelot, villager).
+ */
+export class EntityVariantComponent extends EntityComponent {
+    protected constructor();
+    readonly value: number;
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:variant.
+     *
+     */
+    static readonly componentId = 'minecraft:variant';
+}
+
+/**
+ * @beta
+ * When added, this component signifies that this entity wants
+ * to become a jockey.
+ */
+export class EntityWantsJockeyComponent extends EntityComponent {
+    protected constructor();
+    /**
+     * @remarks
+     * Identifier of this component. Should always be
+     * minecraft:wants_jockey.
+     *
+     */
+    static readonly componentId = 'minecraft:wants_jockey';
+}
+
+/**
+ * @beta
+ * Base class for item components.
+ */
+export class ItemComponent extends Component {
+    protected constructor();
+}
+
+/**
+ * @beta
+ * Defines a collection of items.
+ */
+export class ItemStack {
+    /**
+     * @remarks
+     * Number of the items in the stack. Valid values range between
+     * 1-255. The provided value will be clamped to the item's
+     * maximum stack size.
+     *
+     * @throws
+     * Throws if the value is outside the range of 1-255.
+     */
+    readonly amount: number;
     /**
-     * @beta
      * @remarks
-     * Returns a set of entities based on a set of conditions
-     * defined via the EntityQueryOptions set of filter criteria.
-     *
-     * @param options
-     * Additional options that can be used to filter the set of
-     * entities returned.
-     * @returns
-     * An entity array.
-     * @throws This function can throw errors.
-     * @example testThatEntityIsFeatherItem.ts
-     * ```typescript
-     *        const query = {
-     *          type: "item",
-     *          location: targetLocation,
-     *        };
-     *        const items = overworld.getEntities(query);
-     *
-     *        for (const item of items) {
-     *          const itemComp = item.getComponent("item") as any;
-     *
-     *          if (itemComp) {
-     *            if (itemComp.itemStack.id.endsWith("feather")) {
-     *              console.log("Success! Found a feather", 1);
-     *            }
-     *          }
-     *        }
+     * Returns whether the item is stackable. An item is considered
+     * stackable if the item's maximum stack size is greater than 1
+     * and the item does not contain any custom data or properties.
      *
-     * ```
      */
-    getEntities(options?: EntityQueryOptions): Entity[];
+    readonly isStackable: boolean;
     /**
-     * @beta
      * @remarks
-     * Returns a set of entities at a particular location.
+     * Gets or sets whether the item is kept on death.
      *
-     * @param location
-     * The location at which to return entities.
-     * @returns
-     * Zero or more entities at the specified location.
      */
-    getEntitiesAtBlockLocation(location: Vector3): Entity[];
+    readonly keepOnDeath: boolean;
     /**
-     * @beta
      * @remarks
-     * Returns a set of players based on a set of conditions
-     * defined via the EntityQueryOptions set of filter criteria.
+     * Gets or sets the item's lock mode. The default value is
+     * `ItemLockMode.none`.
      *
-     * @param options
-     * Additional options that can be used to filter the set of
-     * players returned.
-     * @returns
-     * A player array.
-     * @throws This function can throw errors.
      */
-    getPlayers(options?: EntityQueryOptions): Player[];
+    readonly lockMode: ItemLockMode;
     /**
      * @remarks
-     * Runs a particular command asynchronously from the context of
-     * the broader dimension.  Note that there is a maximum queue
-     * of 128 asynchronous commands that can be run in a given
-     * tick.
+     * The maximum stack size. This value varies depending on the
+     * type of item. For example, torches have a maximum stack size
+     * of 64, while eggs have a maximum stack size of 16.
      *
-     * @param commandString
-     * Command to run. Note that command strings should not start
-     * with slash.
-     * @returns
-     * For commands that return data, returns a CommandResult with
-     * an indicator of command results.
-     * @throws This function can throw errors.
      */
-    runCommandAsync(commandString: string): Promise<CommandResult>;
-}
-/**
- * Represents the state of an entity (a mob, the player, or
- * other moving objects like minecarts) in the world.
- */
-export class Entity {
-    protected constructor();
+    readonly maxAmount: number;
     /**
-     * @beta
      * @remarks
-     * Dimension that the entity is currently within.
+     * Given name of this stack of items. The name tag is displayed
+     * when hovering over the item. Setting the name tag to an
+     * empty string or `undefined` will remove the name tag.
      *
-     * @throws This property can throw when used.
+     * @throws
+     * Throws if the length exceeds 255 characters.
      */
-    readonly dimension: Dimension;
+    readonly nameTag?: string;
     /**
      * @remarks
-     * Unique identifier of the entity. This identifier is intended
-     * to be consistent across loads of a world instance. No
-     * meaning should be inferred from the value and structure of
-     * this unique identifier - do not parse or interpret it.
+     * The type of the item.
      *
-     * @throws This property can throw when used.
      */
-    readonly id: string;
+    readonly 'type': ItemType;
     /**
-     * @beta
      * @remarks
-     * Current location of the entity.
+     * Identifier of the type of items for the stack. If a
+     * namespace is not specified, 'minecraft:' is assumed.
+     * Examples include 'wheat' or 'apple'.
      *
-     * @throws This property can throw when used.
      */
-    readonly location: Vector3;
+    readonly typeId: string;
     /**
-     * @beta
      * @remarks
-     * Given name of the entity.
-     *
-     * This property can't be edited in read-only mode.
+     * Creates a new instance of a stack of items for use in the
+     * world.
      *
+     * @param itemType
+     * Type of item to create. See the {@link MinecraftItemTypes}
+     * enumeration for a list of standard item types in Minecraft
+     * experiences.
+     * @param amount
+     * Number of items to place in the stack, between 1-255. The
+     * provided value will be clamped to the item's maximum stack
+     * size. Note that certain items can only have one item in the
+     * stack.
+     * @throws
+     * Throws if `itemType` is invalid, or if `amount` is outside
+     * the range of 1-255.
      */
-    nameTag: string;
+    constructor(itemType: ItemType | string, amount?: number);
     /**
      * @remarks
-     * Unique identifier of the type of the entity - for example,
-     * 'minecraft:skeleton'.
+     * Gets a component (that represents additional capabilities)
+     * for an item stack.
      *
-     * @throws This property can throw when used.
+     * @param componentId
+     * The identifier of the component (e.g., 'minecraft:food') to
+     * retrieve. If no namespace prefix is specified, 'minecraft:'
+     * is assumed. If the component is not present on the item
+     * stack, undefined is returned.
+     * @example durability.ts
+     * ```typescript
+     *        // Get the maximum durability of a custom sword item
+     *        const itemStack = new ItemStack("custom:sword");
+     *        const durability = itemStack.getComponent("minecraft:durability") as ItemDurabilityComponent;
+     *        const maxDurability = durability.maxDurability;
+     *
+     * ```
      */
-    readonly typeId: string;
+    getComponent(componentId: string): ItemComponent | undefined;
     /**
-     * @beta
      * @remarks
-     * Returns the current location of the head component of this
-     * entity.
+     * Returns all components that are both present on this item
+     * stack and supported by the API.
      *
-     * @throws This function can throw errors.
      */
-    getHeadLocation(): Vector3;
+    getComponents(): ItemComponent[];
     /**
-     * @beta
      * @remarks
-     * Returns the current velocity vector of the entity.
+     * Returns true if the specified component is present on this
+     * item stack.
      *
-     * @throws This function can throw errors.
+     * @param componentId
+     * The identifier of the component (e.g., 'minecraft:food') to
+     * retrieve. If no namespace prefix is specified, 'minecraft:'
+     * is assumed.
      */
-    getVelocity(): Vector3;
+    hasComponent(componentId: string): boolean;
     /**
-     * @beta
      * @remarks
-     * Returns the current view direction of the entity.
+     * Returns whether this item stack can be stacked with the
+     * given `itemStack`. This is determined by comparing the item
+     * type and any custom data and properties associated with the
+     * item stacks. The amount of each item stack is not taken into
+     * consideration.
      *
-     * @throws This function can throw errors.
      */
-    getViewDirection(): Vector3;
+    isStackableWith(itemStack: ItemStack): boolean;
+}
+
+/**
+ * @beta
+ * Represents the type of an item - for example, Wool.
+ */
+export class ItemType {
+    protected constructor();
     /**
      * @remarks
-     * Runs a particular command asynchronously from the context of
-     * this entity. Note that there is a maximum queue of 128
-     * asynchronous commands that can be run in a given tick.
+     * Returns the identifier of the item type - for example,
+     * 'minecraft:apple'.
      *
-     * @param commandString
-     * Command to run. Note that command strings should not start
-     * with slash.
-     * @returns
-     * For commands that return data, returns a JSON structure with
-     * command response values.
-     * @throws This function can throw errors.
      */
-    runCommandAsync(commandString: string): Promise<CommandResult>;
+    readonly id: string;
 }
+
 /**
  * A collection of default Minecraft dimension types.
  */
@@ -397,6 +1692,7 @@ export class MinecraftDimensionTypes {
      */
     static readonly theEnd = 'minecraft:the_end';
 }
+
 /**
  * Represents a player within the world.
  */
@@ -409,6 +1705,20 @@ export class Player extends Entity {
      * @throws This property can throw when used.
      */
     readonly name: string;
+    /**
+     * @beta
+     * @remarks
+     * Plays a sound that only this particular player can hear.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param soundID
+     * Identifier of the sound to play.
+     * @param soundOptions
+     * Additional optional options for the sound.
+     * @throws This function can throw errors.
+     */
+    playSound(soundID: string, soundOptions?: PlayerSoundOptions): void;
     /**
      * @beta
      * @remarks
@@ -453,6 +1763,7 @@ export class Player extends Entity {
      */
     sendMessage(message: (RawMessage | string)[] | RawMessage | string): void;
 }
+
 /**
  * A class that provides system-level events and functions.
  */
@@ -518,6 +1829,7 @@ export class System {
      */
     runTimeout(callback: () => void, tickDelay?: number): number;
 }
+
 /**
  * A class that wraps the state of a world - a set of
  * dimensions and the environment of Minecraft.
@@ -555,6 +1867,37 @@ export class World {
      * @throws This function can throw errors.
      */
     getPlayers(options?: EntityQueryOptions): Player[];
+    /**
+     * @beta
+     * @remarks
+     * Plays a particular music track for all players.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    playMusic(trackID: string, musicOptions?: MusicOptions): void;
+    /**
+     * @beta
+     * @remarks
+     * Plays a sound for all players.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    playSound(soundID: string, location: Vector3, soundOptions?: WorldSoundOptions): void;
+    /**
+     * @beta
+     * @remarks
+     * Queues an additional music track for players. If a track is
+     * not playing, a music track will play.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    queueMusic(trackID: string, musicOptions?: MusicOptions): void;
     /**
      * @beta
      * @remarks
@@ -598,7 +1941,56 @@ export class World {
      * ```
      */
     sendMessage(message: (RawMessage | string)[] | RawMessage | string): void;
+    /**
+     * @beta
+     * @remarks
+     * Stops any music tracks from playing.
+     *
+     * This function can't be called in read-only mode.
+     *
+     */
+    stopMusic(): void;
+}
+
+/**
+ * @beta
+ * Additional options for when damage has been applied via a
+ * projectile.
+ */
+export interface EntityApplyDamageByProjectileOptions {
+    /**
+     * @remarks
+     * Optional entity that fired the projectile.
+     *
+     */
+    damagingEntity?: Entity;
+    /**
+     * @remarks
+     * Projectile that caused damage.
+     *
+     */
+    damagingProjectile: Entity;
+}
+
+/**
+ * @beta
+ * Additional descriptions and metadata for a damage event.
+ */
+export interface EntityApplyDamageOptions {
+    /**
+     * @remarks
+     * Underlying cause of the damage.
+     *
+     */
+    cause: EntityDamageCause;
+    /**
+     * @remarks
+     * Optional entity that caused the damage.
+     *
+     */
+    damagingEntity?: Entity;
 }
+
 /**
  * @beta
  * Contains options for selecting entities within an area.
@@ -761,6 +2153,7 @@ export interface EntityQueryOptions {
      */
     type?: string;
 }
+
 /**
  * @beta
  * Contains additional options for filtering players based on
@@ -795,6 +2188,59 @@ export interface EntityQueryScoreOptions {
      */
     objective?: string;
 }
+
+/**
+ * @beta
+ * Additional configuration options for {@link
+ * World.playMusic}/{@link World.queueMusic} methods.
+ */
+export interface MusicOptions {
+    /**
+     * @remarks
+     * Specifies a fade overlap for music at the end of play.
+     *
+     */
+    fade?: number;
+    /**
+     * @remarks
+     * If set to true, this music track will play repeatedly.
+     *
+     */
+    loop?: boolean;
+    /**
+     * @remarks
+     * Relative volume level of the music.
+     *
+     */
+    volume?: number;
+}
+
+/**
+ * @beta
+ * Additional options for how a sound plays for a player.
+ */
+export interface PlayerSoundOptions {
+    /**
+     * @remarks
+     * Location of the sound; if not specified, the sound is played
+     * near a player.
+     *
+     */
+    location?: Vector3;
+    /**
+     * @remarks
+     * Optional pitch of the sound.
+     *
+     */
+    pitch?: number;
+    /**
+     * @remarks
+     * Optional volume of the sound.
+     *
+     */
+    volume?: number;
+}
+
 /**
  * @beta
  */
@@ -805,13 +2251,27 @@ export interface RawMessage {
     translate?: string;
     with?: string[] | RawMessage;
 }
+
 /**
  * @beta
+ * Provides a description of a score token to use within a raw
+ * message.
  */
 export interface RawMessageScore {
+    /**
+     * @remarks
+     * Name of the score value to match.
+     *
+     */
     name?: string;
+    /**
+     * @remarks
+     * Name of the score value to match.
+     *
+     */
     objective?: string;
 }
+
 /**
  * @beta
  * Contains a description of a vector.
@@ -836,6 +2296,27 @@ export interface Vector3 {
      */
     z: number;
 }
+
+/**
+ * @beta
+ * Contains additional options for a world-level playSound
+ * occurrence.
+ */
+export interface WorldSoundOptions {
+    /**
+     * @remarks
+     * Pitch of the sound played at the world level.
+     *
+     */
+    pitch?: number;
+    /**
+     * @remarks
+     * Relative volume and space by which this sound is heard.
+     *
+     */
+    volume?: number;
+}
+
 /**
  * @remarks
  * A class that provides system-level events and functions.