@minecraft/server 1.3.0-beta.1.20.0-preview.22 → 1.3.0-beta.1.20.0-preview.24

package/index.d.ts

@@ -16,7 +16,7 @@
  * ```json
  * {
  *   "module_name": "@minecraft/server",
- *   "version": "1.3.0-internal.1.20.0-preview.22"
+ *   "version": "1.3.0-internal.1.20.0-preview.24"
  * }
  * ```
  *
@@ -40,94 +40,27 @@ export enum CompoundBlockVolumeAction {
 
 /**
  * @beta
- * Represents a direction for expressing relative position or
- * facing.
  */
 export enum Direction {
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the down (z - 1)
-     * direction.
-     *
-     */
     down = 'down',
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the east (x + 1)
-     * direction.
-     *
-     */
     east = 'east',
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the north (z - 1)
-     * direction.
-     *
-     */
     north = 'north',
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the south (z + 1)
-     * direction.
-     *
-     */
     south = 'south',
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the up (z + 1)
-     * direction.
-     *
-     */
     up = 'up',
-    /**
-     * @beta
-     * @remarks
-     * Represents an object located or facing in the west (x - 1)
-     * direction.
-     *
-     */
     west = 'west',
 }
 
 /**
  * @beta
- * An enumeration for the locations where scoreboard objectives
- * can be displayed.
  */
 export enum DisplaySlotId {
-    /**
-     * @beta
-     * @remarks
-     * Score for an objective is displayed below a player's
-     * nametag.
-     *
-     */
     belowname = 'belowname',
-    /**
-     * @beta
-     * @remarks
-     * This objective and respective list of players is shown on
-     * the Pause menu.
-     *
-     */
     list = 'list',
-    /**
-     * @beta
-     * @remarks
-     * The objective is shown on the right-hand side of the screen.
-     *
-     */
     sidebar = 'sidebar',
 }
 
 /**
  * @beta
- * All the dye types supported by scripting
  */
 export enum DyeColor {
     black = 'black',
@@ -425,52 +358,280 @@ export enum WeatherType {
 
 /**
  * @beta
+ * Contains a set of events that are available across the scope
+ * of the World.
  */
 export class AfterEvents {
     protected constructor();
+    /**
+     * @remarks
+     * This event fires for a block that is broken by a player.
+     *
+     */
     readonly blockBreak: BlockBreakAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires for each BlockLocation destroyed by an
+     * explosion. It is fired after the blocks have already been
+     * destroyed.
+     *
+     */
     readonly blockExplode: BlockExplodeAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires for a block that is placed by a player.
+     *
+     */
     readonly blockPlace: BlockPlaceAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a button is pushed.
+     *
+     */
     readonly buttonPush: ButtonPushAfterEventSignal;
+    /**
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     */
     readonly chatSend: ChatSendAfterEventSignal;
+    /**
+     * @remarks
+     * This event is fired when an entity event has been triggered
+     * that will update the component definition state of an
+     * entity.
+     *
+     */
     readonly dataDrivenEntityTriggerEvent: DataDrivenEntityTriggerAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an effect, like poisoning, is added to
+     * an entity.
+     *
+     */
     readonly effectAdd: EffectAddAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an entity dies.
+     *
+     */
     readonly entityDie: EntityDieAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an entity hits (makes a melee attack)
+     * and potentially impacts another entity or block.
+     *
+     */
     readonly entityHit: EntityHitAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an entity is hurt (takes damage).
+     *
+     */
     readonly entityHurt: EntityHurtAfterEventSignal;
+    readonly entityRemoved: EntityRemovedAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an entity is spawned.
+     *
+     */
     readonly entitySpawn: EntitySpawnAfterEventSignal;
+    /**
+     * @remarks
+     * This event is fired after an explosion occurs.
+     *
+     */
     readonly explosion: ExplosionAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a chargeable item completes charging.
+     *
+     */
     readonly itemCompleteCharge: ItemCompleteChargeAfterEventSignal;
+    /**
+     * @remarks
+     * For custom items, this event is triggered when the
+     * fundamental set of defined components for the item change.
+     * Note that this event is only fired for custom data-driven
+     * items.
+     *
+     */
     readonly itemDefinitionEvent: ItemDefinitionAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a chargeable item is released from
+     * charging.
+     *
+     */
     readonly itemReleaseCharge: ItemReleaseChargeAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a chargeable item starts charging.
+     *
+     */
     readonly itemStartCharge: ItemStartChargeAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a player successfully uses an item or
+     * places a block by pressing the Use Item / Place Block
+     * button. If multiple blocks are placed, this event will only
+     * occur once at the beginning of the block placement. Note:
+     * This event cannot be used with Hoe or Axe items.
+     *
+     */
     readonly itemStartUseOn: ItemStartUseOnAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a chargeable item stops charging.
+     *
+     */
     readonly itemStopCharge: ItemStopChargeAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a player releases the Use Item / Place
+     * Block button after successfully using an item. Note: This
+     * event cannot be used with Hoe or Axe items.
+     *
+     */
     readonly itemStopUseOn: ItemStopUseOnAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an item is successfully used by a
+     * player.
+     *
+     */
     readonly itemUse: ItemUseAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when an item is used on a block by a
+     * player.
+     *
+     */
     readonly itemUseOn: ItemUseOnAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a lever activates or is deactivated.
+     *
+     */
     readonly leverActivate: LeverActionAfterEventSignal;
+    /**
+     * @remarks
+     * This event is an internal implementation detail, and is
+     * otherwise not currently functional.
+     *
+     */
     readonly messageReceive: ServerMessageAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a piston expands or retracts.
+     *
+     */
     readonly pistonActivate: PistonActivateAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a player joins a world.  See also
+     * playerSpawn for another related event you can trap for when
+     * a player is spawned the first time within a world.
+     *
+     */
     readonly playerJoin: PlayerJoinAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a player leaves a world.
+     *
+     */
     readonly playerLeave: PlayerLeaveAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a player spawns or respawns. Note that
+     * an additional flag within this event will tell you whether
+     * the player is spawning right after join vs. a respawn.
+     *
+     */
     readonly playerSpawn: PlayerSpawnAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when a projectile hits an entity or block.
+     *
+     */
     readonly projectileHit: ProjectileHitAfterEventSignal;
+    /**
+     * @remarks
+     * This event will be triggered when the weather changes within
+     * Minecraft.
+     *
+     */
     readonly weatherChange: WeatherChangeAfterEventSignal;
+    /**
+     * @remarks
+     * This event fires when the script environment is initialized
+     * on a World. In addition, you can register dynamic properties
+     * within the scope of a world Initialize event.
+     *
+     */
     readonly worldInitialize: WorldInitializeAfterEventSignal;
 }
 
 /**
  * @beta
+ * A set of events that fire before an actual action occurs. In
+ * most cases, you can potentially cancel or modify the
+ * impending event. Note that in before events any APIs that
+ * modify gameplay state will not function and will throw an
+ * error. (e.g., dimension.spawnEntity)
  */
 export class BeforeEvents {
     protected constructor();
+    /**
+     * @remarks
+     * This event is triggered after a chat message has been
+     * broadcast or sent to players.
+     *
+     */
     readonly chatSend: ChatSendBeforeEventSignal;
+    /**
+     * @remarks
+     * This event is fired when an entity event has been triggered
+     * that will update the component definition state of an
+     * entity.
+     *
+     */
     readonly dataDrivenEntityTriggerEvent: DataDrivenEntityTriggerBeforeEventSignal;
+    /**
+     * @remarks
+     * This event is fired after an explosion occurs.
+     *
+     */
     readonly explosion: ExplosionBeforeEventSignal;
+    /**
+     * @remarks
+     * For custom items, this event is triggered when the
+     * fundamental set of defined components for the item change.
+     * Note that this event is only fired for custom data-driven
+     * items.
+     *
+     */
     readonly itemDefinitionEvent: ItemDefinitionBeforeEventSignal;
+    /**
+     * @remarks
+     * This event fires when an item is successfully used by a
+     * player.
+     *
+     */
     readonly itemUse: ItemUseBeforeEventSignal;
+    /**
+     * @remarks
+     * This event fires when an item is used on a block by a
+     * player.
+     *
+     */
     readonly itemUseOn: ItemUseOnBeforeEventSignal;
+    /**
+     * @remarks
+     * This event fires when a piston expands or retracts.
+     *
+     */
     readonly pistonActivate: PistonActivateBeforeEventSignal;
 }
 
@@ -830,6 +991,11 @@ export class BlockEvent {
  */
 export class BlockExplodeAfterEvent extends BlockEvent {
     protected constructor();
+    /**
+     * @remarks
+     * Description of the block that has exploded.
+     *
+     */
     readonly explodedBlockPermutation: BlockPermutation;
     /**
      * @remarks
@@ -863,7 +1029,6 @@ export class BlockInventoryComponent extends BlockComponent {
      */
     readonly container: Container;
     /**
-     * @beta
      * @remarks
      * Identifier of this component. Should always be
      * minecraft:inventory.
@@ -890,11 +1055,15 @@ export class BlockLavaContainerComponent extends BlockLiquidContainerComponent {
 
 /**
  * @beta
+ * For blocks that can contain a liquid (e.g., a cauldron),
+ * this is a base component for liquid containers.
  */
 export class BlockLiquidContainerComponent extends BlockComponent {
     protected constructor();
     /**
      * @remarks
+     * Relative fill level of the liquid container.
+     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -903,6 +1072,21 @@ export class BlockLiquidContainerComponent extends BlockComponent {
 
 /**
  * @beta
+ * A BlockLocationIterator returns the next block location of
+ * the block volume across which it is iterating.
+ * The BlockLocationIterator is used to abstract the shape of
+ * the block volume it was fetched from (so it can represent
+ * all the block locations that make up rectangles, cubes,
+ * spheres, lines and complex shapes).
+ * Each iteration pass returns the next valid block location in
+ * the parent shape.
+ * Unless otherwise specified by the parent shape - the
+ * BlockLocationIterator will iterate over a 3D space in the
+ * order of increasing X, followed by increasing Z followed by
+ * increasing Y.
+ * (Effectively stepping across the XZ plane, and when all the
+ * locations in that plane are exhausted, increasing the Y
+ * coordinate to the next XZ slice)
  */
 export class BlockLocationIterator implements Iterable<Vector3> {
     protected constructor();
@@ -1021,6 +1205,14 @@ export class BlockPermutation {
     matches(blockName: string, states?: Record<string, boolean | number | string>): boolean;
     /**
      * @beta
+     * @remarks
+     * Returns a derived BlockPermutation with a specific property
+     * set.
+     *
+     * @param name
+     * Identifier of the block property.
+     * @param value
+     * Value of the block property.
      * @throws This function can throw errors.
      */
     withState(name: string, value: boolean | number | string): BlockPermutation;
@@ -1398,79 +1590,139 @@ export class BlockType {
 
 /**
  * @beta
+ * Block Volume Utils is a utility class that provides a number
+ * of useful functions for the creation and utility of {@link
+ * @minecraft-server.BlockVolume} objects
  */
 export class BlockVolumeUtils {
     protected constructor();
     /**
      * @remarks
+     * Check to see if the given location is directly adjacent to
+     * the outer surface of a BlockVolume.
+     *
+     *
      * This function can't be called in read-only mode.
      *
+     * @param volume
+     * The volume to test against
+     * @param pos
+     * The world block location to test
+     * @returns
+     * If the location is either inside or more than 0 blocks away,
+     * the function will return false.
+     * If the location is directly contacting the outer surface of
+     * the BlockVolume, the function will return true.
      */
     static doesLocationTouchFaces(volume: BlockVolume, pos: Vector3): boolean;
     /**
      * @remarks
+     * Check to see if a two block volumes are directly adjacent
+     * and two faces touch.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param volume
+     * The volume to test against
+     * @param other
+     * The volume to test
+     * @returns
+     * If the outer faces of both block volumes touch and are
+     * directly adjacent at any point, return true.
      */
     static doesVolumeTouchFaces(volume: BlockVolume, other: BlockVolume): boolean;
     /**
      * @remarks
+     * Test the equality of two block volumes
+     *
      * This function can't be called in read-only mode.
      *
+     * @returns
+     * Return true if two block volumes are identical
      */
     static equals(volume: BlockVolume, other: BlockVolume): boolean;
     /**
      * @remarks
+     * Fetch a {@link BlockLocationIterator} that represents all of
+     * the block world locations within the specified volume
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getBlockLocationIterator(volume: BlockVolume): BlockLocationIterator;
     /**
      * @remarks
+     * Return a {@link BoundingBox} object which represents the
+     * validated min and max coordinates of the volume
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getBoundingBox(volume: BlockVolume): BoundingBox;
     /**
      * @remarks
+     * Return the capacity (volume) of the BlockVolume (W*D*H)
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getCapacity(volume: BlockVolume): number;
     /**
      * @remarks
+     * Get the largest corner position of the volume (guaranteed to
+     * be >= min)
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getMax(volume: BlockVolume): Vector3;
     /**
      * @remarks
+     * Get the smallest corner position of the volume (guaranteed
+     * to be <= max)
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getMin(volume: BlockVolume): Vector3;
     /**
      * @remarks
+     * Get a {@link Vector3} object where each component represents
+     * the number of blocks along that axis
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getSpan(volume: BlockVolume): Vector3;
     /**
      * @remarks
+     * Return an enumeration which represents the intersection
+     * between two BlockVolume objects
+     *
      * This function can't be called in read-only mode.
      *
      */
     static intersects(volume: BlockVolume, other: BlockVolume): BlockVolumeIntersection;
     /**
      * @remarks
+     * Check to see if a given world block location is inside a
+     * BlockVolume
+     *
      * This function can't be called in read-only mode.
      *
      */
     static isInside(volume: BlockVolume, pos: Vector3): number;
     /**
      * @remarks
+     * Move a BlockVolume by a specified amount
+     *
      * This function can't be called in read-only mode.
      *
+     * @param delta
+     * Amount of blocks to move by
+     * @returns
+     * Returns a new BlockVolume object which represents the new
+     * volume
      */
     static translate(volume: BlockVolume, delta: Vector3): BlockVolume;
 }
@@ -1520,41 +1772,86 @@ export class BlockWaterContainerComponent extends BlockLiquidContainerComponent
 
 /**
  * @beta
+ * Bounding Box Utils is a utility class that provides a number
+ * of useful functions for the creation and utility of {@link
+ * @minecraft-server.BoundingBox} objects
  */
 export class BoundingBoxUtils {
     protected constructor();
     /**
      * @remarks
+     * Create a validated instance of a {@link
+     * @minecraft-server.BoundingBox} 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): BoundingBox;
     /**
      * @remarks
+     * Expand a {@link @minecraft-server.BoundingBox} 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 @minecraft-server.BoundingBox} object
+     * representing the changes
      */
     static dilate(box: BoundingBox, size: Vector3): BoundingBox;
     /**
      * @remarks
+     * Check if two {@link @minecraft-server.BoundingBox} objects
+     * are identical
+     *
      * This function can't be called in read-only mode.
      *
      */
     static equals(box: BoundingBox, other: BoundingBox): boolean;
     /**
      * @remarks
+     * Expand the initial box object bounds to include the 2nd box
+     * argument.  The resultant {@link
+     * @minecraft-server.BoundingBox} object will be a BoundingBox
+     * which exactly encompasses the two boxes.
+     *
      * This function can't be called in read-only mode.
      *
+     * @returns
+     * A new {@link @minecraft-server.BoundingBox} instance
+     * representing the smallest possible bounding box which can
+     * encompass both
      */
     static expand(box: BoundingBox, other: BoundingBox): BoundingBox;
     /**
      * @remarks
+     * Calculate the center block of a given {@link
+     * @minecraft-server.BoundingBox} object.
+     *
      * This function can't be called in read-only mode.
      *
+     * @returns
+     * Note that {@link @minecraft-server.BoundingBox} objects
+     * represent whole blocks, so the center of boxes which have
+     * odd numbered bounds are not mathematically centered...
+     * i.e. a BoundingBox( 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: BoundingBox): Vector3;
     /**
      * @remarks
+     * Calculate the BoundingBox which represents the union area of
+     * two intersecting BoundingBoxes
+     *
      * This function can't be called in read-only mode.
      *
      * @throws This function can throw errors.
@@ -1562,32 +1859,44 @@ export class BoundingBoxUtils {
     static getIntersection(box: BoundingBox, other: BoundingBox): BoundingBox;
     /**
      * @remarks
+     * Get the Span of each of the BoundingBox Axis components
+     *
      * This function can't be called in read-only mode.
      *
      */
     static getSpan(box: BoundingBox): Vector3;
     /**
      * @remarks
+     * Check to see if two BoundingBox objects intersect
+     *
      * This function can't be called in read-only mode.
      *
      */
     static intersects(box: BoundingBox, other: BoundingBox): boolean;
     /**
      * @remarks
+     * Check to see if a given coordinate is inside a BoundingBox
+     *
      * This function can't be called in read-only mode.
      *
      */
     static isInside(box: BoundingBox, pos: Vector3): boolean;
     /**
      * @remarks
+     * Check to see if a BoundingBox is valid (i.e. (min <= max))
+     *
      * This function can't be called in read-only mode.
      *
      */
     static isValid(box: BoundingBox): boolean;
     /**
      * @remarks
+     * Move a BoundingBox by a given amount
+     *
      * This function can't be called in read-only mode.
      *
+     * @returns
+     * Return a new BoundingBox object which represents the change
      */
     static translate(box: BoundingBox, delta: Vector3): BoundingBox;
 }
@@ -1642,6 +1951,13 @@ export class ChatSendAfterEvent {
      *
      */
     sendToTargets: boolean;
+    /**
+     * @remarks
+     * List of players that will receive this message.
+     *
+     * @returns
+     * List of player objects.
+     */
     getTargets(): Player[];
 }
 
@@ -1667,6 +1983,14 @@ export class ChatSendBeforeEvent extends ChatSendAfterEvent {
      *
      */
     cancel: boolean;
+    /**
+     * @remarks
+     * Sets an updated list of players that will receive this
+     * message.
+     *
+     * @param players
+     * Updated array of players that should receive this message.
+     */
     setTargets(players: Player[]): void;
 }
 
@@ -1696,82 +2020,178 @@ export class CommandResult {
 
 /**
  * @beta
+ * Base class for downstream Component implementations.
  */
 export class Component {
     protected constructor();
+    /**
+     * @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)
  */
 export class CompoundBlockVolume {
+    /**
+     * @remarks
+     * Return the 'capacity' of the bounding rectangle which
+     * represents the collection of volumes in the stack
+     *
+     */
     readonly capacity: number;
+    /**
+     * @remarks
+     * Return the number of volumes (positive and negative) in the
+     * volume stack
+     *
+     */
     readonly volumeCount: number;
     /**
      * @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)
+     *
+     *
      * 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
+     *
      * This function can't be called in read-only mode.
      *
      */
     getBoundingBox(): BoundingBox;
     /**
      * @remarks
+     * Get the max block location of the outermost bounding
+     * rectangle which represents the volumes on the stack
+     *
      * 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
+     *
      * This function can't be called in read-only mode.
      *
      */
     getMin(): Vector3;
     /**
      * @remarks
+     * Return a boolean representing whether or not a given 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.
      *
+     * @param delta
+     * block location to test
      */
     isInside(delta: 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.
      *
+     * @returns
+     * Returns undefined if the stack is empty
      */
     peekLastVolume(): CompoundBlockVolumeItem | undefined;
     /**
      * @remarks
+     * Remove the last entry from the volume stack.  This will
+     * reduce the stack size by one
+     *
      * This function can't be called in read-only mode.
      *
      */
     popVolume(): boolean;
     /**
      * @remarks
+     * Push a volume item to the stack.  The volume item contains
+     * an 'action' parameter which determines whether this volume
+     * is a positive or negative space
+     *
      * This function can't be called in read-only mode.
      *
+     * @param item
+     * Item to push to the end of the stack
      */
     pushVolume(item: CompoundBlockVolumeItem): void;
     /**
      * @remarks
+     * If the volume stack is empty, this function will push the
+     * specified item to the stack.
+     * If the volume stack is NOT empty, this function will replace
+     * the last item on the stack with the new item.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param item
+     * Item to add or replace
      */
     replaceOrAddLastVolume(item: CompoundBlockVolumeItem): boolean;
     /**
      * @remarks
+     * Move the root block location of the volume by a given
+     * amount.  This effectively adds the specified delta to the
+     * block location of all of the volumes in the stack
+     *
      * This function can't be called in read-only mode.
      *
+     * @param delta
+     * Amount to move
      */
     translate(delta: Vector3): void;
 }
@@ -1990,6 +2410,13 @@ export class ContainerSlot {
      * Throws if the slot's container is invalid.
      */
     readonly isStackable: boolean;
+    /**
+     * @remarks
+     * Returns whether the ContainerSlot is valid. The container
+     * slot is valid if the container exists and is loaded, and the
+     * slot index is valid.
+     *
+     */
     readonly isValid: boolean;
     /**
      * @remarks
@@ -2060,10 +2487,23 @@ export class ContainerSlot {
      *
      * This function can't be called in read-only mode.
      *
+     * @returns
+     * Returns a copy of the item in the slot. Returns undefined if
+     * the slot is empty.
      * @throws
      * Throws if the slot's container is invalid.
      */
     clone(): ItemStack;
+    /**
+     * @remarks
+     * Creates an exact copy of the item stack, including any
+     * custom data or properties.
+     *
+     * @returns
+     * Returns a copy of the item in the slot. Returns undefined if
+     * the slot is empty.
+     * @throws This function can throw errors.
+     */
     getItem(): ItemStack | undefined;
     /**
      * @remarks
@@ -2077,7 +2517,27 @@ export class ContainerSlot {
      * Throws if the slot's container is invalid.
      */
     getLore(): string[];
+    /**
+     * @remarks
+     * Returns all tags for the item in the slot.
+     *
+     * @returns
+     * Returns all tags for the item in the slot. Return an empty
+     * array if the the slot is empty.
+     * @throws This function can throw errors.
+     */
     getTags(): string[];
+    /**
+     * @remarks
+     * Returns whether the item in the slot slot has the given tag.
+     *
+     * @param tag
+     * The item tag.
+     * @returns
+     * Returns false when the slot is empty or the item in the slot
+     * does not have the given tag.
+     * @throws This function can throw errors.
+     */
     hasTag(tag: string): boolean;
     /**
      * @remarks
@@ -2087,6 +2547,11 @@ export class ContainerSlot {
      * item stacks. The amount of each item stack is not taken into
      * consideration.
      *
+     * @param itemStack
+     * The ItemStack that is being compared.
+     * @returns
+     * Returns whether this item stack can be stacked with the
+     * given `itemStack`.
      * @throws
      * Throws if the slot's container is invalid.
      */
@@ -2099,6 +2564,8 @@ export class ContainerSlot {
      *
      * This function can't be called in read-only mode.
      *
+     * @param blockIdentifiers
+     * The list of blocks, given by their identifiers.
      * @throws
      * Throws if the slot's container is invalid. Also throws if
      * any of the provided block identifiers are invalid.
@@ -2113,6 +2580,8 @@ export class ContainerSlot {
      *
      * This function can't be called in read-only mode.
      *
+     * @param blockIdentifiers
+     * The list of blocks, given by their identifiers.
      * @throws
      * Throws if the slot's container is invalid. Also throws if
      * any of the provided block identifiers are invalid.
@@ -2120,8 +2589,13 @@ export class ContainerSlot {
     setCanPlaceOn(blockIdentifiers?: string[]): void;
     /**
      * @remarks
+     * Sets the given ItemStack in the slot, replacing any existing
+     * item.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param itemStack
+     * The ItemStack to be placed in the slot.
      * @throws This function can throw errors.
      */
     setItem(itemStack?: ItemStack): void;
@@ -2132,6 +2606,9 @@ export class ContainerSlot {
      *
      * This function can't be called in read-only mode.
      *
+     * @param loreList
+     * A list of lore strings. Setting this argument to undefined
+     * will clear the lore.
      * @throws
      * Throws if the slot's container is invalid.
      */
@@ -2160,6 +2637,9 @@ export class DataDrivenEntityTriggerAfterEvent {
     readonly id: string;
     /**
      * @remarks
+     * An updateable list of modifications to component state that
+     * are the effect of this triggered event.
+     *
      * This function can't be called in read-only mode.
      *
      */
@@ -2202,7 +2682,21 @@ export class DataDrivenEntityTriggerBeforeEvent {
      *
      */
     readonly id: string;
+    /**
+     * @remarks
+     * An updateable list of modifications to component state that
+     * are the effect of this triggered event.
+     *
+     */
     getModifiers(): DefinitionModifier[];
+    /**
+     * @remarks
+     * Changes a list of modifications to component state that are
+     * the effect of this triggered event.
+     *
+     * @param modifiers
+     * An updated list of modifications to component state.
+     */
     setModifiers(modifiers: DefinitionModifier[]): void;
 }
 
@@ -2360,8 +2854,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.
@@ -2376,6 +2869,10 @@ export class Dimension {
      * Gets the first block that intersects with a vector emanating
      * from a location.
      *
+     * @param location
+     * Location from where to initiate the ray check.
+     * @param direction
+     * Vector direction to cast the ray.
      * @param options
      * Additional options for processing this raycast query.
      * @throws This function can throw errors.
@@ -2652,11 +3149,20 @@ export class Effect {
     /**
      * @remarks
      * Gets the entire specified duration, in ticks, of this
-     * effect.
+     * effect. There are 20 ticks per second. Use {@link
+     * TicksPerSecond} constant to convert between ticks and
+     * seconds.
      *
      * @throws This property can throw when used.
      */
     readonly duration: number;
+    /**
+     * @remarks
+     * Gets the type id of this effect.
+     *
+     * @throws This property can throw when used.
+     */
+    readonly typeId: string;
 }
 
 /**
@@ -2718,6 +3224,36 @@ export class EffectType {
     getName(): string;
 }
 
+/**
+ * @beta
+ * Represents a type of effect - like poison - that can be
+ * applied to an entity.
+ */
+export class EffectTypes {
+    protected constructor();
+    /**
+     * @remarks
+     * Effect type for the given identifier.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * Effect type for the given identifier or undefined if the
+     * effect does not exist.
+     */
+    static get(identifier: string): EffectType | undefined;
+    /**
+     * @remarks
+     * Gets all effects.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @returns
+     * A list of all effects.
+     */
+    static getAll(): EffectType[];
+}
+
 /**
  * @beta
  * This class represents a specific leveled enchantment that is
@@ -2887,7 +3423,18 @@ export class EnchantmentType {
  */
 export class EnchantmentTypes {
     protected constructor();
-    static get(enchantmentId: string): EnchantmentType;
+    /**
+     * @remarks
+     * Retrieves an enchantment with the specified identifier.
+     *
+     * @param enchantmentId
+     * Identifier of the enchantment.  For example,
+     * "minecraft:flame".
+     * @returns
+     * If available, returns an EnchantmentType object that
+     * represents the specified enchantment.
+     */
+    static get(enchantmentId: string): EnchantmentType | undefined;
 }
 
 /**
@@ -2926,6 +3473,12 @@ export class Entity {
     isSneaking: boolean;
     /**
      * @beta
+     * @remarks
+     * Whether the entity reference that you have is valid or not.
+     * For example, an entity may be unloaded if it moves into a
+     * chunk that is unloaded, but may be reactivated if the chunk
+     * it is within gets reloaded.
+     *
      */
     readonly lifetimeState: EntityLifetimeState;
     /**
@@ -2980,44 +3533,49 @@ export class Entity {
      * @param effectType
      * Type of effect to add to the entity.
      * @param duration
-     * Amount of time, in ticks, for the effect to apply.
-     * @param amplifier
-     * Optional amplification of the effect to apply.
+     * Amount of time, in ticks, for the effect to apply. There are
+     * 20 ticks per second. Use {@link TicksPerSecond} constant to
+     * convert between ticks and seconds. The value must be within
+     * the range [0, 20000000].
+     * @param options
+     * Additional options for the effect.
+     * @returns
+     * Returns true if the effect was added successfully. This can
+     * fail if the duration or amplifier are outside of the valid
+     * ranges.
      * @throws This function can throw errors.
      * @example addEffect.js
      * ```typescript
-     *        const villagerId = "minecraft:villager_v2<minecraft:ageable_grow_up>";
+     *        const villagerId = 'minecraft:villager_v2<minecraft:ageable_grow_up>';
      *        const villagerLoc: mc.Vector3 = { x: 1, y: 2, z: 1 };
      *        const villager = test.spawn(villagerId, villagerLoc);
      *        const duration = 20;
      *
-     *        villager.addEffect(MinecraftEffectTypes.poison, duration, 1);
-     *
+     *        villager.addEffect(EffectTypes.get('poison'), duration, { amplifier: 1 });
      *
      * ```
      * @example quickFoxLazyDog.ts
      * ```typescript
-     *        const fox = overworld.spawnEntity("minecraft:fox", {
-     *          x: targetLocation.x + 1,
-     *          y: targetLocation.y + 2,
-     *          z: targetLocation.z + 3,
+     *        const fox = overworld.spawnEntity('minecraft:fox', {
+     *            x: targetLocation.x + 1,
+     *            y: targetLocation.y + 2,
+     *            z: targetLocation.z + 3,
      *        });
-     *        fox.addEffect(mc.MinecraftEffectTypes.speed, 10, 20);
-     *        log("Created a fox.");
+     *        fox.addEffect(mc.MinecraftEffectTypes.speed, 10, { amplifier: 20 });
+     *        log('Created a fox.');
      *
-     *        const wolf = overworld.spawnEntity("minecraft:wolf", {
-     *          x: targetLocation.x + 4,
-     *          y: targetLocation.y + 2,
-     *          z: targetLocation.z + 3,
+     *        const wolf = overworld.spawnEntity('minecraft:wolf', {
+     *            x: targetLocation.x + 4,
+     *            y: targetLocation.y + 2,
+     *            z: targetLocation.z + 3,
      *        });
-     *        wolf.addEffect(mc.MinecraftEffectTypes.slowness, 10, 20);
+     *        wolf.addEffect(mc.MinecraftEffectTypes.slowness, 10, { amplifier: 20 });
      *        wolf.isSneaking = true;
-     *        log("Created a sneaking wolf.", 1);
-     *
+     *        log('Created a sneaking wolf.', 1);
      *
      * ```
      */
-    addEffect(effectType: EffectType, duration: number, amplifier?: number, showParticles?: boolean): void;
+    addEffect(effectType: EffectType | string, duration: number, options?: EntityEffectOptions): boolean;
     /**
      * @beta
      * @remarks
@@ -3027,6 +3585,9 @@ export class Entity {
      *
      * @param tag
      * Content of the tag to add.
+     * @returns
+     * Returns true if the tag was added successfully. This can
+     * fail if the tag already exists on the entity.
      * @throws This function can throw errors.
      */
     addTag(tag: string): boolean;
@@ -3043,6 +3604,10 @@ export class Entity {
      * Additional options about the source of damage, which may add
      * additional effects or spur additional behaviors on this
      * entity.
+     * @returns
+     * Whether the entity takes any damage. This can return false
+     * if the entity is invulnerable or if the damage applied is
+     * less than or equal to 0.
      * @throws This function can throw errors.
      */
     applyDamage(amount: number, options?: EntityApplyDamageByProjectileOptions | EntityApplyDamageOptions): boolean;
@@ -3101,6 +3666,8 @@ export class Entity {
      * @param useEffects
      * Whether to show any visual effects connected to the
      * extinguishing.
+     * @returns
+     * Returns whether the entity was on fire.
      * @throws This function can throw errors.
      */
     extinguishFire(useEffects?: boolean): boolean;
@@ -3110,6 +3677,11 @@ export class Entity {
      * Returns the first intersecting block from the direction that
      * this entity is looking at.
      *
+     * @param options
+     * Additional configuration options for the ray cast.
+     * @returns
+     * Returns the first intersecting block from the direction that
+     * this entity is looking at.
      * @throws This function can throw errors.
      */
     getBlockFromViewDirection(options?: BlockRaycastOptions): Block;
@@ -3124,14 +3696,20 @@ export class Entity {
      * to retrieve. If no namespace prefix is specified,
      * 'minecraft:' is assumed. If the component is not present on
      * the entity, undefined is returned.
+     * @returns
+     * Returns the component if it exists on the entity, otherwise
+     * undefined.
      */
-    getComponent(componentId: string): EntityComponent;
+    getComponent(componentId: string): EntityComponent | undefined;
     /**
      * @beta
      * @remarks
      * Returns all components that are both present on this entity
      * and supported by the API.
      *
+     * @returns
+     * Returns all components that are both present on this entity
+     * and supported by the API.
      */
     getComponents(): EntityComponent[];
     /**
@@ -3139,6 +3717,8 @@ export class Entity {
      * @remarks
      * Returns a property value.
      *
+     * @param identifier
+     * The property identifier.
      * @returns
      * Returns the value for the property, or undefined if the
      * property has not been set.
@@ -3151,16 +3731,18 @@ export class Entity {
      * Returns the effect for the specified EffectType on the
      * entity, or undefined if the effect is not present.
      *
+     * @param effectType
+     * The effect identifier.
      * @returns
      * Effect object for the specified effect, or undefined if the
      * effect is not present.
      * @throws This function can throw errors.
      */
-    getEffect(effectType: EffectType): Effect;
+    getEffect(effectType: EffectType | string): Effect | undefined;
     /**
      * @beta
      * @remarks
-     * Returns a set of effects applied to this item.
+     * Returns a set of effects applied to this entity.
      *
      * @returns
      * List of effects.
@@ -3170,9 +3752,14 @@ export class Entity {
     /**
      * @beta
      * @remarks
-     * Returns a potential set of entities from the direction that
-     * this entity is looking at.
+     * Gets the entities that this entity is looking at by
+     * performing a ray cast from the view of this entity.
      *
+     * @param options
+     * Additional configuration options for the ray cast.
+     * @returns
+     * Returns a set of entities from the direction that this
+     * entity is looking at.
      * @throws This function can throw errors.
      */
     getEntitiesFromViewDirection(options?: EntityRaycastOptions): Entity[];
@@ -3182,6 +3769,9 @@ export class Entity {
      * Returns the current location of the head component of this
      * entity.
      *
+     * @returns
+     * Returns the current location of the head component of this
+     * entity.
      * @throws This function can throw errors.
      */
     getHeadLocation(): Vector3;
@@ -3190,6 +3780,8 @@ export class Entity {
      * @remarks
      * Returns the current rotation component of this entity.
      *
+     * @returns
+     * Returns the current rotation component of this entity.
      * @throws This function can throw errors.
      */
     getRotation(): Vector2;
@@ -3198,6 +3790,8 @@ export class Entity {
      * @remarks
      * Returns all tags associated with an entity.
      *
+     * @returns
+     * Returns the current rotation component of this entity.
      * @throws This function can throw errors.
      */
     getTags(): string[];
@@ -3206,6 +3800,8 @@ export class Entity {
      * @remarks
      * Returns the current velocity vector of the entity.
      *
+     * @returns
+     * Returns the current velocity vector of the entity.
      * @throws This function can throw errors.
      */
     getVelocity(): Vector3;
@@ -3214,6 +3810,8 @@ export class Entity {
      * @remarks
      * Returns the current view direction of the entity.
      *
+     * @returns
+     * Returns the current view direction of the entity.
      * @throws This function can throw errors.
      */
     getViewDirection(): Vector3;
@@ -3227,15 +3825,20 @@ export class Entity {
      * The identifier of the component (e.g., 'minecraft:rideable')
      * to retrieve. If no namespace prefix is specified,
      * 'minecraft:' is assumed.
+     * @returns
+     * Returns true if the specified component is present on this
+     * entity.
      */
     hasComponent(componentId: string): boolean;
     /**
      * @beta
      * @remarks
-     * Tests whether an entity has a particular tag.
+     * Returns whether an entity has a particular tag.
      *
      * @param tag
      * Identifier of the tag to test for.
+     * @returns
+     * Returns whether an entity has a particular tag.
      * @throws This function can throw errors.
      */
     hasTag(tag: string): boolean;
@@ -3255,8 +3858,15 @@ export class Entity {
     /**
      * @beta
      * @remarks
+     * Cause the entity to play the given animation.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param animationName
+     * The animation identifier. e.g. animation.creeper.swelling
+     * @param options
+     * Additional options to control the playback and transitions
+     * of the animation.
      * @throws This function can throw errors.
      */
     playAnimation(animationName: string, options?: PlayAnimationOptions): void;
@@ -3265,9 +3875,29 @@ export class Entity {
      * @remarks
      * Removes a specified property.
      *
+     * @param identifier
+     * The property identifier.
+     * @returns
+     * Returns whether the given property existed on the entity.
      * @throws This function can throw errors.
      */
     removeDynamicProperty(identifier: string): boolean;
+    /**
+     * @beta
+     * @remarks
+     * Removes the specified EffectType on the entity, or returns
+     * false if the effect is not present.
+     *
+     * This function can't be called in read-only mode.
+     *
+     * @param effectType
+     * The effect identifier.
+     * @returns
+     * Returns true if the effect has been removed and false if the
+     * effect is not present.
+     * @throws This function can throw errors.
+     */
+    removeEffect(effectType: EffectType | string): boolean;
     /**
      * @beta
      * @remarks
@@ -3277,14 +3907,24 @@ export class Entity {
      *
      * @param tag
      * Content of the tag to remove.
+     * @returns
+     * Returns whether the tag existed on the entity.
      * @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.
      *
+     * @param commandString
+     * The command string. Note: This should not include a leading
+     * forward slash.
+     * @returns
+     * A command result containing whether the command was
+     * successful.
      * @throws This function can throw errors.
      */
     runCommand(commandString: string): CommandResult;
@@ -3308,6 +3948,8 @@ export class Entity {
      * @remarks
      * Sets a specified property to a value.
      *
+     * @param identifier
+     * The property identifier.
      * @param value
      * Data value of the property to set.
      * @throws This function can throw errors.
@@ -3324,6 +3966,14 @@ export class Entity {
      *
      * @param seconds
      * Length of time to set the entity on fire.
+     * @param useEffects
+     * Whether side-effects should be applied (e.g. thawing freeze)
+     * and other conditions such as rain or fire protection should
+     * be taken into consideration.
+     * @returns
+     * Whether the entity was set on fire. This can fail if seconds
+     * is less than or equal to zero, the entity is wet or the
+     * entity is immune to fire.
      * @throws This function can throw errors.
      */
     setOnFire(seconds: number, useEffects?: boolean): boolean;
@@ -3334,6 +3984,10 @@ export class Entity {
      *
      * This function can't be called in read-only mode.
      *
+     * @param rotation
+     * The x and y rotation of the entity. For most mobs, the x
+     * rotation controls the head tilt and the y rotation controls
+     * the body rotation.
      * @throws This function can throw errors.
      */
     setRotation(rotation: Vector2): void;
@@ -3346,6 +4000,8 @@ export class Entity {
      *
      * @param location
      * New location for the entity.
+     * @param teleportOptions
+     * Options regarding the teleport operation.
      * @throws This function can throw errors.
      */
     teleport(location: Vector3, teleportOptions?: TeleportOptions): void;
@@ -3368,8 +4024,20 @@ export class Entity {
     /**
      * @beta
      * @remarks
+     * Attempts to try a teleport, but may not complete the
+     * teleport operation (for example, if there are blocks at the
+     * destination.)
+     *
      * This function can't be called in read-only mode.
      *
+     * @param location
+     * Location to teleport the entity to.
+     * @param teleportOptions
+     * Options regarding the teleport operation.
+     * @returns
+     * Returns whether the teleport succeeded. This can fail if the
+     * destination chunk is unloaded or if the teleport would
+     * result in intersecting with blocks.
      * @throws This function can throw errors.
      */
     tryTeleport(location: Vector3, teleportOptions?: TeleportOptions): boolean;
@@ -3656,8 +4324,6 @@ export class EntityColorComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The palette color value of the entity.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -3678,6 +4344,7 @@ export class EntityColorComponent extends EntityComponent {
 export class EntityComponent extends Component {
     protected constructor();
     /**
+     * @beta
      * @remarks
      * The entity that owns this component.
      *
@@ -3728,28 +4395,51 @@ export class EntityDieAfterEventSignal extends IEntityDieAfterEventSignal {
 
 /**
  * @beta
+ * Provides access to a mob's equipment slots. This component
+ * exists for all mob entities.
  */
 export class EntityEquipmentInventoryComponent extends EntityComponent {
     protected constructor();
     static readonly componentId = 'minecraft:equipment_inventory';
     /**
      * @remarks
+     * Gets the equipped item for the given EquipmentSlot.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param equipmentSlot
+     * The equipment slot. e.g. "head", "chest", "offhand"
+     * @returns
+     * Returns the item equipped to the given EquipmentSlot. If
+     * empty, returns undefined.
      * @throws This function can throw errors.
      */
     getEquipment(equipmentSlot: EquipmentSlot): ItemStack | undefined;
     /**
      * @remarks
+     * Gets the ContainerSlot corresponding to the given
+     * EquipmentSlot.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param equipmentSlot
+     * The equipment slot. e.g. "head", "chest", "offhand".
+     * @returns
+     * Returns the ContainerSlot corresponding to the given
+     * EquipmentSlot.
      * @throws This function can throw errors.
      */
     getEquipmentSlot(equipmentSlot: EquipmentSlot): ContainerSlot;
     /**
      * @remarks
+     * Replaces the item in the given EquipmentSlot.
+     *
      * This function can't be called in read-only mode.
      *
+     * @param equipmentSlot
+     * The equipment slot. e.g. "head", "chest", "offhand".
+     * @param itemStack
+     * The item to equip. If undefined, clears the slot.
      * @throws This function can throw errors.
      */
     setEquipment(equipmentSlot: EquipmentSlot, itemStack?: ItemStack): void;
@@ -3795,8 +4485,6 @@ export class EntityFlyingSpeedComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * Speed while flying value of the entity.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -3818,10 +4506,6 @@ export class EntityFrictionModifierComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The higher the number, the more the friction affects this
-     * entity. A value of 1.0 means regular friction, while 2.0
-     * means twice as much.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -3844,9 +4528,6 @@ export class EntityGroundOffsetComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The value of the entity's offset from the terrain, in
-     * blocks.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -3892,6 +4573,8 @@ export class EntityHealableComponent extends EntityComponent {
      * @remarks
      * A set of items that can specifically heal this entity.
      *
+     * @returns
+     * Entity that this component is associated with.
      * @throws This function can throw errors.
      */
     getFeedItems(): FeedItem[];
@@ -4050,7 +4733,6 @@ export class EntityInventoryComponent extends EntityComponent {
      */
     readonly restrictToOwner: boolean;
     /**
-     * @beta
      * @remarks
      * Identifier of this component. Should always be
      * minecraft:inventory.
@@ -4112,7 +4794,7 @@ export class EntityIsChestedComponent extends EntityComponent {
  * When added, this component signifies that dyes can be used
  * on this entity to change its color.
  */
-export class EntityIsDyableComponent extends EntityComponent {
+export class EntityIsDyeableComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
@@ -4284,7 +4966,6 @@ export class EntityItemComponent extends EntityComponent {
      */
     readonly itemStack: ItemStack;
     /**
-     * @beta
      * @remarks
      * Identifier of this component.
      *
@@ -4387,9 +5068,6 @@ export class EntityMarkVariantComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The identifier of the variant. By convention, 0 is the
-     * identifier of the base entity.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -4435,15 +5113,8 @@ export class EntityMountTamingComponent extends EntityComponent {
  * When added, this movement control allows the mob to swim in
  * water and walk on land.
  */
-export class EntityMovementAmphibiousComponent extends EntityComponent {
+export class EntityMovementAmphibiousComponent extends EntityBaseMovementComponent {
     protected constructor();
-    /**
-     * @remarks
-     * The maximum number in degrees the mob can turn per tick.
-     *
-     * @throws This property can throw when used.
-     */
-    readonly maxTurn: number;
     /**
      * @remarks
      * Identifier of this component. Should always be
@@ -4457,15 +5128,8 @@ export class EntityMovementAmphibiousComponent extends EntityComponent {
  * @beta
  * This component accents the movement of an entity.
  */
-export class EntityMovementBasicComponent extends EntityComponent {
+export class EntityMovementBasicComponent extends EntityBaseMovementComponent {
     protected constructor();
-    /**
-     * @remarks
-     * The maximum number in degrees the mob can turn per tick.
-     *
-     * @throws This property can throw when used.
-     */
-    readonly maxTurn: number;
     /**
      * @remarks
      * Identifier of this component. Should always be
@@ -4905,8 +5569,6 @@ export class EntityPushThroughComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The value of the entity's push-through, in blocks.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -4920,6 +5582,21 @@ export class EntityPushThroughComponent extends EntityComponent {
     static readonly componentId = 'minecraft:push_through';
 }
 
+/**
+ * @beta
+ */
+export class EntityRemovedAfterEvent {
+    protected constructor();
+    readonly removedEntity: string;
+}
+
+/**
+ * @beta
+ */
+export class EntityRemovedAfterEventSignal extends IEntityRemovedAfterEventSignal {
+    protected constructor();
+}
+
 /**
  * @beta
  * When added, this component adds the capability that an
@@ -5072,10 +5749,6 @@ export class EntityScaleComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The value of the scale. 1.0 means the entity will appear at
-     * the scale they are defined in their model. Higher numbers
-     * make the entity bigger.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -5098,9 +5771,6 @@ export class EntitySkinIdComponent extends EntityComponent {
     protected constructor();
     /**
      * @remarks
-     * The identifier of the skin. By convention, 0 is the
-     * identifier of the base skin.
-     *
      * This property can't be edited in read-only mode.
      *
      */
@@ -5153,14 +5823,7 @@ export class EntityStrengthComponent extends EntityComponent {
      *
      * @throws This property can throw when used.
      */
-    readonly max: number;
-    /**
-     * @remarks
-     * Current strength value of this entity, after any effects or
-     * component updates are applied.
-     *
-     * @throws This property can throw when used.
-     */
+    readonly max: number;
     readonly value: number;
     /**
      * @remarks
@@ -5291,13 +5954,6 @@ export class EntityUnderwaterMovementComponent extends EntityAttributeComponent
  */
 export class EntityVariantComponent extends EntityComponent {
     protected constructor();
-    /**
-     * @remarks
-     * The identifier of the variant. By convention, 0 is the
-     * identifier of the base entity.
-     *
-     * @throws This property can throw when used.
-     */
     readonly value: number;
     /**
      * @remarks
@@ -5343,6 +5999,11 @@ export class ExplosionAfterEvent {
      *
      */
     readonly source?: Entity;
+    /**
+     * @remarks
+     * A collection of blocks impacted by this explosion event.
+     *
+     */
     getImpactedBlocks(): Vector3[];
 }
 
@@ -5368,6 +6029,14 @@ export class ExplosionBeforeEvent extends ExplosionAfterEvent {
      *
      */
     cancel: boolean;
+    /**
+     * @remarks
+     * Updates a collection of blocks impacted by this explosion
+     * event.
+     *
+     * @param blocks
+     * New list of blocks that are impacted by this explosion.
+     */
     setImpactedBlocks(blocks: Vector3[]): void;
 }
 
@@ -5481,6 +6150,8 @@ export class FluidContainer {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when blocks are broken.
  */
 export class IBlockBreakAfterEventSignal {
     protected constructor();
@@ -5501,6 +6172,8 @@ export class IBlockBreakAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an explosion occurs.
  */
 export class IBlockExplodeAfterEventSignal {
     protected constructor();
@@ -5521,6 +6194,8 @@ export class IBlockExplodeAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a block is placed.
  */
 export class IBlockPlaceAfterEventSignal {
     protected constructor();
@@ -5541,6 +6216,8 @@ export class IBlockPlaceAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when a button is pushed.
  */
 export class IButtonPushAfterEventSignal {
     protected constructor();
@@ -5561,6 +6238,8 @@ export class IButtonPushAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when a chat message is sent.
  */
 export class IChatSendAfterEventSignal {
     protected constructor();
@@ -5581,6 +6260,8 @@ export class IChatSendAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before a chat message is sent.
  */
 export class IChatSendBeforeEventSignal {
     protected constructor();
@@ -5601,6 +6282,9 @@ export class IChatSendBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an entities' definition is
+ * triggered to change.
  */
 export class IDataDrivenEntityTriggerAfterEventSignal {
     protected constructor();
@@ -5624,6 +6308,9 @@ export class IDataDrivenEntityTriggerAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before an entities' definition is
+ * scheduled to change via a triggered event.
  */
 export class IDataDrivenEntityTriggerBeforeEventSignal {
     protected constructor();
@@ -5647,6 +6334,8 @@ export class IDataDrivenEntityTriggerBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an effect is added to an entity.
  */
 export class IEffectAddAfterEventSignal {
     protected constructor();
@@ -5670,6 +6359,8 @@ export class IEffectAddAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an entity dies.
  */
 export class IEntityDieAfterEventSignal {
     protected constructor();
@@ -5693,6 +6384,9 @@ export class IEntityDieAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an entity hits (melee attacks)
+ * another entity.
  */
 export class IEntityHitAfterEventSignal {
     protected constructor();
@@ -5716,6 +6410,8 @@ export class IEntityHitAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an entity is hurt.
  */
 export class IEntityHurtAfterEventSignal {
     protected constructor();
@@ -5740,6 +6436,31 @@ export class IEntityHurtAfterEventSignal {
 /**
  * @beta
  */
+export class IEntityRemovedAfterEventSignal {
+    protected constructor();
+    /**
+     * @remarks
+     * This function can't be called in read-only mode.
+     *
+     */
+    subscribe(
+        callback: (arg: EntityRemovedAfterEvent) => void,
+        options?: EntityEventOptions,
+    ): (arg: EntityRemovedAfterEvent) => void;
+    /**
+     * @remarks
+     * This function can't be called in read-only mode.
+     *
+     * @throws This function can throw errors.
+     */
+    unsubscribe(callback: (arg: EntityRemovedAfterEvent) => void): void;
+}
+
+/**
+ * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an entity is spawned.
+ */
 export class IEntitySpawnAfterEventSignal {
     protected constructor();
     /**
@@ -5759,6 +6480,8 @@ export class IEntitySpawnAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an explosion occurs.
  */
 export class IExplosionAfterEventSignal {
     protected constructor();
@@ -5779,6 +6502,8 @@ export class IExplosionAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before an explosion begins.
  */
 export class IExplosionBeforeEventSignal {
     protected constructor();
@@ -5799,6 +6524,8 @@ export class IExplosionBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an item has completed charging.
  */
 export class IItemCompleteChargeAfterEventSignal {
     protected constructor();
@@ -5819,6 +6546,8 @@ export class IItemCompleteChargeAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an items' definition has changed.
  */
 export class IItemDefinitionAfterEventSignal {
     protected constructor();
@@ -5841,6 +6570,8 @@ export class IItemDefinitionAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before an items' definition changes.
  */
 export class IItemDefinitionBeforeEventSignal {
     protected constructor();
@@ -5863,6 +6594,8 @@ export class IItemDefinitionBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a charged item is released.
  */
 export class IItemReleaseChargeAfterEventSignal {
     protected constructor();
@@ -5883,6 +6616,8 @@ export class IItemReleaseChargeAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when a chargeable item starts charging.
  */
 export class IItemStartChargeAfterEventSignal {
     protected constructor();
@@ -5903,6 +6638,9 @@ export class IItemStartChargeAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an item item is starting to be used
+ * on a block.
  */
 export class IItemStartUseOnAfterEventSignal {
     protected constructor();
@@ -5923,6 +6661,8 @@ export class IItemStartUseOnAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an item stops charging.
  */
 export class IItemStopChargeAfterEventSignal {
     protected constructor();
@@ -5943,6 +6683,9 @@ export class IItemStopChargeAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when an item has stopped being used on a
+ * block.
  */
 export class IItemStopUseOnAfterEventSignal {
     protected constructor();
@@ -5963,6 +6706,8 @@ export class IItemStopUseOnAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an item is used.
  */
 export class IItemUseAfterEventSignal {
     protected constructor();
@@ -5983,6 +6728,8 @@ export class IItemUseAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before an item is used.
  */
 export class IItemUseBeforeEventSignal {
     protected constructor();
@@ -6003,6 +6750,8 @@ export class IItemUseBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after an item is used on a block.
  */
 export class IItemUseOnAfterEventSignal {
     protected constructor();
@@ -6023,6 +6772,8 @@ export class IItemUseOnAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before an item is being used on a block.
  */
 export class IItemUseOnBeforeEventSignal {
     protected constructor();
@@ -6043,6 +6794,8 @@ export class IItemUseOnBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a lever is used.
  */
 export class ILeverActionAfterEventSignal {
     protected constructor();
@@ -6063,6 +6816,8 @@ export class ILeverActionAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a piston is activated.
  */
 export class IPistonActivateAfterEventSignal {
     protected constructor();
@@ -6083,6 +6838,8 @@ export class IPistonActivateAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires before a piston is activated.
  */
 export class IPistonActivateBeforeEventSignal {
     protected constructor();
@@ -6103,6 +6860,8 @@ export class IPistonActivateBeforeEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a player joins a world.
  */
 export class IPlayerJoinAfterEventSignal {
     protected constructor();
@@ -6123,6 +6882,8 @@ export class IPlayerJoinAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a player leaves a world.
  */
 export class IPlayerLeaveAfterEventSignal {
     protected constructor();
@@ -6143,6 +6904,8 @@ export class IPlayerLeaveAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a player spawns.
  */
 export class IPlayerSpawnAfterEventSignal {
     protected constructor();
@@ -6163,6 +6926,8 @@ export class IPlayerSpawnAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a projectile hits a target.
  */
 export class IProjectileHitAfterEventSignal {
     protected constructor();
@@ -6183,6 +6948,8 @@ export class IProjectileHitAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires when /script event command is called.
  */
 export class IScriptEventCommandMessageAfterEventSignal {
     protected constructor();
@@ -6206,6 +6973,9 @@ export class IScriptEventCommandMessageAfterEventSignal {
 
 /**
  * @beta
+ * Provides an adaptable interface for callers to subscribe to
+ * an event that fires after a server message is sent. Note
+ * that this event is for internal use only.
  */
 export class IServerMessageAfterEventSignal {
     protected constructor();
@@ -6226,36 +6996,16 @@ export class IServerMessageAfterEventSignal {
 
 /**
  * @beta
- * Contains information related to a chargeable item completing
- * being charged.
  */
 export class ItemCompleteChargeAfterEvent {
     protected constructor();
-    /**
-     * @remarks
-     * Returns the item stack that has completed charging.
-     *
-     */
     readonly itemStack: ItemStack;
-    /**
-     * @remarks
-     * Returns the source entity that triggered this item event.
-     *
-     */
     readonly source: Entity;
-    /**
-     * @remarks
-     * Returns the time, in ticks, for the remaining duration left
-     * before the charge completes its cycle.
-     *
-     */
     readonly useDuration: number;
 }
 
 /**
  * @beta
- * Manages callbacks that are connected to the completion of
- * charging for a chargeable item.
  */
 export class ItemCompleteChargeAfterEventSignal extends IItemCompleteChargeAfterEventSignal {
     protected constructor();
@@ -6510,37 +7260,16 @@ export class ItemFoodComponent extends ItemComponent {
 
 /**
  * @beta
- * Contains information related to a chargeable item when the
- * player has finished using the item and released the build
- * action.
  */
 export class ItemReleaseChargeAfterEvent {
     protected constructor();
-    /**
-     * @remarks
-     * Returns the item stack that triggered this item event.
-     *
-     */
     readonly itemStack: ItemStack;
-    /**
-     * @remarks
-     * Returns the source entity that triggered this item event.
-     *
-     */
     readonly source: Entity;
-    /**
-     * @remarks
-     * Returns the time, in ticks, for the remaining duration left
-     * before the charge completes its cycle.
-     *
-     */
     readonly useDuration: number;
 }
 
 /**
  * @beta
- * Manages callbacks that are connected to the releasing of
- * charging for a chargeable item.
  */
 export class ItemReleaseChargeAfterEventSignal extends IItemReleaseChargeAfterEventSignal {
     protected constructor();
@@ -6647,6 +7376,8 @@ export class ItemStack {
      * Creates an exact copy of the item stack, including any
      * custom data or properties.
      *
+     * @returns
+     * Returns a copy of this item stack.
      */
     clone(): ItemStack;
     /**
@@ -6689,6 +7420,9 @@ export class ItemStack {
     getLore(): string[];
     /**
      * @beta
+     * @remarks
+     * Returns a set of tags associated with this item stack.
+     *
      */
     getTags(): string[];
     /**
@@ -6704,6 +7438,15 @@ export class ItemStack {
     hasComponent(componentId: string): boolean;
     /**
      * @beta
+     * @remarks
+     * Checks whether this item stack has a particular tag
+     * associated with it.
+     *
+     * @param tag
+     * Tag to search for.
+     * @returns
+     * True if the Item Stack has the tag associated with it, else
+     * false.
      */
     hasTag(tag: string): boolean;
     /**
@@ -6792,36 +7535,16 @@ export class ItemStack {
 
 /**
  * @beta
- * Contains information related to a chargeable item starting
- * to be charged.
  */
 export class ItemStartChargeAfterEvent {
     protected constructor();
-    /**
-     * @remarks
-     * The impacted item stack that is starting to be charged.
-     *
-     */
     readonly itemStack: ItemStack;
-    /**
-     * @remarks
-     * Returns the source entity that triggered this item event.
-     *
-     */
     readonly source: Entity;
-    /**
-     * @remarks
-     * Returns the time, in ticks, for the remaining duration left
-     * before the charge completes its cycle.
-     *
-     */
     readonly useDuration: number;
 }
 
 /**
  * @beta
- * Manages callbacks that are connected to the start of
- * charging for a chargeable item.
  */
 export class ItemStartChargeAfterEventSignal extends IItemStartChargeAfterEventSignal {
     protected constructor();
@@ -6874,38 +7597,16 @@ export class ItemStartUseOnAfterEventSignal extends IItemStartUseOnAfterEventSig
 
 /**
  * @beta
- * Contains information related to a chargeable item has
- * finished an items use cycle, or when the player has released
- * the use action with the item.
  */
 export class ItemStopChargeAfterEvent {
     protected constructor();
-    /**
-     * @remarks
-     * The impacted item stack that is stopping being charged.
-     *
-     */
     readonly itemStack: ItemStack;
-    /**
-     * @remarks
-     * Returns the source entity that triggered this item event.
-     *
-     */
     readonly source: Entity;
-    /**
-     * @remarks
-     * Returns the time, in ticks, for the remaining duration left
-     * before the charge completes its cycle.
-     *
-     */
     readonly useDuration: number;
 }
 
 /**
  * @beta
- * Manages callbacks that are connected to the stopping of
- * charging for an item that has a registered
- * minecraft:chargeable component.
  */
 export class ItemStopChargeAfterEventSignal extends IItemStopChargeAfterEventSignal {
     protected constructor();
@@ -7015,6 +7716,11 @@ export class ItemTypes {
  */
 export class ItemUseAfterEvent {
     protected constructor();
+    /**
+     * @remarks
+     * The impacted item stack that is being used.
+     *
+     */
     itemStack: ItemStack;
     /**
      * @remarks
@@ -7081,6 +7787,11 @@ export class ItemUseOnAfterEvent {
      *
      */
     readonly faceLocation: Vector3;
+    /**
+     * @remarks
+     * The impacted item stack that is being used on a block.
+     *
+     */
     readonly itemStack: ItemStack;
     /**
      * @remarks
@@ -7125,6 +7836,9 @@ export class ItemUseOnBeforeEventSignal extends IItemUseOnBeforeEventSignal {
 
 /**
  * @beta
+ * An event that fires before the watchdog is about to
+ * terminate a world because various performance metrics for
+ * scripting have exceeded a threshold.
  */
 export class IWatchdogTerminateBeforeEventSignal {
     protected constructor();
@@ -7145,6 +7859,7 @@ export class IWatchdogTerminateBeforeEventSignal {
 
 /**
  * @beta
+ * An event that fires after the weather has changed.
  */
 export class IWeatherChangeAfterEventSignal {
     protected constructor();
@@ -7165,6 +7880,8 @@ export class IWeatherChangeAfterEventSignal {
 
 /**
  * @beta
+ * An event that fires when a world is first initialized or
+ * loaded.
  */
 export class IWorldInitializeAfterEventSignal {
     protected constructor();
@@ -16227,12 +16944,18 @@ export class ProjectileHitAfterEvent {
     readonly source: Entity;
     /**
      * @remarks
+     * Contains additional information about the block that was hit
+     * by the projectile, or undefined if the projectile did not
+     * hit a block.
+     *
      * This function can't be called in read-only mode.
      *
      */
     getBlockHit(): BlockHitInformation | undefined;
     /**
      * @remarks
+     * Contains additional information about a block that was hit.
+     *
      * This function can't be called in read-only mode.
      *
      */
@@ -17360,6 +18083,10 @@ export class WorldInitializeAfterEvent {
 
 /**
  * @beta
+ * Manages callbacks that are run at the initialization of the
+ * scripting environment for a World. Do note that this event
+ * may run multiple times within a session in the case that the
+ * /reload command is used.
  */
 export class WorldInitializeAfterEventSignal extends IWorldInitializeAfterEventSignal {
     protected constructor();
@@ -17367,8 +18094,15 @@ export class WorldInitializeAfterEventSignal extends IWorldInitializeAfterEventS
 
 /**
  * @beta
+ * Contains additional options for a block fill operation.
  */
 export interface BlockFillOptions {
+    /**
+     * @remarks
+     * When specified, the fill operation will only apply to blocks
+     * that match this description.
+     *
+     */
     matchingBlock?: BlockPermutation;
 }
 
@@ -17428,17 +18162,83 @@ export interface BlockRaycastOptions {
 
 /**
  * @beta
+ * A BlockVolume is a simple interface to an object which
+ * represents a 3D rectangle of a given size (in blocks) at a
+ * world block location.
+ * Note that these are not analogous to "min" and "max" values,
+ * in that the vector components are not guaranteed to be in
+ * any order.
+ * In addition, these vector positions are not interchangeable
+ * with BlockLocation.
+ * If you want to get this volume represented as range of of
+ * BlockLocations, you can use the getBoundingBox utility
+ * function.
+ * This volume class will maintain the ordering of the corner
+ * indexes as initially set. imagine that each corner is
+ * assigned in Editor - as you move the corner around
+ * (potentially inverting the min/max relationship of the
+ * bounds) - what
+ * you had originally selected as the top/left corner would
+ * traditionally become the bottom/right.
+ * When manually editing these kinds of volumes, you need to
+ * maintain the identity of the corner as you edit - the
+ * BlockVolume utility functions do this.
+ *
+ * Important to note that this measures block sizes (to/from) -
+ * a normal AABB (0,0,0) to (0,0,0) would traditionally be of
+ * size (0,0,0)
+ * However, because we're measuring blocks - the size or span
+ * of a BlockVolume would actually be (1,1,1)
+ *
  */
 export interface BlockVolume {
+    /**
+     * @remarks
+     * A world block location that represents a corner in a 3D
+     * rectangle
+     *
+     */
     from: Vector3;
+    /**
+     * @remarks
+     * A world block location that represents the opposite corner
+     * in a 3D rectangle
+     *
+     */
     to: Vector3;
 }
 
 /**
  * @beta
+ * A BoundingBox is an interface to an object which represents
+ * an AABB aligned rectangle.
+ * The BoundingBox 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.BoundingBoxUtils} utility functions.
+ * The min/max coordinates represent the diametrically opposite
+ * corners of the rectangle.
+ * The BoundingBox is not a representation of blocks - it has
+ * no association with any type, it is just a mathematical
+ * construct - so a rectangle with
+ * ( 0,0,0 ) -> ( 0,0,0 )
+ * has a size of ( 0,0,0 ) (unlike the very similar {@link
+ * BlockVolume} object)
  */
 export interface BoundingBox {
+    /**
+     * @remarks
+     * A {@link @minecraft-server.Vector3} that represents the
+     * largest corner of the rectangle
+     *
+     */
     max: Vector3;
+    /**
+     * @remarks
+     * A {@link @minecraft-server.Vector3} that represents the
+     * smallest corner of the rectangle
+     *
+     */
     min: Vector3;
 }
 
@@ -17479,34 +18279,92 @@ export interface Color {
 
 /**
  * @beta
+ * This interface defines an entry into the {@link
+ * @minecraft-server/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 volume of space
+     *
+     */
     volume: BlockVolume;
 }
 
 /**
  * @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
+ * Provides information about how damage has been applied to an
+ * entity.
  */
 export interface EntityDamageSource {
+    /**
+     * @remarks
+     * Cause enumeration of damage.
+     *
+     */
     cause: EntityDamageCause;
+    /**
+     * @remarks
+     * Optional entity that caused the damage.
+     *
+     */
     damagingEntity?: Entity;
+    /**
+     * @remarks
+     * Optional projectile that may have caused damage.
+     *
+     */
     damagingProjectile?: Entity;
 }
 
@@ -17540,6 +18398,25 @@ export interface EntityDataDrivenTriggerEventOptions {
     eventTypes?: string[];
 }
 
+/**
+ * @beta
+ * Contains additional options for entity effects.
+ */
+export interface EntityEffectOptions {
+    /**
+     * @remarks
+     * The strength of the effect.
+     *
+     */
+    amplifier?: number;
+    /**
+     * @remarks
+     * If true, will show particles when effect is on the entity.
+     *
+     */
+    showParticles?: boolean;
+}
+
 /**
  * @beta
  * Contains optional parameters for registering an entity
@@ -17877,20 +18754,60 @@ export interface NumberRange {
 
 /**
  * @beta
+ * Contains additional options for how an animation is played.
  */
 export interface PlayAnimationOptions {
+    /**
+     * @remarks
+     * Amount of time to fade out after an animation stops.
+     *
+     */
     blendOutTime?: number;
+    /**
+     * @remarks
+     * Specifies a controller to use that has been defined on the
+     * entity.
+     *
+     */
     controller?: string;
+    /**
+     * @remarks
+     * Specifies the state to transition to.
+     *
+     */
     nextState?: string;
+    /**
+     * @remarks
+     * Specifies a Molang expression for when this animation should
+     * complete.
+     *
+     */
     stopExpression?: string;
 }
 
 /**
  * @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;
 }
 
@@ -17907,9 +18824,21 @@ export interface 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;
 }
 
@@ -17919,7 +18848,7 @@ export interface RawMessageScore {
  * `RawMessage` is serialized the contents are put into a
  * rawtext property, so this is useful when reading saved
  * RawMessages. See `BlockSignComponent.setText` and
- * `BlockSignComponent.getRawText` for examples
+ * `BlockSignComponent.getRawText` for examples.
  */
 export interface RawText {
     rawtext?: RawMessage[];
@@ -17947,19 +18876,56 @@ export interface ScoreboardObjectiveDisplayOptions {
 
 /**
  * @beta
+ * Contains additional options for registering a script event
+ * event callback.
  */
 export interface ScriptEventMessageFilterOptions {
+    /**
+     * @remarks
+     * Optional list of namespaces to filter inbound script event
+     * messages.
+     *
+     */
     namespaces: string[];
 }
 
 /**
  * @beta
+ * Contains additional options for teleporting an entity.
  */
 export interface TeleportOptions {
+    /**
+     * @remarks
+     * Whether to check whether blocks will block the entity after
+     * teleport.
+     *
+     */
     checkForBlocks?: boolean;
+    /**
+     * @remarks
+     * Dimension to potentially move the entity to.  If not
+     * specified, the entity is teleported within the dimension
+     * that they reside.
+     *
+     */
     dimension?: Dimension;
+    /**
+     * @remarks
+     * Location that the entity should be facing after teleport.
+     *
+     */
     facingLocation?: Vector3;
+    /**
+     * @remarks
+     * Whether to retain the entities velocity after teleport.
+     *
+     */
     keepVelocity?: boolean;
+    /**
+     * @remarks
+     * Rotation of the entity after teleport.
+     *
+     */
     rotation?: Vector2;
 }
 
@@ -17997,9 +18963,20 @@ export interface TitleDisplayOptions {
 
 /**
  * @beta
+ * Represents a two-directional vector.
  */
 export interface Vector2 {
+    /**
+     * @remarks
+     * X component of the two-dimensional vector.
+     *
+     */
     x: number;
+    /**
+     * @remarks
+     * Y component of the two-dimensional vector.
+     *
+     */
     y: number;
 }
 
@@ -18030,15 +19007,26 @@ export interface Vector3 {
 
 /**
  * @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;
 }
 
 /**
  * @beta
- * The error type thrown when a command fails.
  */
 export class CommandError extends Error {
     protected constructor();