@minecraft/server 1.9.0-rc.1.20.70-preview.21 → 1.9.0-rc.1.20.70-preview.24

package/index.d.ts

@@ -15,7 +15,7 @@
  * ```json
  * {
  *   "module_name": "@minecraft/server",
- *   "version": "1.7.0"
+ *   "version": "1.8.0"
  * }
  * ```
  *
@@ -577,34 +577,29 @@ export enum EquipmentSlot {
 }
 
 /**
- * @beta
  * Represents the type of fluid for use within a fluid
  * containing block, like a cauldron.
  */
 export enum FluidType {
     /**
-     * @beta
      * @remarks
      * Represents lava as a type of fluid.
      *
      */
     Lava = 'Lava',
     /**
-     * @beta
      * @remarks
      * Represents a potion as a type of fluid.
      *
      */
     Potion = 'Potion',
     /**
-     * @beta
      * @remarks
      * Represents powder snow as a type of fluid.
      *
      */
     PowderSnow = 'PowderSnow',
     /**
-     * @beta
      * @remarks
      * Represents water as a type of fluida.
      *
@@ -1077,7 +1072,6 @@ export class Block {
      */
     getComponent(componentId: string): BlockComponent | undefined;
     /**
-     * @beta
      * @remarks
      * Returns a set of tags for a block.
      *
@@ -1091,7 +1085,6 @@ export class Block {
      */
     getTags(): string[];
     /**
-     * @beta
      * @remarks
      * Checks to see if the permutation of this block has a
      * specific tag.
@@ -1246,6 +1239,24 @@ export class BlockEvent {
 /**
  * Represents the inventory of a block in the world. Used with
  * blocks like chests.
+ * @example place_items_in_chest.js
+ * ```typescript
+ * import { world, MinecraftBlockTypes, Items, ItemStack } from "@minecraft/server";
+ *
+ * // Fetch block
+ * const block = world.getDimension("overworld").getBlock({ x: 1, y: 2, z: 3 });
+ *
+ * // Make it a chest
+ * block.setType(MinecraftBlockTypes.chest);
+ *
+ * // Get the inventory
+ * const inventoryComponent = block.getComponent("inventory");
+ * const inventoryContainer = inventoryComponent.container;
+ *
+ * // Set slot 0 to a stack of 10 apples
+ * inventoryContainer.setItem(0, new ItemStack(Items.apple, 10, 0));
+ *
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class BlockInventoryComponent extends BlockComponent {
@@ -1265,6 +1276,31 @@ export class BlockInventoryComponent extends BlockComponent {
  * properties (also sometimes called block state) which
  * describe a block (but does not belong to a specific {@link
  * Block}).
+ * @example createTranslatedSign.ts
+ * ```typescript
+ * // A function the creates a sign at the specified location with the specified text
+ * import { DimensionLocation, BlockPermutation, BlockComponentTypes } from '@minecraft/server';
+ * import { MinecraftBlockTypes } from '@minecraft/vanilla-data';
+ *
+ * function createSignAt(location: DimensionLocation) {
+ *     const signBlock = location.dimension.getBlock(location);
+ *
+ *     if (!signBlock) {
+ *         console.warn('Could not find a block at specified location.');
+ *         return;
+ *     }
+ *
+ *     const signPerm = BlockPermutation.resolve(MinecraftBlockTypes.StandingSign, { ground_sign_direction: 8 });
+ *     signBlock.setPermutation(signPerm); // Update block to be a sign
+ *
+ *     // Update the sign block's text
+ *     // with "Steve's Head"
+ *     const signComponent = signBlock.getComponent(BlockComponentTypes.Sign);
+ *     if (signComponent) {
+ *         signComponent.setText({ translate: 'item.skull.player.name', with: ['Steve'] });
+ *     }
+ * }
+ * ```
  */
 export class BlockPermutation {
     private constructor();
@@ -1280,7 +1316,6 @@ export class BlockPermutation {
      */
     getAllStates(): Record<string, boolean | number | string>;
     /**
-     * @beta
      * @remarks
      * Gets a state for the permutation.
      *
@@ -1302,7 +1337,6 @@ export class BlockPermutation {
      */
     matches(blockName: string, states?: Record<string, boolean | number | string>): boolean;
     /**
-     * @beta
      * @remarks
      * Returns a derived BlockPermutation with a specific property
      * set.
@@ -1325,43 +1359,43 @@ export class BlockPermutation {
      * @throws This function can throw errors.
      * @example addBlockColorCube.ts
      * ```typescript
-     *   const allColorNames: string[] = [
-     *     "white",
-     *     "orange",
-     *     "magenta",
-     *     "light_blue",
-     *     "yellow",
-     *     "lime",
-     *     "pink",
-     *     "gray",
-     *     "silver",
-     *     "cyan",
-     *     "purple",
-     *     "blue",
-     *     "brown",
-     *     "green",
-     *     "red",
-     *     "black",
-     *   ];
-     *
-     *   const cubeDim = 7;
-     *
-     *   let colorIndex = 0;
-     *
-     *   for (let x = 0; x <= cubeDim; x++) {
-     *     for (let y = 0; y <= cubeDim; y++) {
-     *       for (let z = 0; z <= cubeDim; z++) {
-     *         colorIndex++;
-     *         overworld
-     *           .getBlock({ x: targetLocation.x + x, y: targetLocation.y + y, z: targetLocation.z + z })
-     *           ?.setPermutation(
-     *             mc.BlockPermutation.resolve("minecraft:wool", {
-     *               color: allColorNames[colorIndex % allColorNames.length],
-     *             })
-     *           );
-     *       }
+     * import { DimensionLocation, BlockPermutation } from '@minecraft/server';
+     * import { MinecraftBlockTypes } from '@minecraft/vanilla-data';
+     *
+     * const allWoolBlocks: string[] = [
+     *     MinecraftBlockTypes.WhiteWool,
+     *     MinecraftBlockTypes.OrangeWool,
+     *     MinecraftBlockTypes.MagentaWool,
+     *     MinecraftBlockTypes.LightBlueWool,
+     *     MinecraftBlockTypes.YellowWool,
+     *     MinecraftBlockTypes.LimeWool,
+     *     MinecraftBlockTypes.PinkWool,
+     *     MinecraftBlockTypes.GrayWool,
+     *     MinecraftBlockTypes.LightGrayWool,
+     *     MinecraftBlockTypes.CyanWool,
+     *     MinecraftBlockTypes.PurpleWool,
+     *     MinecraftBlockTypes.BlueWool,
+     *     MinecraftBlockTypes.BrownWool,
+     *     MinecraftBlockTypes.GreenWool,
+     *     MinecraftBlockTypes.RedWool,
+     *     MinecraftBlockTypes.BlackWool,
+     * ];
+     *
+     * const cubeDim = 7;
+     *
+     * function placeRainbowCube(location: DimensionLocation) {
+     *     let colorIndex = 0;
+     *     for (let x = 0; x <= cubeDim; x++) {
+     *         for (let y = 0; y <= cubeDim; y++) {
+     *             for (let z = 0; z <= cubeDim; z++) {
+     *                 colorIndex++;
+     *                 location.dimension
+     *                     .getBlock({ x: location.x + x, y: location.y + y, z: location.z + z })
+     *                     ?.setPermutation(BlockPermutation.resolve(allWoolBlocks[colorIndex % allWoolBlocks.length]));
+     *             }
+     *         }
      *     }
-     *   }
+     * }
      * ```
      */
     static resolve(blockName: string, states?: Record<string, boolean | number | string>): BlockPermutation;
@@ -1412,6 +1446,103 @@ export class BlockPistonComponent extends BlockComponent {
 /**
  * @beta
  * Represents a block that can display text on it.
+ * @example addTwoSidedSign.ts
+ * ```typescript
+ * // A function the creates a sign at the specified location with text on both sides and dye colors
+ * import {
+ *     DimensionLocation,
+ *     BlockPermutation,
+ *     BlockSignComponent,
+ *     BlockComponentTypes,
+ *     DyeColor,
+ *     SignSide,
+ * } from '@minecraft/server';
+ * import { MinecraftBlockTypes } from '@minecraft/vanilla-data';
+ *
+ * function createSignAt(location: DimensionLocation) {
+ *     const block = location.dimension.getBlock(location);
+ *     if (!block) {
+ *         console.warn('Could not find a block at specified location.');
+ *         return;
+ *     }
+ *     const signPerm = BlockPermutation.resolve(MinecraftBlockTypes.StandingSign, {
+ *         ground_sign_direction: 8,
+ *     });
+ *     block.setPermutation(signPerm);
+ *     const sign = block.getComponent(BlockComponentTypes.Sign);
+ *
+ *     if (sign !== undefined) {
+ *         sign.setText(`Party Sign!\nThis is green on the front.`);
+ *         sign.setText(`Party Sign!\nThis is red on the back.`, SignSide.Back);
+ *         sign.setTextDyeColor(DyeColor.Green);
+ *         sign.setTextDyeColor(DyeColor.Red, SignSide.Back);
+ *
+ *         // players cannot edit sign!
+ *         sign.setWaxed(true);
+ *     } else {
+ *         console.warn('Could not find a sign component on the block.');
+ *     }
+ * }
+ * ```
+ * @example setSignText.ts
+ * ```typescript
+ * import {
+ *     BlockComponentTypes,
+ *     DimensionLocation,
+ *     RawMessage,
+ *     RawText,
+ * } from '@minecraft/server';
+ *
+ * // Function which updates a sign blocks text to raw text
+ * function updateSignText(signLocation: DimensionLocation) {
+ *     const block = signLocation.dimension.getBlock(signLocation);
+ *     if (!block) {
+ *         console.warn('Could not find a block at specified location.');
+ *         return;
+ *     }
+ *
+ *     const sign = block.getComponent(BlockComponentTypes.Sign);
+ *     if (sign) {
+ *         // RawMessage
+ *         const helloWorldMessage: RawMessage = { text: 'Hello World' };
+ *         sign.setText(helloWorldMessage);
+ *
+ *         // RawText
+ *         const helloWorldText: RawText = { rawtext: [{ text: 'Hello World' }] };
+ *         sign.setText(helloWorldText);
+ *
+ *         // Regular string
+ *         sign.setText('Hello World');
+ *     } else {
+ *         console.warn('Could not find a sign component on the block.');
+ *     }
+ * }
+ * ```
+ * @example createTranslatedSign.ts
+ * ```typescript
+ * // A function the creates a sign at the specified location with the specified text
+ * import { DimensionLocation, BlockPermutation, BlockComponentTypes } from '@minecraft/server';
+ * import { MinecraftBlockTypes } from '@minecraft/vanilla-data';
+ *
+ * function createSignAt(location: DimensionLocation) {
+ *     const signBlock = location.dimension.getBlock(location);
+ *
+ *     if (!signBlock) {
+ *         console.warn('Could not find a block at specified location.');
+ *         return;
+ *     }
+ *
+ *     const signPerm = BlockPermutation.resolve(MinecraftBlockTypes.StandingSign, { ground_sign_direction: 8 });
+ *     signBlock.setPermutation(signPerm); // Update block to be a sign
+ *
+ *     // Update the sign block's text
+ *     // with "Steve's Head"
+ *     const signComponent = signBlock.getComponent(BlockComponentTypes.Sign);
+ *     if (signComponent) {
+ *         signComponent.setText({ translate: 'item.skull.player.name', with: ['Steve'] });
+ *     }
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class BlockSignComponent extends BlockComponent {
@@ -1481,50 +1612,39 @@ export class BlockSignComponent extends BlockComponent {
      * @throws
      * Throws if the provided message is greater than 512
      * characters in length.
-     * @example SetRawMessage.ts
+     * @example setSignText.ts
      * ```typescript
-     * const signLocation: Vector3 = { x: 0, y: -60, z: 0 }; // Replace with your sign's coordinates
-     * const block = world.getDimension("overworld").getBlock(signLocation);
-     * if (!block) {
-     *   world.sendMessage("Could not find a block at specified location.");
-     *   return;
-     * }
-     * const sign = block.getComponent("minecraft:sign") as BlockSignComponent;
-     * const helloWorldMessage: RawMessage = { text: "Hello World" };
-     * sign.setText(helloWorldMessage);
+     * import {
+     *     BlockComponentTypes,
+     *     DimensionLocation,
+     *     RawMessage,
+     *     RawText,
+     * } from '@minecraft/server';
+     *
+     * // Function which updates a sign blocks text to raw text
+     * function updateSignText(signLocation: DimensionLocation) {
+     *     const block = signLocation.dimension.getBlock(signLocation);
+     *     if (!block) {
+     *         console.warn('Could not find a block at specified location.');
+     *         return;
+     *     }
      *
-     * // Sign text will be saved as a RawText
-     * const result = sign.getRawText();
-     * world.sendMessage(JSON.stringify(result)); // { rawtext: [{ text: 'Hello World' }] };
-     * ```
-     * @example SetRawText.ts
-     * ```typescript
-     * const signLocation: Vector3 = { x: 0, y: -60, z: 0 }; // Replace with your sign's coordinates
-     * const block = world.getDimension("overworld").getBlock(signLocation);
-     * if (!block) {
-     *   world.sendMessage("Could not find a block at specified location.");
-     *   return;
-     * }
-     * const sign = block.getComponent("minecraft:sign") as BlockSignComponent;
-     * const helloWorldText: RawText = { rawtext: [{ text: "Hello World" }] };
-     * sign.setText(helloWorldText);
+     *     const sign = block.getComponent(BlockComponentTypes.Sign);
+     *     if (sign) {
+     *         // RawMessage
+     *         const helloWorldMessage: RawMessage = { text: 'Hello World' };
+     *         sign.setText(helloWorldMessage);
      *
-     * // There will be no data transformation unlike calling setText with a RawMessage
-     * const result = sign.getRawText();
-     * world.sendMessage(JSON.stringify(result)); // { rawtext: [{ text: 'Hello World' }] };
-     * ```
-     * @example SetString.ts
-     * ```typescript
-     * const signLocation: Vector3 = { x: 0, y: -60, z: 0 }; // Replace with your sign's coordinates
-     * const block = world.getDimension("overworld").getBlock(signLocation);
-     * if (!block) {
-     *   world.sendMessage("Could not find a block at specified location.");
-     *   return;
+     *         // RawText
+     *         const helloWorldText: RawText = { rawtext: [{ text: 'Hello World' }] };
+     *         sign.setText(helloWorldText);
+     *
+     *         // Regular string
+     *         sign.setText('Hello World');
+     *     } else {
+     *         console.warn('Could not find a sign component on the block.');
+     *     }
      * }
-     * const sign = block.getComponent("minecraft:sign") as BlockSignComponent;
-     * // Set sign to say 'Hello'
-     * sign.setText("Hello World");
-     * world.sendMessage(sign.getText() ?? "undefined"); // 'Hello World'
      * ```
      */
     setText(message: RawMessage | RawText | string, side?: SignSide): void;
@@ -1601,7 +1721,6 @@ export class BlockStateType {
 }
 
 /**
- * @beta
  * The type (or template) of a block. Does not contain
  * permutation data (state) other than the type of block it
  * represents. This type was introduced as of version
@@ -1613,6 +1732,18 @@ export class BlockType {
 
 /**
  * Contains information related to changes to a button push.
+ * @example buttonPushEvent.ts
+ * ```typescript
+ * import { world, ButtonPushAfterEvent, system } from '@minecraft/server';
+ *
+ * world.afterEvents.buttonPush.subscribe((buttonPushEvent: ButtonPushAfterEvent) => {
+ *     const eventLoc = buttonPushEvent.block.location;
+ *
+ *     world.sendMessage(
+ *         `Button push event at tick ${system.currentTick} Power:${buttonPushEvent.block.getRedstonePower()}`,
+ *     );
+ * });
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class ButtonPushAfterEvent extends BlockEvent {
@@ -1628,6 +1759,18 @@ export class ButtonPushAfterEvent extends BlockEvent {
 /**
  * Manages callbacks that are connected to when a button is
  * pushed.
+ * @example buttonPushEvent.ts
+ * ```typescript
+ * import { world, ButtonPushAfterEvent, system } from '@minecraft/server';
+ *
+ * world.afterEvents.buttonPush.subscribe((buttonPushEvent: ButtonPushAfterEvent) => {
+ *     const eventLoc = buttonPushEvent.block.location;
+ *
+ *     world.sendMessage(
+ *         `Button push event at tick ${system.currentTick} Power:${buttonPushEvent.block.getRedstonePower()}`,
+ *     );
+ * });
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class ButtonPushAfterEventSignal extends IButtonPushAfterEventSignal {
@@ -1730,6 +1873,54 @@ export class Component {
  * Represents a container that can hold sets of items. Used
  * with entities such as Players, Chest Minecarts, Llamas, and
  * more.
+ * @example containers.js
+ * ```typescript
+ * let leftLocation = test.worldLocation({ x: 2, y: 2, z: 2 }); // left chest location
+ * let rightLocation = test.worldLocation({ x: 4, y: 2, z: 2 }); // right chest location
+ *
+ * const chestCart = test.spawn("chest_minecart", { x: 6, y: 2, z: 2 });
+ *
+ * let leftChestBlock = defaultDimension.getBlock(leftLocation);
+ * let rightChestBlock = defaultDimension.getBlock(rightLocation);
+ *
+ * leftChestBlock.setType(MinecraftBlockTypes.chest);
+ * rightChestBlock.setType(MinecraftBlockTypes.chest);
+ *
+ * const rightChestInventoryComp = rightChestBlock.getComponent("inventory");
+ * const leftChestInventoryComp = leftChestBlock.getComponent("inventory");
+ * const chestCartInventoryComp = chestCart.getComponent("inventory");
+ *
+ * const rightChestContainer = rightChestInventoryComp.container;
+ * const leftChestContainer = leftChestInventoryComp.container;
+ * const chestCartContainer = chestCartInventoryComp.container;
+ *
+ * rightChestContainer.setItem(0, new ItemStack(Items.apple, 10, 0));
+ * test.assert(rightChestContainer.getItem(0).id === "apple", "Expected apple in right container slot index 0");
+ *
+ * rightChestContainer.setItem(1, new ItemStack(Items.emerald, 10, 0));
+ * test.assert(rightChestContainer.getItem(1).id === "emerald", "Expected emerald in right container slot index 1");
+ *
+ * test.assert(rightChestContainer.size === 27, "Unexpected size: " + rightChestContainer.size);
+ * test.assert(
+ *   rightChestContainer.emptySlotsCount === 25,
+ *   "Unexpected emptySlotsCount: " + rightChestContainer.emptySlotsCount
+ * );
+ *
+ * const itemStack = rightChestContainer.getItem(0);
+ * test.assert(itemStack.id === "apple", "Expected apple");
+ * test.assert(itemStack.amount === 10, "Expected 10 apples");
+ * test.assert(itemStack.data === 0, "Expected 0 data");
+ *
+ * leftChestContainer.setItem(0, new ItemStack(Items.cake, 10, 0));
+ *
+ * rightChestContainer.transferItem(0, 4, chestCartContainer); // transfer the apple from the right chest to a chest cart
+ * rightChestContainer.swapItems(1, 0, leftChestContainer); // swap the cake and emerald
+ *
+ * test.assert(chestCartContainer.getItem(4).id === "apple", "Expected apple in left container slot index 4");
+ * test.assert(leftChestContainer.getItem(0).id === "emerald", "Expected emerald in left container slot index 0");
+ * test.assert(rightChestContainer.getItem(1).id === "cake", "Expected cake in right container slot index 1");
+ *
+ * ```
  */
 export class Container {
     private constructor();
@@ -1791,9 +1982,16 @@ export class Container {
      * 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);
+     * // A function that gets a copy of the first item in the player's hotbar
+     * import { Player, EntityInventoryComponent, ItemStack } from '@minecraft/server';
+     *
+     * function getFirstHotbarItem(player: Player): ItemStack | undefined {
+     *     const inventory = player.getComponent(EntityInventoryComponent.componentId);
+     *     if (inventory && inventory.container) {
+     *         return inventory.container.getItem(0);
+     *     }
+     *     return undefined;
+     * }
      * ```
      */
     getItem(slot: number): ItemStack | undefined;
@@ -1840,10 +2038,17 @@ export class Container {
      * 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);
+     * // A function that moves an item from one slot of the player's inventory to another player's inventory
+     * import { Player, EntityComponentTypes } from '@minecraft/server';
+     *
+     * function moveBetweenPlayers(slotId: number, fromPlayer: Player, toPlayer: Player) {
+     *     const fromInventory = fromPlayer.getComponent(EntityComponentTypes.Inventory);
+     *     const toInventory = toPlayer.getComponent(EntityComponentTypes.Inventory);
+     *
+     *     if (fromInventory && toInventory && fromInventory.container && toInventory.container) {
+     *         fromInventory.container.moveItem(slotId, slotId, toInventory.container);
+     *     }
+     * }
      * ```
      */
     moveItem(fromSlot: number, toSlot: number, toContainer: Container): void;
@@ -1881,9 +2086,17 @@ export class Container {
      * 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);
+     * // A function that swaps an item from one slot of the player's inventory to another player's inventory
+     * import { Player, EntityComponentTypes } from '@minecraft/server';
+     *
+     * function swapBetweenPlayers(slotId: number, fromPlayer: Player, toPlayer: Player) {
+     *     const fromInventory = fromPlayer.getComponent(EntityComponentTypes.Inventory);
+     *     const toInventory = toPlayer.getComponent(EntityComponentTypes.Inventory);
+     *
+     *     if (fromInventory && toInventory && fromInventory.container && toInventory.container) {
+     *         fromInventory.container.swapItems(slotId, slotId, toInventory.container);
+     *     }
+     * }
      * ```
      */
     swapItems(slot: number, otherSlot: number, otherContainer: Container): void;
@@ -1908,10 +2121,17 @@ export class Container {
      * 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);
+     * // A function that moves an item from one slot of the player's inventory to another player's inventory
+     * import { Player, EntityComponentTypes } from '@minecraft/server';
+     *
+     * function moveBetweenPlayers(slotId: number, fromPlayer: Player, toPlayer: Player) {
+     *     const fromInventory = fromPlayer.getComponent(EntityComponentTypes.Inventory);
+     *     const toInventory = toPlayer.getComponent(EntityComponentTypes.Inventory);
+     *
+     *     if (fromInventory && toInventory && fromInventory.container && toInventory.container) {
+     *         fromInventory.container.transferItem(slotId, toInventory.container);
+     *     }
+     * }
      * ```
      */
     transferItem(fromSlot: number, toContainer: Container): ItemStack | undefined;
@@ -2264,7 +2484,6 @@ export class ContainerSlot {
 }
 
 /**
- * @beta
  * Contains information related to firing of a data driven
  * entity event - for example, the minecraft:ageable_grow_up
  * event on a chicken.
@@ -2293,7 +2512,6 @@ export class DataDrivenEntityTriggerAfterEvent {
 }
 
 /**
- * @beta
  * Contains event registration related to firing of a data
  * driven entity event - for example, the
  * minecraft:ageable_grow_up event on a chicken.
@@ -2361,39 +2579,21 @@ export class Dimension {
      * {@link LocationInUnloadedChunkError}
      *
      * {@link LocationOutOfWorldBoundariesError}
-     * @example createExplosion.ts
-     * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
-     *
-     *   log("Creating an explosion of radius 10.");
-     *   overworld.createExplosion(targetLocation, 10);
-     * ```
-     * @example createFireAndWaterExplosions.ts
+     * @example createExplosions.ts
      * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
-     *
-     *   const explosionLoc = { x: targetLocation.x + 0.5, y: targetLocation.y + 0.5, z: targetLocation.z + 0.5};
-     *
-     *   log("Creating an explosion of radius 15 that causes fire.");
-     *   overworld.createExplosion(explosionLoc, 15, { causesFire: true });
+     * // Creates an explosion of radius 15 that does not break blocks
+     * import { DimensionLocation } from '@minecraft/server';
      *
-     *   const belowWaterLoc = { x: targetLocation.x + 3, y: targetLocation.y + 1,z: targetLocation.z + 3};
+     * function createExplosions(location: DimensionLocation) {
+     *     // Creates an explosion of radius 15 that does not break blocks
+     *     location.dimension.createExplosion(location, 15, { breaksBlocks: false });
      *
-     *   log("Creating an explosion of radius 10 that can go underwater.");
-     *   overworld.createExplosion(belowWaterLoc, 10, { allowUnderwater: true });
-     * ```
-     * @example createNoBlockExplosion.ts
-     * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
+     *     // Creates an explosion of radius 15 that does not cause fire
+     *     location.dimension.createExplosion(location, 15, { causesFire: true });
      *
-     *   const explodeNoBlocksLoc = {
-     *     x: Math.floor(targetLocation.x + 1),
-     *     y: Math.floor(targetLocation.y + 2),
-     *     z: Math.floor(targetLocation.z + 1)
-     *   };
-     *
-     *   log("Creating an explosion of radius 15 that does not break blocks.");
-     *   overworld.createExplosion(explodeNoBlocksLoc, 15, { breaksBlocks: false });
+     *     // Creates an explosion of radius 10 that can go underwater
+     *     location.dimension.createExplosion(location, 10, { allowUnderwater: true });
+     * }
      * ```
      */
     createExplosion(location: Vector3, radius: number, explosionOptions?: ExplosionOptions): boolean;
@@ -2446,60 +2646,52 @@ export class Dimension {
      * @returns
      * An entity array.
      * @throws This function can throw errors.
-     * @example bounceSkeletons.ts
+     * @example checkFeatherNearby.ts
      * ```typescript
-     *   let mobs = ["creeper", "skeleton", "sheep"];
-     *
-     *   // create some sample mob data
-     *   for (let i = 0; i < 10; i++) {
-     *     overworld.spawnEntity(mobs[i % mobs.length], targetLocation);
-     *   }
-     *
-     *   let eqo: mc.EntityQueryOptions = {
-     *     type: "skeleton",
-     *   };
+     * import { DimensionLocation, EntityComponentTypes } from "@minecraft/server";
+     *
+     * // Returns true if a feather item entity is within 'distance' blocks of 'location'.
+     * function isFeatherNear(location: DimensionLocation, distance: number): boolean {
+     *     const items = location.dimension.getEntities({
+     *         location: location,
+     *         maxDistance: 20,
+     *     });
+     *
+     *     for (const item of items) {
+     *         const itemComp = item.getComponent(EntityComponentTypes.Item);
+     *
+     *         if (itemComp) {
+     *             if (itemComp.itemStack.typeId.endsWith('feather')) {
+     *                 return true;
+     *             }
+     *         }
+     *     }
      *
-     *   for (let entity of overworld.getEntities(eqo)) {
-     *     entity.applyKnockback(0, 0, 0, 1);
-     *   }
+     *     return false;
+     * }
      * ```
      * @example tagsQuery.ts
      * ```typescript
-     *   let mobs = ["creeper", "skeleton", "sheep"];
-     *
-     *   // create some sample mob data
-     *   for (let i = 0; i < 10; i++) {
-     *     let mobTypeId = mobs[i % mobs.length];
-     *     let entity = overworld.spawnEntity(mobTypeId, targetLocation);
-     *     entity.addTag("mobparty." + mobTypeId);
-     *   }
-     *
-     *   let eqo: mc.EntityQueryOptions = {
-     *     tags: ["mobparty.skeleton"],
-     *   };
-     *
-     *   for (let entity of overworld.getEntities(eqo)) {
-     *     entity.kill();
-     *   }
-     * ```
-     * @example testThatEntityIsFeatherItem.ts
-     * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
+     * import { EntityQueryOptions, DimensionLocation } from '@minecraft/server';
+     *
+     * function mobParty(targetLocation: DimensionLocation) {
+     *     const mobs = ['creeper', 'skeleton', 'sheep'];
      *
-     *   const items = overworld.getEntities({
-     *     location: targetLocation,
-     *     maxDistance: 20,
-     *   });
+     *     // create some sample mob data
+     *     for (let i = 0; i < 10; i++) {
+     *         const mobTypeId = mobs[i % mobs.length];
+     *         const entity = targetLocation.dimension.spawnEntity(mobTypeId, targetLocation);
+     *         entity.addTag('mobparty.' + mobTypeId);
+     *     }
      *
-     *   for (const item of items) {
-     *     const itemComp = item.getComponent("item") as mc.EntityItemComponent;
+     *     const eqo: EntityQueryOptions = {
+     *         tags: ['mobparty.skeleton'],
+     *     };
      *
-     *     if (itemComp) {
-     *       if (itemComp.itemStack.typeId.endsWith("feather")) {
-     *         log("Success! Found a feather", 1);
-     *       }
+     *     for (const entity of targetLocation.dimension.getEntities(eqo)) {
+     *         entity.kill();
      *     }
-     *   }
+     * }
      * ```
      */
     getEntities(options?: EntityQueryOptions): Entity[];
@@ -2615,42 +2807,39 @@ export class Dimension {
      * {@link LocationOutOfWorldBoundariesError}
      * @example createOldHorse.ts
      * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
+     * // Spawns an adult horse
+     * import { DimensionLocation } from '@minecraft/server';
      *
-     *   log("Create a horse and triggering the 'ageable_grow_up' event, ensuring the horse is created as an adult");
-     *   overworld.spawnEntity("minecraft:horse<minecraft:ageable_grow_up>", targetLocation);
+     * function spawnAdultHorse(location: DimensionLocation) {
+     *     // Create a horse and triggering the 'ageable_grow_up' event, ensuring the horse is created as an adult
+     *     location.dimension.spawnEntity('minecraft:horse<minecraft:ageable_grow_up>', location);
+     * }
      * ```
      * @example quickFoxLazyDog.ts
      * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
-     *
-     *   const fox = overworld.spawnEntity("minecraft:fox", {
-     *     x: targetLocation.x + 1,
-     *     y: targetLocation.y + 2,
-     *     z: targetLocation.z + 3,
-     *   });
-     *
-     *   fox.addEffect("speed", 10, {
-     *     amplifier: 2,
-     *   });
-     *   log("Created a fox.");
-     *
-     *   const wolf = overworld.spawnEntity("minecraft:wolf", {
-     *     x: targetLocation.x + 4,
-     *     y: targetLocation.y + 2,
-     *     z: targetLocation.z + 3,
-     *   });
-     *   wolf.addEffect("slowness", 10, {
-     *     amplifier: 2,
-     *   });
-     *   wolf.isSneaking = true;
-     *   log("Created a sneaking wolf.", 1);
-     * ```
-     * @example triggerEvent.ts
-     * ```typescript
-     *   const creeper = overworld.spawnEntity("minecraft:creeper", targetLocation);
-     *
-     *   creeper.triggerEvent("minecraft:start_exploding_forced");
+     * // Spawns a fox over a dog
+     * import { DimensionLocation } from '@minecraft/server';
+     * import { MinecraftEntityTypes } from '@minecraft/vanilla-data';
+     *
+     * function spawnAdultHorse(location: DimensionLocation) {
+     *     // Create fox (our quick brown fox)
+     *     const fox = location.dimension.spawnEntity(MinecraftEntityTypes.Fox, {
+     *         x: location.x,
+     *         y: location.y + 2,
+     *         z: location.z,
+     *     });
+     *
+     *     fox.addEffect('speed', 10, {
+     *         amplifier: 2,
+     *     });
+     *
+     *     // Create wolf (our lazy dog)
+     *     const wolf = location.dimension.spawnEntity(MinecraftEntityTypes.Wolf, location);
+     *     wolf.addEffect('slowness', 10, {
+     *         amplifier: 2,
+     *     });
+     *     wolf.isSneaking = true;
+     * }
      * ```
      */
     spawnEntity(identifier: string, location: Vector3): Entity;
@@ -2670,33 +2859,16 @@ export class Dimension {
      * {@link LocationInUnloadedChunkError}
      *
      * {@link LocationOutOfWorldBoundariesError}
-     * @example itemStacks.ts
-     * ```typescript
-     * const overworld = mc.world.getDimension('overworld');
-     *
-     * const oneItemLoc = { x: targetLocation.x + targetLocation.y + 3, y: 2, z: targetLocation.z + 1 };
-     * const fiveItemsLoc = { x: targetLocation.x + 1, y: targetLocation.y + 2, z: targetLocation.z + 1 };
-     * const diamondPickaxeLoc = { x: targetLocation.x + 2, y: targetLocation.y + 2, z: targetLocation.z + 4 };
-     *
-     * const oneEmerald = new mc.ItemStack(mc.MinecraftItemTypes.Emerald, 1);
-     * const onePickaxe = new mc.ItemStack(mc.MinecraftItemTypes.DiamondPickaxe, 1);
-     * const fiveEmeralds = new mc.ItemStack(mc.MinecraftItemTypes.Emerald, 5);
-     *
-     * log(`Spawning an emerald at (${oneItemLoc.x}, ${oneItemLoc.y}, ${oneItemLoc.z})`);
-     * overworld.spawnItem(oneEmerald, oneItemLoc);
-     *
-     * log(`Spawning five emeralds at (${fiveItemsLoc.x}, ${fiveItemsLoc.y}, ${fiveItemsLoc.z})`);
-     * overworld.spawnItem(fiveEmeralds, fiveItemsLoc);
-     *
-     * log(`Spawning a diamond pickaxe at (${diamondPickaxeLoc.x}, ${diamondPickaxeLoc.y}, ${diamondPickaxeLoc.z})`);
-     * overworld.spawnItem(onePickaxe, diamondPickaxeLoc);
-     * ```
-     * @example spawnItem.ts
+     * @example spawnFeatherItem.ts
      * ```typescript
-     * const featherItem = new mc.ItemStack(mc.MinecraftItemTypes.Feather, 1);
+     * // Spawns a feather at a location
+     * import { ItemStack, DimensionLocation } from '@minecraft/server';
+     * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
      *
-     * overworld.spawnItem(featherItem, targetLocation);
-     * log(`New feather created at ${targetLocation.x}, ${targetLocation.y}, ${targetLocation.z}!`);
+     * function spawnFeather(location: DimensionLocation) {
+     *     const featherItem = new ItemStack(MinecraftItemTypes.Feather, 1);
+     *     location.dimension.spawnItem(featherItem, location);
+     * }
      * ```
      */
     spawnItem(itemStack: ItemStack, location: Vector3): Entity;
@@ -2721,18 +2893,27 @@ export class Dimension {
      * {@link LocationOutOfWorldBoundariesError}
      * @example spawnParticle.ts
      * ```typescript
-     *   for (let i = 0; i < 100; i++) {
-     *     const molang = new mc.MolangVariableMap();
-     *
-     *     molang.setColorRGB("variable.color", { red: Math.random(), green: Math.random(), blue: Math.random(), alpha: 1 });
-     *
-     *     let newLocation = {
-     *       x: targetLocation.x + Math.floor(Math.random() * 8) - 4,
-     *       y: targetLocation.y + Math.floor(Math.random() * 8) - 4,
-     *       z: targetLocation.z + Math.floor(Math.random() * 8) - 4,
-     *     };
-     *     overworld.spawnParticle("minecraft:colored_flame_particle", newLocation, molang);
-     *   }
+     * // A function that spawns a particle at a random location near the target location for all players in the server
+     * import { world, MolangVariableMap, DimensionLocation, Vector3 } from '@minecraft/server';
+     *
+     * function spawnConfetti(location: DimensionLocation) {
+     *     for (let i = 0; i < 100; i++) {
+     *         const molang = new MolangVariableMap();
+     *
+     *         molang.setColorRGB('variable.color', {
+     *             red: Math.random(),
+     *             green: Math.random(),
+     *             blue: Math.random()
+     *         });
+     *
+     *         const newLocation: Vector3 = {
+     *             x: location.x + Math.floor(Math.random() * 8) - 4,
+     *             y: location.y + Math.floor(Math.random() * 8) - 4,
+     *             z: location.z + Math.floor(Math.random() * 8) - 4,
+     *         };
+     *         location.dimension.spawnParticle('minecraft:colored_flame_particle', newLocation, molang);
+     *     }
+     * }
      * ```
      */
     spawnParticle(effectName: string, location: Vector3, molangVariables?: MolangVariableMap): void;
@@ -2821,7 +3002,6 @@ export class Effect {
 }
 
 /**
- * @beta
  * Contains information related to changes to an effect - like
  * poison - being added to an entity.
  */
@@ -2842,7 +3022,6 @@ export class EffectAddAfterEvent {
 }
 
 /**
- * @beta
  * Manages callbacks that are connected to when an effect is
  * added to an entity.
  */
@@ -2873,7 +3052,6 @@ export class EffectAddAfterEventSignal {
 }
 
 /**
- * @beta
  * Contains information related to changes to an effect - like
  * poison - being added to an entity.
  */
@@ -2906,7 +3084,6 @@ export class EffectAddBeforeEvent {
 }
 
 /**
- * @beta
  * Manages callbacks that are connected to when an effect is
  * added to an entity.
  */
@@ -3029,7 +3206,10 @@ export class Entity {
     readonly isInWater: boolean;
     /**
      * @remarks
-     * Whether the entity is on top of a solid block.
+     * Whether the entity is on top of a solid block. This property
+     * may behave in unexpected ways. This property will always be
+     * true when an Entity is first spawned, and if the Entity has
+     * no gravity this property may be incorrect.
      *
      * @throws This property can throw when used.
      */
@@ -3118,40 +3298,48 @@ export class Entity {
      * amplifier are outside of the valid ranges, or if the effect
      * does not exist.
      * @throws This function can throw errors.
-     * @example addEffect.js
+     * @example poisonVillager.ts
      * ```typescript
-     * 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;
+     * // Spawns a villager and gives it the poison effect
+     * import {
+     *     DimensionLocation,
+     * } from '@minecraft/server';
+     * import { MinecraftEffectTypes } from '@minecraft/vanilla-data';
+     *
+     * function spawnPoisonedVillager(location: DimensionLocation) {
+     *     const villagerType = 'minecraft:villager_v2<minecraft:ageable_grow_up>';
+     *     const villager = location.dimension.spawnEntity(villagerType, location);
+     *     const duration = 20;
+     *
+     *     villager.addEffect(MinecraftEffectTypes.Poison, duration, { amplifier: 1 });
+     * }
      *
-     * villager.addEffect(EffectTypes.get('poison'), duration, { amplifier: 1 });
      * ```
      * @example quickFoxLazyDog.ts
      * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
-     *
-     *   const fox = overworld.spawnEntity("minecraft:fox", {
-     *     x: targetLocation.x + 1,
-     *     y: targetLocation.y + 2,
-     *     z: targetLocation.z + 3,
-     *   });
-     *
-     *   fox.addEffect("speed", 10, {
-     *     amplifier: 2,
-     *   });
-     *   log("Created a fox.");
-     *
-     *   const wolf = overworld.spawnEntity("minecraft:wolf", {
-     *     x: targetLocation.x + 4,
-     *     y: targetLocation.y + 2,
-     *     z: targetLocation.z + 3,
-     *   });
-     *   wolf.addEffect("slowness", 10, {
-     *     amplifier: 2,
-     *   });
-     *   wolf.isSneaking = true;
-     *   log("Created a sneaking wolf.", 1);
+     * // Spawns a fox over a dog
+     * import { DimensionLocation } from '@minecraft/server';
+     * import { MinecraftEntityTypes } from '@minecraft/vanilla-data';
+     *
+     * function spawnAdultHorse(location: DimensionLocation) {
+     *     // Create fox (our quick brown fox)
+     *     const fox = location.dimension.spawnEntity(MinecraftEntityTypes.Fox, {
+     *         x: location.x,
+     *         y: location.y + 2,
+     *         z: location.z,
+     *     });
+     *
+     *     fox.addEffect('speed', 10, {
+     *         amplifier: 2,
+     *     });
+     *
+     *     // Create wolf (our lazy dog)
+     *     const wolf = location.dimension.spawnEntity(MinecraftEntityTypes.Wolf, location);
+     *     wolf.addEffect('slowness', 10, {
+     *         amplifier: 2,
+     *     });
+     *     wolf.isSneaking = true;
+     * }
      * ```
      */
     addEffect(effectType: EffectType | string, duration: number, options?: EntityEffectOptions): void;
@@ -3168,25 +3356,6 @@ export class Entity {
      * 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.
-     * @example tagsQuery.ts
-     * ```typescript
-     *   let mobs = ["creeper", "skeleton", "sheep"];
-     *
-     *   // create some sample mob data
-     *   for (let i = 0; i < 10; i++) {
-     *     let mobTypeId = mobs[i % mobs.length];
-     *     let entity = overworld.spawnEntity(mobTypeId, targetLocation);
-     *     entity.addTag("mobparty." + mobTypeId);
-     *   }
-     *
-     *   let eqo: mc.EntityQueryOptions = {
-     *     tags: ["mobparty.skeleton"],
-     *   };
-     *
-     *   for (let entity of overworld.getEntities(eqo)) {
-     *     entity.kill();
-     *   }
-     * ```
      */
     addTag(tag: string): boolean;
     /**
@@ -3208,16 +3377,25 @@ export class Entity {
      * @throws This function can throw errors.
      * @example applyDamageThenHeal.ts
      * ```typescript
-     *   const skelly = overworld.spawnEntity("minecraft:skeleton", targetLocation);
+     * // A function that applies damage and then heals the entity
+     * import { Entity, EntityComponentTypes, system, world } from '@minecraft/server';
+     *
+     * function applyDamageAndHeal(entity: Entity) {
+     *     entity.applyDamage(19); // Many mobs have max damage of 20 so this is a near-death mob
      *
-     *   skelly.applyDamage(19); // skeletons have max damage of 20 so this is a near-death skeleton
+     *     system.runTimeout(() => {
+     *         const health = entity.getComponent(EntityComponentTypes.Health);
+     *         if (health) {
+     *             world.sendMessage(`Entity health before heal: ${health.currentValue}`);
      *
-     *   mc.system.runTimeout(() => {
-     *     let health = skelly.getComponent("health") as mc.EntityHealthComponent;
-     *     log("Skeleton health before heal: " + health.currentValue);
-     *     health.resetToMaxValue();
-     *     log("Skeleton health after heal: " + health.currentValue);
-     *   }, 20);
+     *             health.resetToMaxValue();
+     *
+     *             world.sendMessage(`Entity after before heal: ${health.currentValue}`);
+     *         } else {
+     *             console.warn('Entity does not have health component');
+     *         }
+     *     }, 40); // Run in a few seconds (40 ticks)
+     * }
      * ```
      */
     applyDamage(amount: number, options?: EntityApplyDamageByProjectileOptions | EntityApplyDamageOptions): boolean;
@@ -3231,14 +3409,19 @@ export class Entity {
      * @param vector
      * Impulse vector.
      * @throws This function can throw errors.
-     * @example applyImpulse.ts
+     * @example yeetEntity.ts
      * ```typescript
-     *   const zombie = overworld.spawnEntity("minecraft:zombie", targetLocation);
+     * // A function that throws entities up in the air
+     * import { Entity } from '@minecraft/server';
      *
-     *   zombie.clearVelocity();
+     * function yeetEntity(entity: Entity) {
      *
-     *   // throw the zombie up in the air
-     *   zombie.applyImpulse({ x: 0, y: 0.5, z: 0 });
+     *     // Zero out the entity's velocity before applying impulse
+     *     entity.clearVelocity();
+     *
+     *     // throw the zombie up in the air
+     *     entity.applyImpulse({ x: 0, y: 15, z: 0 });
+     * }
      * ```
      */
     applyImpulse(vector: Vector3): void;
@@ -3260,20 +3443,24 @@ export class Entity {
      * @throws This function can throw errors.
      * @example bounceSkeletons.ts
      * ```typescript
-     *   let mobs = ["creeper", "skeleton", "sheep"];
+     * import { EntityQueryOptions, DimensionLocation } from '@minecraft/server';
      *
-     *   // create some sample mob data
-     *   for (let i = 0; i < 10; i++) {
-     *     overworld.spawnEntity(mobs[i % mobs.length], targetLocation);
-     *   }
+     * function mobParty(targetLocation: DimensionLocation) {
+     *     const mobs = ['creeper', 'skeleton', 'sheep'];
      *
-     *   let eqo: mc.EntityQueryOptions = {
-     *     type: "skeleton",
-     *   };
+     *     // create some sample mob data
+     *     for (let i = 0; i < 10; i++) {
+     *         targetLocation.dimension.spawnEntity(mobs[i % mobs.length], targetLocation);
+     *     }
+     *
+     *     const eqo: EntityQueryOptions = {
+     *         type: 'skeleton',
+     *     };
      *
-     *   for (let entity of overworld.getEntities(eqo)) {
-     *     entity.applyKnockback(0, 0, 0, 1);
-     *   }
+     *     for (const entity of targetLocation.dimension.getEntities(eqo)) {
+     *         entity.applyKnockback(0, 0, 0, 1);
+     *     }
+     * }
      * ```
      */
     applyKnockback(directionX: number, directionZ: number, horizontalStrength: number, verticalStrength: number): void;
@@ -3293,14 +3480,19 @@ export class Entity {
      * This function can't be called in read-only mode.
      *
      * @throws This function can throw errors.
-     * @example applyImpulse.ts
+     * @example yeetEntity.ts
      * ```typescript
-     *   const zombie = overworld.spawnEntity("minecraft:zombie", targetLocation);
+     * // A function that throws entities up in the air
+     * import { Entity } from '@minecraft/server';
+     *
+     * function yeetEntity(entity: Entity) {
      *
-     *   zombie.clearVelocity();
+     *     // Zero out the entity's velocity before applying impulse
+     *     entity.clearVelocity();
      *
-     *   // throw the zombie up in the air
-     *   zombie.applyImpulse({ x: 0, y: 0.5, z: 0 });
+     *     // throw the zombie up in the air
+     *     entity.applyImpulse({ x: 0, y: 15, z: 0 });
+     * }
      * ```
      */
     clearVelocity(): void;
@@ -3319,32 +3511,23 @@ export class Entity {
      * @returns
      * Returns whether the entity was on fire.
      * @throws This function can throw errors.
-     * @example setOnFire.ts
+     * @example setEntityOnFire.ts
      * ```typescript
-     *   const skelly = overworld.spawnEntity("minecraft:skeleton", targetLocation);
+     * import { world, Entity, EntityComponentTypes, system } from "@minecraft/server";
      *
-     *   skelly.setOnFire(20, true);
+     * function setAblaze(entity: Entity) {
+     *     entity.setOnFire(20, true);
      *
-     *   mc.system.runTimeout(() => {
-     *     let onfire = skelly.getComponent("onfire") as mc.EntityOnFireComponent;
-     *     log(onfire.onFireTicksRemaining + " fire ticks remaining.");
+     *     system.runTimeout(() => {
+     *         const onfire = entity.getComponent(EntityComponentTypes.OnFire);
+     *         if (onfire) {
+     *             world.sendMessage(`${onfire.onFireTicksRemaining} fire ticks remaining, extinguishing the entity.`);
+     *         }
+     *         // This will extinguish the entity
+     *         entity.extinguishFire(true);
+     *     }, 30); // Run in 30 ticks or ~1.5 seconds
      *
-     *     skelly.extinguishFire(true);
-     *     log("Never mind. Fire extinguished.");
-     *   }, 20);
-     * ```
-     * @example teleport.ts
-     * ```typescript
-     *   const cow = overworld.spawnEntity("minecraft:cow", targetLocation);
-     *
-     *   mc.system.runTimeout(() => {
-     *     cow.teleport(
-     *       { x: targetLocation.x + 2, y: targetLocation.y + 2, z: targetLocation.z + 2 },
-     *       {
-     *         facingLocation: targetLocation,
-     *       }
-     *     );
-     *   }, 20);
+     * }
      * ```
      */
     extinguishFire(useEffects?: boolean): boolean;
@@ -3513,13 +3696,19 @@ export class Entity {
      * @throws This function can throw errors.
      * @example getFireworkVelocity.ts
      * ```typescript
-     *   const fireworkRocket = overworld.spawnEntity("minecraft:fireworks_rocket", targetLocation);
+     * // A function that spawns fireworks and logs their velocity after 5 ticks
+     * import { DimensionLocation, system, world } from '@minecraft/server';
+     * import { MinecraftEntityTypes } from '@minecraft/vanilla-data';
+     *
+     * function spawnFireworks(location: DimensionLocation) {
+     *     const fireworkRocket = location.dimension.spawnEntity(MinecraftEntityTypes.FireworksRocket, location);
      *
-     *   mc.system.runTimeout(() => {
-     *     let velocity = fireworkRocket.getVelocity();
+     *     system.runTimeout(() => {
+     *         const velocity = fireworkRocket.getVelocity();
      *
-     *     log("Velocity of firework is: (x: " + velocity.x + ", y:" + velocity.y + ", z:" + velocity.z + ")");
-     *   }, 5);
+     *         world.sendMessage(`Velocity of firework is: ${velocity.x}, ${velocity.y}, ${velocity.z}`);
+     *     }, 5);
+     * }
      * ```
      */
     getVelocity(): Vector3;
@@ -3579,22 +3768,26 @@ export class Entity {
      * @throws This function can throw errors.
      * @example tagsQuery.ts
      * ```typescript
-     *   let mobs = ["creeper", "skeleton", "sheep"];
-     *
-     *   // create some sample mob data
-     *   for (let i = 0; i < 10; i++) {
-     *     let mobTypeId = mobs[i % mobs.length];
-     *     let entity = overworld.spawnEntity(mobTypeId, targetLocation);
-     *     entity.addTag("mobparty." + mobTypeId);
-     *   }
-     *
-     *   let eqo: mc.EntityQueryOptions = {
-     *     tags: ["mobparty.skeleton"],
-     *   };
-     *
-     *   for (let entity of overworld.getEntities(eqo)) {
-     *     entity.kill();
-     *   }
+     * import { EntityQueryOptions, DimensionLocation } from '@minecraft/server';
+     *
+     * function mobParty(targetLocation: DimensionLocation) {
+     *     const mobs = ['creeper', 'skeleton', 'sheep'];
+     *
+     *     // create some sample mob data
+     *     for (let i = 0; i < 10; i++) {
+     *         const mobTypeId = mobs[i % mobs.length];
+     *         const entity = targetLocation.dimension.spawnEntity(mobTypeId, targetLocation);
+     *         entity.addTag('mobparty.' + mobTypeId);
+     *     }
+     *
+     *     const eqo: EntityQueryOptions = {
+     *         tags: ['mobparty.skeleton'],
+     *     };
+     *
+     *     for (const entity of targetLocation.dimension.getEntities(eqo)) {
+     *         entity.kill();
+     *     }
+     * }
      * ```
      */
     kill(): boolean;
@@ -3755,32 +3948,23 @@ export class Entity {
      * is less than or equal to zero, the entity is wet or the
      * entity is immune to fire.
      * @throws This function can throw errors.
-     * @example setOnFire.ts
+     * @example setEntityOnFire.ts
      * ```typescript
-     *   const skelly = overworld.spawnEntity("minecraft:skeleton", targetLocation);
+     * import { world, Entity, EntityComponentTypes, system } from "@minecraft/server";
      *
-     *   skelly.setOnFire(20, true);
+     * function setAblaze(entity: Entity) {
+     *     entity.setOnFire(20, true);
      *
-     *   mc.system.runTimeout(() => {
-     *     let onfire = skelly.getComponent("onfire") as mc.EntityOnFireComponent;
-     *     log(onfire.onFireTicksRemaining + " fire ticks remaining.");
+     *     system.runTimeout(() => {
+     *         const onfire = entity.getComponent(EntityComponentTypes.OnFire);
+     *         if (onfire) {
+     *             world.sendMessage(`${onfire.onFireTicksRemaining} fire ticks remaining, extinguishing the entity.`);
+     *         }
+     *         // This will extinguish the entity
+     *         entity.extinguishFire(true);
+     *     }, 30); // Run in 30 ticks or ~1.5 seconds
      *
-     *     skelly.extinguishFire(true);
-     *     log("Never mind. Fire extinguished.");
-     *   }, 20);
-     * ```
-     * @example teleport.ts
-     * ```typescript
-     *   const cow = overworld.spawnEntity("minecraft:cow", targetLocation);
-     *
-     *   mc.system.runTimeout(() => {
-     *     cow.teleport(
-     *       { x: targetLocation.x + 2, y: targetLocation.y + 2, z: targetLocation.z + 2 },
-     *       {
-     *         facingLocation: targetLocation,
-     *       }
-     *     );
-     *   }, 20);
+     * }
      * ```
      */
     setOnFire(seconds: number, useEffects?: boolean): boolean;
@@ -3833,22 +4017,27 @@ export class Entity {
      * @throws This function can throw errors.
      * @example teleportMovement.ts
      * ```typescript
-     *   const pig = overworld.spawnEntity("minecraft:pig", targetLocation);
+     * import { world, system } from '@minecraft/server';
+     *
+     * const overworld = world.getDimension('overworld');
+     * const targetLocation = { x: 0, y: 0, z: 0 };
      *
-     *   let inc = 1;
-     *   let runId = mc.system.runInterval(() => {
+     * const pig = overworld.spawnEntity('minecraft:pig', targetLocation);
+     *
+     * let inc = 1;
+     * const runId = system.runInterval(() => {
      *     pig.teleport(
-     *       { x: targetLocation.x + inc / 4, y: targetLocation.y + inc / 4, z: targetLocation.z + inc / 4 },
-     *       {
-     *         facingLocation: targetLocation,
-     *       }
+     *         { x: targetLocation.x + inc / 4, y: targetLocation.y + inc / 4, z: targetLocation.z + inc / 4 },
+     *         {
+     *             facingLocation: targetLocation,
+     *         },
      *     );
      *
      *     if (inc > 100) {
-     *       mc.system.clearRun(runId);
+     *         system.clearRun(runId);
      *     }
      *     inc++;
-     *   }, 4);
+     * }, 4);
      * ```
      */
     teleport(location: Vector3, teleportOptions?: TeleportOptions): void;
@@ -3869,9 +4058,15 @@ export class Entity {
      * an error will be thrown.
      * @example triggerEvent.ts
      * ```typescript
-     *   const creeper = overworld.spawnEntity("minecraft:creeper", targetLocation);
+     * // A function that spawns a creeper and triggers it to explode immediately
+     * import { DimensionLocation } from '@minecraft/server';
+     * import { MinecraftEntityTypes } from '@minecraft/vanilla-data';
+     *
+     * function spawnExplodingCreeper(location: DimensionLocation) {
+     *     const creeper = location.dimension.spawnEntity(MinecraftEntityTypes.Creeper, location);
      *
-     *   creeper.triggerEvent("minecraft:start_exploding_forced");
+     *     creeper.triggerEvent('minecraft:start_exploding_forced');
+     * }
      * ```
      */
     triggerEvent(eventName: string): void;
@@ -4108,6 +4303,39 @@ export class EntityDieAfterEventSignal {
 /**
  * Provides access to a mob's equipment slots. This component
  * exists for all mob entities.
+ * @example givePlayerElytra.ts
+ * ```typescript
+ * // Gives the player Elytra
+ * import { EquipmentSlot, ItemStack, Player, EntityComponentTypes } from '@minecraft/server';
+ * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+ *
+ * function giveEquipment(player: Player) {
+ *     const equipmentCompPlayer = player.getComponent(EntityComponentTypes.Equippable);
+ *     if (equipmentCompPlayer) {
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Chest, new ItemStack(MinecraftItemTypes.Elytra));
+ *     }
+ * }
+ * ```
+ * @example givePlayerEquipment.ts
+ * ```typescript
+ * // Gives the player some equipment
+ * import { EquipmentSlot, ItemStack, Player, EntityComponentTypes } from '@minecraft/server';
+ * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+ *
+ * function giveEquipment(player: Player) {
+ *     const equipmentCompPlayer = player.getComponent(EntityComponentTypes.Equippable);
+ *     if (equipmentCompPlayer) {
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Head, new ItemStack(MinecraftItemTypes.GoldenHelmet));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Chest, new ItemStack(MinecraftItemTypes.IronChestplate));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Legs, new ItemStack(MinecraftItemTypes.DiamondLeggings));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Feet, new ItemStack(MinecraftItemTypes.NetheriteBoots));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Mainhand, new ItemStack(MinecraftItemTypes.WoodenSword));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Offhand, new ItemStack(MinecraftItemTypes.Shield));
+ *     } else {
+ *         console.warn('No equipment component found on player');
+ *     }
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityEquippableComponent extends EntityComponent {
@@ -4314,6 +4542,28 @@ export class EntityHealthChangedAfterEventSignal {
 
 /**
  * Defines the health properties of an entity.
+ * @example applyDamageThenHeal.ts
+ * ```typescript
+ * // A function that applies damage and then heals the entity
+ * import { Entity, EntityComponentTypes, system, world } from '@minecraft/server';
+ *
+ * function applyDamageAndHeal(entity: Entity) {
+ *     entity.applyDamage(19); // Many mobs have max damage of 20 so this is a near-death mob
+ *
+ *     system.runTimeout(() => {
+ *         const health = entity.getComponent(EntityComponentTypes.Health);
+ *         if (health) {
+ *             world.sendMessage(`Entity health before heal: ${health.currentValue}`);
+ *
+ *             health.resetToMaxValue();
+ *
+ *             world.sendMessage(`Entity after before heal: ${health.currentValue}`);
+ *         } else {
+ *             console.warn('Entity does not have health component');
+ *         }
+ *     }, 40); // Run in a few seconds (40 ticks)
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityHealthComponent extends EntityAttributeComponent {
@@ -4677,6 +4927,30 @@ export class EntityIsTamedComponent extends EntityComponent {
  * represents a free-floating item in the world. Lets you
  * retrieve the actual item stack contents via the itemStack
  * property.
+ * @example checkFeatherNearby.ts
+ * ```typescript
+ * import { DimensionLocation, EntityComponentTypes } from "@minecraft/server";
+ *
+ * // Returns true if a feather item entity is within 'distance' blocks of 'location'.
+ * function isFeatherNear(location: DimensionLocation, distance: number): boolean {
+ *     const items = location.dimension.getEntities({
+ *         location: location,
+ *         maxDistance: 20,
+ *     });
+ *
+ *     for (const item of items) {
+ *         const itemComp = item.getComponent(EntityComponentTypes.Item);
+ *
+ *         if (itemComp) {
+ *             if (itemComp.itemStack.typeId.endsWith('feather')) {
+ *                 return true;
+ *             }
+ *         }
+ *     }
+ *
+ *     return false;
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityItemComponent extends EntityComponent {
@@ -4828,6 +5102,24 @@ export class EntityMovementSkipComponent extends EntityBaseMovementComponent {
 /**
  * @beta
  * When present on an entity, this entity is on fire.
+ * @example setEntityOnFire.ts
+ * ```typescript
+ * import { world, Entity, EntityComponentTypes, system } from "@minecraft/server";
+ *
+ * function setAblaze(entity: Entity) {
+ *     entity.setOnFire(20, true);
+ *
+ *     system.runTimeout(() => {
+ *         const onfire = entity.getComponent(EntityComponentTypes.OnFire);
+ *         if (onfire) {
+ *             world.sendMessage(`${onfire.onFireTicksRemaining} fire ticks remaining, extinguishing the entity.`);
+ *         }
+ *         // This will extinguish the entity
+ *         entity.extinguishFire(true);
+ *     }, 30); // Run in 30 ticks or ~1.5 seconds
+ *
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class EntityOnFireComponent extends EntityComponent {
@@ -5004,6 +5296,18 @@ export class EntitySkinIdComponent extends EntityComponent {
 /**
  * Contains data related to an entity spawning within the
  * world.
+ * @example logEntitySpawnEvents.ts
+ * ```typescript
+ * // Register a new function that is called when a new entity is created.
+ * import { world, EntitySpawnAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.entitySpawn.subscribe((entityEvent: EntitySpawnAfterEvent) => {
+ *     const spawnLocation = entityEvent.entity.location;
+ *     world.sendMessage(
+ *         `New entity of type '${entityEvent.entity.typeId}' spawned at ${spawnLocation.x}, ${spawnLocation.y}, ${spawnLocation.z}!`,
+ *     );
+ * });
+ * ```
  */
 export class EntitySpawnAfterEvent {
     private constructor();
@@ -5026,6 +5330,18 @@ export class EntitySpawnAfterEvent {
 /**
  * Registers a script-based event handler for handling what
  * happens when an entity spawns.
+ * @example logEntitySpawnEvents.ts
+ * ```typescript
+ * // Register a new function that is called when a new entity is created.
+ * import { world, EntitySpawnAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.entitySpawn.subscribe((entityEvent: EntitySpawnAfterEvent) => {
+ *     const spawnLocation = entityEvent.entity.location;
+ *     world.sendMessage(
+ *         `New entity of type '${entityEvent.entity.typeId}' spawned at ${spawnLocation.x}, ${spawnLocation.y}, ${spawnLocation.z}!`,
+ *     );
+ * });
+ * ```
  */
 export class EntitySpawnAfterEventSignal {
     private constructor();
@@ -5038,21 +5354,6 @@ export class EntitySpawnAfterEventSignal {
      *
      * @param callback
      * Function that handles the spawn event.
-     * @example runEntitySpawnEvent.ts
-     * ```typescript
-     *   // register a new function that is called when a new entity is created.
-     *   mc.world.afterEvents.entitySpawn.subscribe((entityEvent: mc.EntitySpawnAfterEvent) => {
-     *     if (entityEvent && entityEvent.entity) {
-     *       log(`New entity of type '${entityEvent.entity.typeId}' created!`, 1);
-     *     } else {
-     *       log(`The entity event didn't work as expected.`, -1);
-     *     }
-     *   });
-     *
-     *   mc.system.runTimeout(() => {
-     *     createOldHorse(log, targetLocation);
-     *   }, 20);
-     * ```
      */
     subscribe(callback: (arg: EntitySpawnAfterEvent) => void): (arg: EntitySpawnAfterEvent) => void;
     /**
@@ -5486,19 +5787,23 @@ export class ItemDurabilityComponent extends ItemComponent {
     /**
      * @remarks
      * Returns the maximum chance that this item would be damaged
-     * using the damageRange property, given an unbreaking level.
+     * using the damageRange property, given an unbreaking
+     * enchantment level.
      *
      * This function can't be called in read-only mode.
      *
+     * @param unbreakingEnchantmentLevel
+     * Unbreaking factor to consider in factoring the damage
+     * chance. Incoming unbreaking parameter must be within the
+     * range [0, 3].
      * @throws This function can throw errors.
      */
     getDamageChance(unbreakingEnchantmentLevel?: number): number;
     /**
      * @remarks
-     * Returns the min and max variables used by the damage chance
-     * formula:
-     * chance = (min + ((max - min) / (unbreaking + 1)))
-     *
+     * A range of numbers that is used to calculate the damage
+     * chance for an item. The damage chance will fall within this
+     * range.
      *
      * This function can't be called in read-only mode.
      *
@@ -5609,6 +5914,58 @@ export class ItemReleaseUseAfterEventSignal {
 
 /**
  * Defines a collection of items.
+ * @example givePlayerIronFireSword.ts
+ * ```typescript
+ * // Spawns a bunch of item stacks
+ * import { ItemComponentTypes, ItemStack, Player } from '@minecraft/server';
+ * import { MinecraftItemTypes, MinecraftEnchantmentTypes } from '@minecraft/vanilla-data';
+ *
+ * function giveFireSword(player: Player) {
+ *     const ironFireSword = new ItemStack(MinecraftItemTypes.DiamondSword, 1);
+ *
+ *     const enchantments = ironFireSword?.getComponent(ItemComponentTypes.Enchantable);
+ *     if (enchantments) {
+ *         enchantments.addEnchantment({ type: MinecraftEnchantmentTypes.FireAspect, level: 1 });
+ *     }
+ *
+ *     const inventory = player.getComponent('minecraft:inventory');
+ *     if (inventory === undefined || inventory.container === undefined) {
+ *         return;
+ *     }
+ *     inventory.container.setItem(0, ironFireSword);
+ * }
+ * ```
+ * @example givePlayerEquipment.ts
+ * ```typescript
+ * // Gives the player some equipment
+ * import { EquipmentSlot, ItemStack, Player, EntityComponentTypes } from '@minecraft/server';
+ * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+ *
+ * function giveEquipment(player: Player) {
+ *     const equipmentCompPlayer = player.getComponent(EntityComponentTypes.Equippable);
+ *     if (equipmentCompPlayer) {
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Head, new ItemStack(MinecraftItemTypes.GoldenHelmet));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Chest, new ItemStack(MinecraftItemTypes.IronChestplate));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Legs, new ItemStack(MinecraftItemTypes.DiamondLeggings));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Feet, new ItemStack(MinecraftItemTypes.NetheriteBoots));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Mainhand, new ItemStack(MinecraftItemTypes.WoodenSword));
+ *         equipmentCompPlayer.setEquipment(EquipmentSlot.Offhand, new ItemStack(MinecraftItemTypes.Shield));
+ *     } else {
+ *         console.warn('No equipment component found on player');
+ *     }
+ * }
+ * ```
+ * @example spawnFeatherItem.ts
+ * ```typescript
+ * // Spawns a feather at a location
+ * import { ItemStack, DimensionLocation } from '@minecraft/server';
+ * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+ *
+ * function spawnFeather(location: DimensionLocation) {
+ *     const featherItem = new ItemStack(MinecraftItemTypes.Feather, 1);
+ *     location.dimension.spawnItem(featherItem, location);
+ * }
+ * ```
  */
 export class ItemStack {
     /**
@@ -5701,6 +6058,14 @@ export class ItemStack {
      * the range of 1-255.
      */
     constructor(itemType: ItemType | string, amount?: number);
+    /**
+     * @beta
+     * @remarks
+     * Clears all dynamic properties that have been set on this
+     * item stack.
+     *
+     */
+    clearDynamicProperties(): void;
     /**
      * @remarks
      * Creates an exact copy of the item stack, including any
@@ -5743,10 +6108,24 @@ export class ItemStack {
      * otherwise undefined.
      * @example durability.ts
      * ```typescript
-     * // Get the maximum durability of a custom sword item
-     * const itemStack = new ItemStack('custom:sword');
-     * const durability = itemStack.getComponent(ItemComponentTypes.Durability);
-     * const maxDurability = durability.maxDurability;
+     * // Gives a player a half-damaged diamond sword
+     * import { ItemStack, Player, ItemComponentTypes, EntityComponentTypes } from '@minecraft/server';
+     * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+     *
+     * function giveHurtDiamondSword(player: Player) {
+     *     const hurtDiamondSword = new ItemStack(MinecraftItemTypes.DiamondSword);
+     *     const durabilityComponent = hurtDiamondSword.getComponent(ItemComponentTypes.Durability);
+     *     if (durabilityComponent !== undefined) {
+     *         durabilityComponent.damage = durabilityComponent.maxDurability / 2;
+     *     }
+     *
+     *     const inventory = player.getComponent(EntityComponentTypes.Inventory);
+     *     if (inventory === undefined || inventory.container === undefined) {
+     *         return;
+     *     }
+     *
+     *     inventory.container.addItem(hurtDiamondSword);
+     * }
      * ```
      */
     getComponent(componentId: string): ItemComponent | undefined;
@@ -5758,25 +6137,59 @@ export class ItemStack {
      */
     getComponents(): ItemComponent[];
     /**
+     * @beta
      * @remarks
-     * Returns the lore value - a secondary display string - for an
-     * ItemStack.
+     * Returns a property value.
      *
+     * @param identifier
+     * The property identifier.
      * @returns
-     * An array of lore lines. If the item does not have lore,
-     * returns an empty array.
+     * Returns the value for the property, or undefined if the
+     * property has not been set.
      */
-    getLore(): string[];
+    getDynamicProperty(identifier: string): boolean | number | string | Vector3 | undefined;
     /**
+     * @beta
      * @remarks
-     * Returns a set of tags associated with this item stack.
+     * Returns the available set of dynamic property identifiers
+     * that have been used on this entity.
      *
+     * @returns
+     * A string array of the dynamic properties set on this entity.
      */
-    getTags(): string[];
+    getDynamicPropertyIds(): string[];
     /**
+     * @beta
      * @remarks
-     * Returns true if the specified component is present on this
-     * item stack.
+     * Returns the total size, in bytes, of all the dynamic
+     * properties that are currently stored for this entity. This
+     * includes the size of both the key and the value.  This can
+     * be useful for diagnosing performance warning signs - if, for
+     * example, an entity has many megabytes of associated dynamic
+     * properties, it may be slow to load on various devices.
+     *
+     */
+    getDynamicPropertyTotalByteCount(): number;
+    /**
+     * @remarks
+     * Returns the lore value - a secondary display string - for an
+     * ItemStack.
+     *
+     * @returns
+     * An array of lore lines. If the item does not have lore,
+     * returns an empty array.
+     */
+    getLore(): string[];
+    /**
+     * @remarks
+     * Returns a set of tags associated with this item stack.
+     *
+     */
+    getTags(): string[];
+    /**
+     * @remarks
+     * Returns true if the specified component is present on this
+     * item stack.
      *
      * @param componentId
      * The identifier of the component (e.g., 'minecraft:food') to
@@ -5825,9 +6238,24 @@ export class ItemStack {
      * Throws if any of the provided block identifiers are invalid.
      * @example example.ts
      * ```typescript
+     * const specialPickaxe = new ItemStack('minecraft:diamond_pickaxe');
+     * specialPickaxe.setCanDestroy(['minecraft:cobblestone', 'minecraft:obsidian']);
+     *
      * // Creates a diamond pickaxe that can destroy cobblestone and obsidian
-     * const specialPickaxe = new ItemStack("minecraft:diamond_pickaxe");
-     * specialPickaxe.setCanDestroy(["minecraft:cobblestone", "minecraft:obsidian"]);
+     * import { ItemStack, Player } from '@minecraft/server';
+     * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+     *
+     * function giveRestrictedPickaxe(player: Player) {
+     *     const specialPickaxe = new ItemStack(MinecraftItemTypes.DiamondPickaxe);
+     *     specialPickaxe.setCanPlaceOn([MinecraftItemTypes.Cobblestone, MinecraftItemTypes.Obsidian]);
+     *
+     *     const inventory = player.getComponent('inventory');
+     *     if (inventory === undefined || inventory.container === undefined) {
+     *         return;
+     *     }
+     *
+     *     inventory.container.addItem(specialPickaxe);
+     * }
      * ```
      */
     setCanDestroy(blockIdentifiers?: string[]): void;
@@ -5847,11 +6275,37 @@ export class ItemStack {
      * @example example.ts
      * ```typescript
      * // Creates a gold block that can be placed on grass and dirt
-     * const specialGoldBlock = new ItemStack("minecraft:gold_block");
-     * specialPickaxe.setCanPlaceOn(["minecraft:grass", "minecraft:dirt"]);
+     * import { ItemStack, Player, EntityComponentTypes } from '@minecraft/server';
+     * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+     *
+     * function giveRestrictedGoldBlock(player: Player) {
+     *     const specialGoldBlock = new ItemStack(MinecraftItemTypes.GoldBlock);
+     *     specialGoldBlock.setCanPlaceOn([MinecraftItemTypes.Grass, MinecraftItemTypes.Dirt]);
+     *
+     *     const inventory = player.getComponent(EntityComponentTypes.Inventory);
+     *     if (inventory === undefined || inventory.container === undefined) {
+     *         return;
+     *     }
+     *
+     *     inventory.container.addItem(specialGoldBlock);
+     * }
      * ```
      */
     setCanPlaceOn(blockIdentifiers?: string[]): void;
+    /**
+     * @beta
+     * @remarks
+     * Sets a specified property to a value. Note: This function
+     * only works with non-stackable items.
+     *
+     * @param identifier
+     * The property identifier.
+     * @param value
+     * Data value of the property to set.
+     * @throws
+     * Throws if the item stack is stackable.
+     */
+    setDynamicProperty(identifier: string, value?: boolean | number | string | Vector3): void;
     /**
      * @remarks
      * Sets the lore value - a secondary display string - for an
@@ -5867,28 +6321,24 @@ export class ItemStack {
      * @throws This function can throw errors.
      * @example diamondAwesomeSword.ts
      * ```typescript
-     *   const diamondAwesomeSword = new mc.ItemStack(mc.MinecraftItemTypes.diamondSword, 1);
-     *   let players = mc.world.getAllPlayers();
-     *
-     *   diamondAwesomeSword.setLore(["§c§lDiamond Sword of Awesome§r", "+10 coolness", "§p+4 shiny§r"]);
-     *
-     *   // hover over/select the item in your inventory to see the lore.
-     *   const inventory = players[0].getComponent("inventory") as mc.EntityInventoryComponent;
-     *   inventory.container.setItem(0, diamondAwesomeSword);
-     *
-     *   let item = inventory.container.getItem(0);
+     * import { EntityComponentTypes, ItemStack, Player } from '@minecraft/server';
+     * import { MinecraftItemTypes } from '@minecraft/vanilla-data';
+     *
+     * function giveAwesomeSword(player: Player) {
+     *     const diamondAwesomeSword = new ItemStack(MinecraftItemTypes.DiamondSword, 1);
+     *     diamondAwesomeSword.setLore([
+     *         '§c§lDiamond Sword of Awesome§r',
+     *          '+10 coolness', '§p+4 shiny§r'
+     *     ]);
+     *
+     *     // hover over/select the item in your inventory to see the lore.
+     *     const inventory = player.getComponent(EntityComponentTypes.Inventory);
+     *     if (inventory === undefined || inventory.container === undefined) {
+     *         return;
+     *     }
      *
-     *   if (item) {
-     *     let enchants = item.getComponent("minecraft:enchantments") as mc.ItemEnchantsComponent;
-     *     let knockbackEnchant = new mc.Enchantment("knockback", 3);
-     *     enchants.enchantments.addEnchantment(knockbackEnchant);
-     *   }
-     * ```
-     * @example multilineLore.ts
-     * ```typescript
-     * // Set the lore of an item to multiple lines of text
-     * const itemStack = new ItemStack("minecraft:diamond_sword");
-     * itemStack.setLore(["Line 1", "Line 2", "Line 3"]);
+     *     inventory.container.setItem(0, diamondAwesomeSword);
+     * }
      * ```
      */
     setLore(loreList?: string[]): void;
@@ -6338,6 +6788,17 @@ export class ItemUseOnBeforeEventSignal {
 /**
  * Contains information related to changes to a lever
  * activating or deactivating.
+ * @example leverActionEvent.ts
+ * ```typescript
+ * import { world, system, LeverActionAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.leverAction.subscribe((leverActivateEvent: LeverActionAfterEvent) => {
+ *     console.warn(
+ *         `Lever event at ${system.currentTick} with power: ${leverActivateEvent.block.getRedstonePower()}`,
+ *     );
+ * });
+ *
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class LeverActionAfterEvent extends BlockEvent {
@@ -6360,6 +6821,17 @@ export class LeverActionAfterEvent extends BlockEvent {
 /**
  * Manages callbacks that are connected to lever moves
  * (activates or deactivates).
+ * @example leverActionEvent.ts
+ * ```typescript
+ * import { world, system, LeverActionAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.leverAction.subscribe((leverActivateEvent: LeverActionAfterEvent) => {
+ *     console.warn(
+ *         `Lever event at ${system.currentTick} with power: ${leverActivateEvent.block.getRedstonePower()}`,
+ *     );
+ * });
+ *
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class LeverActionAfterEventSignal extends ILeverActionAfterEventSignal {
@@ -6480,6 +6952,16 @@ export class MolangVariableMap {
  * @beta
  * Contains information related to changes to a piston
  * expanding or retracting.
+ * @example pistonAfterEvent.ts
+ * ```typescript
+ * import { world, system, PistonActivateAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.pistonActivate.subscribe((pistonEvent: PistonActivateAfterEvent) => {
+ *     console.warn(
+ *         `Piston event at ${system.currentTick} ${(pistonEvent.piston.isMoving ? ' Moving' : 'Not moving')} with state: ${pistonEvent.piston.state}`,
+ *     );
+ * });
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class PistonActivateAfterEvent extends BlockEvent {
@@ -6501,58 +6983,23 @@ export class PistonActivateAfterEvent extends BlockEvent {
 /**
  * @beta
  * Manages callbacks that are connected to piston activations.
+ * @example pistonAfterEvent.ts
+ * ```typescript
+ * import { world, system, PistonActivateAfterEvent } from '@minecraft/server';
+ *
+ * world.afterEvents.pistonActivate.subscribe((pistonEvent: PistonActivateAfterEvent) => {
+ *     console.warn(
+ *         `Piston event at ${system.currentTick} ${(pistonEvent.piston.isMoving ? ' Moving' : 'Not moving')} with state: ${pistonEvent.piston.state}`,
+ *     );
+ * });
+ * ```
  */
 export class PistonActivateAfterEventSignal {
     private constructor();
     /**
      * @remarks
-     * Adds a callback that will be called when a piston expands or
-     * retracts.
-     *
      * This function can't be called in read-only mode.
      *
-     * @example pistonAfterEvent.ts
-     * ```typescript
-     * // set up a couple of piston blocks
-     * let piston = overworld.getBlock(targetLocation);
-     * let button = overworld.getBlock({
-     *   x: targetLocation.x,
-     *   y: targetLocation.y + 1,
-     *   z: targetLocation.z,
-     * });
-     *
-     * if (piston === undefined || button === undefined) {
-     *   log("Could not find block at location.");
-     *   return -1;
-     * }
-     *
-     * piston.setPermutation(
-     *   mc.BlockPermutation.resolve("piston").withState("facing_direction", 3)
-     * );
-     * button.setPermutation(
-     *   mc.BlockPermutation.resolve("acacia_button").withState("facing_direction", 1)
-     * );
-     *
-     * mc.world.afterEvents.pistonActivate.subscribe(
-     *   (pistonEvent: mc.PistonActivateAfterEvent) => {
-     *     let eventLoc = pistonEvent.piston.block.location;
-     *
-     *     if (
-     *       eventLoc.x === targetLocation.x &&
-     *       eventLoc.y === targetLocation.y &&
-     *       eventLoc.z === targetLocation.z
-     *     ) {
-     *       log(
-     *         "Piston event at " +
-     *           mc.system.currentTick +
-     *           (pistonEvent.piston.isMoving ? " Moving" : "") +
-     *           " State: " +
-     *           pistonEvent.piston.state
-     *       );
-     *     }
-     *   }
-     * );
-     * ```
      */
     subscribe(callback: (arg: PistonActivateAfterEvent) => void): (arg: PistonActivateAfterEvent) => void;
     /**
@@ -6700,30 +7147,6 @@ export class Player extends Entity {
      * @param soundOptions
      * Additional optional options for the sound.
      * @throws This function can throw errors.
-     * @example playMusicAndSound.ts
-     * ```typescript
-     *   let players = mc.world.getPlayers();
-     *
-     *   const musicOptions: mc.MusicOptions = {
-     *     fade: 0.5,
-     *     loop: true,
-     *     volume: 1.0,
-     *   };
-     *   mc.world.playMusic("music.menu", musicOptions);
-     *
-     *   const worldSoundOptions: mc.WorldSoundOptions = {
-     *     pitch: 0.5,
-     *     volume: 4.0,
-     *   };
-     *   mc.world.playSound("ambient.weather.thunder", targetLocation, worldSoundOptions);
-     *
-     *   const playerSoundOptions: mc.PlayerSoundOptions = {
-     *     pitch: 1.0,
-     *     volume: 1.0,
-     *   };
-     *
-     *   players[0].playSound("bucket.fill_water", playerSoundOptions);
-     * ```
      */
     playSound(soundId: string, soundOptions?: PlayerSoundOptions): void;
     /**
@@ -6745,43 +7168,32 @@ export class Player extends Entity {
      * This method can throw if the provided {@link RawMessage} is
      * in an invalid format. For example, if an empty `name` string
      * is provided to `score`.
-     * @example nestedTranslation.ts
+     * @example sendMessagesToPlayer.ts
      * ```typescript
-     * // Displays "Apple or Coal"
-     * let rawMessage = {
-     *   translate: "accessibility.list.or.two",
-     *   with: { rawtext: [{ translate: "item.apple.name" }, { translate: "item.coal.name" }] },
-     * };
-     * player.sendMessage(rawMessage);
-     * ```
-     * @example scoreWildcard.ts
-     * ```typescript
-     * // Displays the player's score for objective "obj". Each player will see their own score.
-     * const rawMessage = { score: { name: "*", objective: "obj" } };
-     * world.sendMessage(rawMessage);
-     * ```
-     * @example sendBasicMessage.ts
-     * ```typescript
-     *   let players = mc.world.getPlayers();
+     * import { Player } from "@minecraft/server";
      *
-     *   players[0].sendMessage("Hello World!");
-     * ```
-     * @example sendTranslatedMessage.ts
-     * ```typescript
-     *   let players = mc.world.getPlayers();
+     * function sendPlayerMessages(player: Player) {
+     *     // Displays "First or Second"
+     *     const rawMessage = { translate: 'accessibility.list.or.two', with: ['First', 'Second'] };
+     *     player.sendMessage(rawMessage);
      *
-     *   players[0].sendMessage({ translate: "authentication.welcome", with: ["Amazing Player 1"] });
-     * ```
-     * @example simpleString.ts
-     * ```typescript
-     * // Displays "Hello, world!"
-     * world.sendMessage("Hello, world!");
-     * ```
-     * @example translation.ts
-     * ```typescript
-     * // Displays "First or Second"
-     * const rawMessage = { translate: "accessibility.list.or.two", with: ["First", "Second"] };
-     * player.sendMessage(rawMessage);
+     *     // Displays "Hello, world!"
+     *     player.sendMessage('Hello, world!');
+     *
+     *     // Displays "Welcome, Amazing Player 1!"
+     *     player.sendMessage({ translate: 'authentication.welcome', with: ['Amazing Player 1'] });
+     *
+     *     // Displays the player's score for objective "obj". Each player will see their own score.
+     *     const rawMessageWithScore = { score: { name: '*', objective: 'obj' } };
+     *     player.sendMessage(rawMessageWithScore);
+     *
+     *     // Displays "Apple or Coal"
+     *     const rawMessageWithNestedTranslations = {
+     *         translate: 'accessibility.list.or.two',
+     *         with: { rawtext: [{ translate: 'item.apple.name' }, { translate: 'item.coal.name' }] },
+     *     };
+     *     player.sendMessage(rawMessageWithNestedTranslations);
+     * }
      * ```
      */
     sendMessage(message: (RawMessage | string)[] | RawMessage | string): void;
@@ -7925,6 +8337,51 @@ export class ScoreboardScoreInfo {
 /**
  * Contains information about user interface elements that are
  * showing up on the screen.
+ * @example setTitle.ts
+ * ```typescript
+ * import { world } from '@minecraft/server';
+ *
+ * world.afterEvents.playerSpawn.subscribe((event) => {
+ *     event.player.onScreenDisplay.setTitle('§o§6You respawned!§r');
+ * });
+ * ```
+ * @example setTitleAndSubtitle.ts
+ * ```typescript
+ * import { world } from '@minecraft/server';
+ *
+ * world.afterEvents.playerSpawn.subscribe((event) => {
+ *     event.player.onScreenDisplay.setTitle('You respawned', {
+ *         stayDuration: 100,
+ *         fadeInDuration: 2,
+ *         fadeOutDuration: 4,
+ *         subtitle: 'Try not to die next time!',
+ *     });
+ * });
+ * ```
+ * @example titleCountdown.ts
+ * ```typescript
+ * import { world, system } from '@minecraft/server';
+ *
+ * world.afterEvents.playerSpawn.subscribe(event => {
+ *     event.player.onScreenDisplay.setTitle('Get ready!', {
+ *         stayDuration: 220,
+ *         fadeInDuration: 2,
+ *         fadeOutDuration: 4,
+ *         subtitle: '10',
+ *     });
+ *
+ *     let countdown = 10;
+ *
+ *     const intervalId = system.runInterval(() => {
+ *         countdown--;
+ *         event.player.onScreenDisplay.updateSubtitle(countdown.toString());
+ *
+ *         if (countdown == 0) {
+ *             system.clearRun(intervalId);
+ *         }
+ *     }, 20);
+ * });
+ * ```
  */
 export class ScreenDisplay {
     private constructor();
@@ -7957,44 +8414,50 @@ export class ScreenDisplay {
      * This function can't be called in read-only mode.
      *
      * @throws This function can throw errors.
-     * @example countdown.ts
-     * ```typescript
-     *   let players = mc.world.getPlayers();
-     *
-     *   players[0].onScreenDisplay.setTitle("Get ready!", {
-     *     stayDuration: 220,
-     *     fadeInDuration: 2,
-     *     fadeOutDuration: 4,
-     *     subtitle: "10",
-     *   });
-     *
-     *   let countdown = 10;
-     *
-     *   let intervalId = mc.system.runInterval(() => {
-     *     countdown--;
-     *     players[0].onScreenDisplay.updateSubtitle(countdown.toString());
-     *
-     *     if (countdown == 0) {
-     *       mc.system.clearRun(intervalId);
-     *     }
-     *   }, 20);
-     * ```
      * @example setTitle.ts
      * ```typescript
-     *   let players = mc.world.getPlayers();
+     * import { world } from '@minecraft/server';
      *
-     *   players[0].onScreenDisplay.setTitle("§o§6Fancy Title§r");
+     * world.afterEvents.playerSpawn.subscribe((event) => {
+     *     event.player.onScreenDisplay.setTitle('§o§6You respawned!§r');
+     * });
      * ```
      * @example setTitleAndSubtitle.ts
      * ```typescript
-     *   let players = mc.world.getPlayers();
-     *
-     *   players[0].onScreenDisplay.setTitle("Chapter 1", {
-     *     stayDuration: 100,
-     *     fadeInDuration: 2,
-     *     fadeOutDuration: 4,
-     *     subtitle: "Trouble in Block Town",
-     *   });
+     * import { world } from '@minecraft/server';
+     *
+     * world.afterEvents.playerSpawn.subscribe((event) => {
+     *     event.player.onScreenDisplay.setTitle('You respawned', {
+     *         stayDuration: 100,
+     *         fadeInDuration: 2,
+     *         fadeOutDuration: 4,
+     *         subtitle: 'Try not to die next time!',
+     *     });
+     * });
+     * ```
+     * @example titleCountdown.ts
+     * ```typescript
+     * import { world, system } from '@minecraft/server';
+     *
+     * world.afterEvents.playerSpawn.subscribe(event => {
+     *     event.player.onScreenDisplay.setTitle('Get ready!', {
+     *         stayDuration: 220,
+     *         fadeInDuration: 2,
+     *         fadeOutDuration: 4,
+     *         subtitle: '10',
+     *     });
+     *
+     *     let countdown = 10;
+     *
+     *     const intervalId = system.runInterval(() => {
+     *         countdown--;
+     *         event.player.onScreenDisplay.updateSubtitle(countdown.toString());
+     *
+     *         if (countdown == 0) {
+     *             system.clearRun(intervalId);
+     *         }
+     *     }, 20);
+     * });
      * ```
      */
     setTitle(title: (RawMessage | string)[] | RawMessage | string, options?: TitleDisplayOptions): void;
@@ -8107,7 +8570,7 @@ export class System {
     /**
      * @remarks
      * Cancels the execution of a function run that was previously
-     * scheduled via the `run` function.
+     * scheduled via {@link System.run}.
      *
      */
     clearRun(runId: number): void;
@@ -8125,18 +8588,22 @@ export class System {
      * function to cancel the execution of this run.
      * @example trapTick.ts
      * ```typescript
-     *   const overworld = mc.world.getDimension("overworld");
+     * import { system, world } from '@minecraft/server';
      *
-     *   try {
-     *     // Minecraft runs at 20 ticks per second.
-     *     if (mc.system.currentTick % 1200 === 0) {
-     *       mc.world.sendMessage("Another minute passes...");
+     * function printEveryMinute() {
+     *     try {
+     *         // Minecraft runs at 20 ticks per second.
+     *         if (system.currentTick % 1200 === 0) {
+     *             world.sendMessage('Another minute passes...');
+     *         }
+     *     } catch (e) {
+     *         console.warn('Error: ' + e);
      *     }
-     *   } catch (e) {
-     *     console.warn("Error: " + e);
-     *   }
      *
-     *   mc.system.run(trapTick);
+     *     system.run(printEveryMinute);
+     * }
+     *
+     * printEveryMinute();
      * ```
      */
     run(callback: () => void): number;
@@ -8154,11 +8621,13 @@ export class System {
      * to stop the run of this function on an interval.
      * @example every30Seconds.ts
      * ```typescript
-     *   let intervalRunIdentifier = Math.floor(Math.random() * 10000);
+     * import { system, world } from '@minecraft/server';
+     *
+     * const intervalRunIdentifier = Math.floor(Math.random() * 10000);
      *
-     *   mc.system.runInterval(() => {
-     *     mc.world.sendMessage("This is an interval run " + intervalRunIdentifier + " sending a message every 30 seconds.");
-     *   }, 600);
+     * system.runInterval(() => {
+     *     world.sendMessage('This is an interval run ' + intervalRunIdentifier + ' sending a message every 30 seconds.');
+     * }, 600);
      * ```
      */
     runInterval(callback: () => void, tickInterval?: number): number;
@@ -8256,6 +8725,37 @@ export class TargetBlockHitAfterEventSignal {
 
 /**
  * Contains information related to changes to a trip wire trip.
+ * @example tripWireTripEvent.ts
+ * ```typescript
+ * import { Vector3, world, BlockPermutation, TripWireTripAfterEvent, system } from '@minecraft/server';
+ *
+ * const overworld = world.getDimension('overworld');
+ * const targetLocation: Vector3 = { x: 0, y: 0, z: 0 };
+ *
+ * // set up a tripwire
+ * const redstone = overworld.getBlock({ x: targetLocation.x, y: targetLocation.y - 1, z: targetLocation.z });
+ * const tripwire = overworld.getBlock(targetLocation);
+ *
+ * if (redstone === undefined || tripwire === undefined) {
+ *     console.warn('Could not find block at location.');
+ * } else {
+ *
+ * redstone.setPermutation(BlockPermutation.resolve('redstone_block'));
+ * tripwire.setPermutation(BlockPermutation.resolve('tripwire'));
+ *
+ * world.afterEvents.tripWireTrip.subscribe((tripWireTripEvent: TripWireTripAfterEvent) => {
+ *     const eventLoc = tripWireTripEvent.block.location;
+ *
+ *     if (eventLoc.x === targetLocation.x && eventLoc.y === targetLocation.y && eventLoc.z === targetLocation.z) {
+ *         console.warn(
+ *             'Tripwire trip event at tick ' +
+ *                 system.currentTick +
+ *                 (tripWireTripEvent.sources.length > 0 ? ' by entity ' + tripWireTripEvent.sources[0].id : ''),
+ *         );
+ *     }
+ * });
+ * }
+ * ```
  */
 // @ts-ignore Class inheritance allowed for native defined classes
 export class TripWireTripAfterEvent extends BlockEvent {
@@ -8277,6 +8777,37 @@ export class TripWireTripAfterEvent extends BlockEvent {
 /**
  * Manages callbacks that are connected to when a trip wire is
  * tripped.
+ * @example tripWireTripEvent.ts
+ * ```typescript
+ * import { Vector3, world, BlockPermutation, TripWireTripAfterEvent, system } from '@minecraft/server';
+ *
+ * const overworld = world.getDimension('overworld');
+ * const targetLocation: Vector3 = { x: 0, y: 0, z: 0 };
+ *
+ * // set up a tripwire
+ * const redstone = overworld.getBlock({ x: targetLocation.x, y: targetLocation.y - 1, z: targetLocation.z });
+ * const tripwire = overworld.getBlock(targetLocation);
+ *
+ * if (redstone === undefined || tripwire === undefined) {
+ *     console.warn('Could not find block at location.');
+ * } else {
+ *
+ * redstone.setPermutation(BlockPermutation.resolve('redstone_block'));
+ * tripwire.setPermutation(BlockPermutation.resolve('tripwire'));
+ *
+ * world.afterEvents.tripWireTrip.subscribe((tripWireTripEvent: TripWireTripAfterEvent) => {
+ *     const eventLoc = tripWireTripEvent.block.location;
+ *
+ *     if (eventLoc.x === targetLocation.x && eventLoc.y === targetLocation.y && eventLoc.z === targetLocation.z) {
+ *         console.warn(
+ *             'Tripwire trip event at tick ' +
+ *                 system.currentTick +
+ *                 (tripWireTripEvent.sources.length > 0 ? ' by entity ' + tripWireTripEvent.sources[0].id : ''),
+ *         );
+ *     }
+ * });
+ * }
+ * ```
  */
 export class TripWireTripAfterEventSignal {
     private constructor();
@@ -8314,7 +8845,17 @@ export class WeatherChangeAfterEvent {
      *
      */
     readonly dimension: string;
+    /**
+     * @remarks
+     * The weather type after the weather was changed.
+     *
+     */
     readonly newWeather: WeatherType;
+    /**
+     * @remarks
+     * The weather type before the weather was changed.
+     *
+     */
     readonly previousWeather: WeatherType;
 }
 
@@ -8436,57 +8977,72 @@ export class World {
      * @throws
      * Throws if the given dynamic property identifier is not
      * defined.
-     * @example incrementProperty.ts
+     * @example incrementDynamicProperty.ts
      * ```typescript
-     *   let number = mc.world.getDynamicProperty("samplelibrary:number");
+     * import * as mc from '@minecraft/server';
      *
-     *   log("Current value is: " + number);
+     * function incrementProperty(propertyName: string): boolean {
+     *     let number = mc.world.getDynamicProperty(propertyName);
      *
-     *   if (number === undefined) {
-     *     number = 0;
-     *   }
+     *     console.warn('Current value is: ' + number);
      *
-     *   if (typeof number !== "number") {
-     *     log("Number is of an unexpected type.");
-     *     return -1;
-     *   }
+     *     if (number === undefined) {
+     *         number = 0;
+     *     }
+     *
+     *     if (typeof number !== 'number') {
+     *         console.warn('Number is of an unexpected type.');
+     *         return false;
+     *     }
      *
-     *   mc.world.setDynamicProperty("samplelibrary:number", number + 1);
+     *     mc.world.setDynamicProperty(propertyName, number + 1);
+     *     return true;
+     * }
+     *
+     * incrementProperty('samplelibrary:number');
      * ```
-     * @example incrementPropertyInJsonBlob.ts
+     * @example incrementDynamicPropertyInJsonBlob.ts
      * ```typescript
-     *   let paintStr = mc.world.getDynamicProperty("samplelibrary:longerjson");
-     *   let paint: { color: string; intensity: number } | undefined = undefined;
+     * import * as mc from '@minecraft/server';
      *
-     *   log("Current value is: " + paintStr);
+     * function updateWorldProperty(propertyName: string): boolean {
+     *     let paintStr = mc.world.getDynamicProperty(propertyName);
+     *     let paint: { color: string; intensity: number } | undefined = undefined;
      *
-     *   if (paintStr === undefined) {
-     *     paint = {
-     *       color: "purple",
-     *       intensity: 0,
-     *     };
-     *   } else {
-     *     if (typeof paintStr !== "string") {
-     *       log("Paint is of an unexpected type.");
-     *       return -1;
+     *     console.log('Current value is: ' + paintStr);
+     *
+     *     if (paintStr === undefined) {
+     *         paint = {
+     *             color: 'purple',
+     *             intensity: 0,
+     *         };
+     *     } else {
+     *         if (typeof paintStr !== 'string') {
+     *             console.warn('Paint is of an unexpected type.');
+     *             return false;
+     *         }
+     *
+     *         try {
+     *             paint = JSON.parse(paintStr);
+     *         } catch (e) {
+     *             console.warn('Error parsing serialized struct.');
+     *             return false;
+     *         }
      *     }
      *
-     *     try {
-     *       paint = JSON.parse(paintStr);
-     *     } catch (e) {
-     *       log("Error parsing serialized struct.");
-     *       return -1;
+     *     if (!paint) {
+     *         console.warn('Error parsing serialized struct.');
+     *         return false;
      *     }
-     *   }
      *
-     *   if (!paint) {
-     *     log("Error parsing serialized struct.");
-     *     return -1;
-     *   }
+     *     paint.intensity++;
+     *     paintStr = JSON.stringify(paint); // be very careful to ensure your serialized JSON str cannot exceed limits
+     *     mc.world.setDynamicProperty(propertyName, paintStr);
+     *
+     *     return true;
+     * }
      *
-     *   paint.intensity++;
-     *   paintStr = JSON.stringify(paint); // be very careful to ensure your serialized JSON str cannot exceed limits
-     *   mc.world.setDynamicProperty("samplelibrary:longerjson", paintStr);
+     * updateWorldProperty('samplelibrary:longerjson');
      * ```
      */
     getDynamicProperty(identifier: string): boolean | number | string | Vector3 | undefined;
@@ -8556,27 +9112,34 @@ export class World {
      * @throws This function can throw errors.
      * @example playMusicAndSound.ts
      * ```typescript
-     *   let players = mc.world.getPlayers();
+     * import { world, MusicOptions, WorldSoundOptions, PlayerSoundOptions, Vector3 } from '@minecraft/server';
+     *
+     * const players = world.getPlayers();
+     * const targetLocation: Vector3 = {
+     *     x: 0,
+     *     y: 0,
+     *     z: 0,
+     * };
      *
-     *   const musicOptions: mc.MusicOptions = {
+     * const musicOptions: MusicOptions = {
      *     fade: 0.5,
      *     loop: true,
      *     volume: 1.0,
-     *   };
-     *   mc.world.playMusic("music.menu", musicOptions);
+     * };
+     * world.playMusic('music.menu', musicOptions);
      *
-     *   const worldSoundOptions: mc.WorldSoundOptions = {
+     * const worldSoundOptions: WorldSoundOptions = {
      *     pitch: 0.5,
      *     volume: 4.0,
-     *   };
-     *   mc.world.playSound("ambient.weather.thunder", targetLocation, worldSoundOptions);
+     * };
+     * world.playSound('ambient.weather.thunder', targetLocation, worldSoundOptions);
      *
-     *   const playerSoundOptions: mc.PlayerSoundOptions = {
+     * const playerSoundOptions: PlayerSoundOptions = {
      *     pitch: 1.0,
      *     volume: 1.0,
-     *   };
+     * };
      *
-     *   players[0].playSound("bucket.fill_water", playerSoundOptions);
+     * players[0].playSound('bucket.fill_water', playerSoundOptions);
      * ```
      */
     playMusic(trackId: string, musicOptions?: MusicOptions): void;
@@ -8593,27 +9156,34 @@ export class World {
      * An error will be thrown if volume is less than 0.0.
      * @example playMusicAndSound.ts
      * ```typescript
-     *   let players = mc.world.getPlayers();
+     * import { world, MusicOptions, WorldSoundOptions, PlayerSoundOptions, Vector3 } from '@minecraft/server';
      *
-     *   const musicOptions: mc.MusicOptions = {
+     * const players = world.getPlayers();
+     * const targetLocation: Vector3 = {
+     *     x: 0,
+     *     y: 0,
+     *     z: 0,
+     * };
+     *
+     * const musicOptions: MusicOptions = {
      *     fade: 0.5,
      *     loop: true,
      *     volume: 1.0,
-     *   };
-     *   mc.world.playMusic("music.menu", musicOptions);
+     * };
+     * world.playMusic('music.menu', musicOptions);
      *
-     *   const worldSoundOptions: mc.WorldSoundOptions = {
+     * const worldSoundOptions: WorldSoundOptions = {
      *     pitch: 0.5,
      *     volume: 4.0,
-     *   };
-     *   mc.world.playSound("ambient.weather.thunder", targetLocation, worldSoundOptions);
+     * };
+     * world.playSound('ambient.weather.thunder', targetLocation, worldSoundOptions);
      *
-     *   const playerSoundOptions: mc.PlayerSoundOptions = {
+     * const playerSoundOptions: PlayerSoundOptions = {
      *     pitch: 1.0,
      *     volume: 1.0,
-     *   };
+     * };
      *
-     *   players[0].playSound("bucket.fill_water", playerSoundOptions);
+     * players[0].playSound('bucket.fill_water', playerSoundOptions);
      * ```
      */
     playSound(soundId: string, location: Vector3, soundOptions?: WorldSoundOptions): void;
@@ -8646,28 +9216,36 @@ export class World {
      * is provided to `score`.
      * @example nestedTranslation.ts
      * ```typescript
+     * import { world } from '@minecraft/server';
+     *
      * // Displays "Apple or Coal"
-     * let rawMessage = {
-     *   translate: "accessibility.list.or.two",
-     *   with: { rawtext: [{ translate: "item.apple.name" }, { translate: "item.coal.name" }] },
+     * const rawMessage = {
+     *     translate: 'accessibility.list.or.two',
+     *     with: { rawtext: [{ translate: 'item.apple.name' }, { translate: 'item.coal.name' }] },
      * };
      * world.sendMessage(rawMessage);
      * ```
      * @example scoreWildcard.ts
      * ```typescript
+     * import { world } from '@minecraft/server';
+     *
      * // Displays the player's score for objective "obj". Each player will see their own score.
-     * const rawMessage = { score: { name: "*", objective: "obj" } };
+     * const rawMessage = { score: { name: '*', objective: 'obj' } };
      * world.sendMessage(rawMessage);
      * ```
      * @example simpleString.ts
      * ```typescript
+     * import { world } from '@minecraft/server';
+     *
      * // Displays "Hello, world!"
-     * world.sendMessage("Hello, world!");
+     * world.sendMessage('Hello, world!');
      * ```
      * @example translation.ts
      * ```typescript
+     * import { world } from '@minecraft/server';
+     *
      * // Displays "First or Second"
-     * const rawMessage = { translate: "accessibility.list.or.two", with: ["First", "Second"] };
+     * const rawMessage = { translate: 'accessibility.list.or.two', with: ['First', 'Second'] };
      * world.sendMessage(rawMessage);
      * ```
      */
@@ -8710,57 +9288,72 @@ export class World {
      * @throws
      * Throws if the given dynamic property identifier is not
      * defined.
-     * @example incrementProperty.ts
+     * @example incrementDynamicProperty.ts
      * ```typescript
-     *   let number = mc.world.getDynamicProperty("samplelibrary:number");
+     * import * as mc from '@minecraft/server';
+     *
+     * function incrementProperty(propertyName: string): boolean {
+     *     let number = mc.world.getDynamicProperty(propertyName);
+     *
+     *     console.warn('Current value is: ' + number);
      *
-     *   log("Current value is: " + number);
+     *     if (number === undefined) {
+     *         number = 0;
+     *     }
      *
-     *   if (number === undefined) {
-     *     number = 0;
-     *   }
+     *     if (typeof number !== 'number') {
+     *         console.warn('Number is of an unexpected type.');
+     *         return false;
+     *     }
      *
-     *   if (typeof number !== "number") {
-     *     log("Number is of an unexpected type.");
-     *     return -1;
-     *   }
+     *     mc.world.setDynamicProperty(propertyName, number + 1);
+     *     return true;
+     * }
      *
-     *   mc.world.setDynamicProperty("samplelibrary:number", number + 1);
+     * incrementProperty('samplelibrary:number');
      * ```
-     * @example incrementPropertyInJsonBlob.ts
+     * @example incrementDynamicPropertyInJsonBlob.ts
      * ```typescript
-     *   let paintStr = mc.world.getDynamicProperty("samplelibrary:longerjson");
-     *   let paint: { color: string; intensity: number } | undefined = undefined;
+     * import * as mc from '@minecraft/server';
      *
-     *   log("Current value is: " + paintStr);
+     * function updateWorldProperty(propertyName: string): boolean {
+     *     let paintStr = mc.world.getDynamicProperty(propertyName);
+     *     let paint: { color: string; intensity: number } | undefined = undefined;
      *
-     *   if (paintStr === undefined) {
-     *     paint = {
-     *       color: "purple",
-     *       intensity: 0,
-     *     };
-     *   } else {
-     *     if (typeof paintStr !== "string") {
-     *       log("Paint is of an unexpected type.");
-     *       return -1;
+     *     console.log('Current value is: ' + paintStr);
+     *
+     *     if (paintStr === undefined) {
+     *         paint = {
+     *             color: 'purple',
+     *             intensity: 0,
+     *         };
+     *     } else {
+     *         if (typeof paintStr !== 'string') {
+     *             console.warn('Paint is of an unexpected type.');
+     *             return false;
+     *         }
+     *
+     *         try {
+     *             paint = JSON.parse(paintStr);
+     *         } catch (e) {
+     *             console.warn('Error parsing serialized struct.');
+     *             return false;
+     *         }
      *     }
      *
-     *     try {
-     *       paint = JSON.parse(paintStr);
-     *     } catch (e) {
-     *       log("Error parsing serialized struct.");
-     *       return -1;
+     *     if (!paint) {
+     *         console.warn('Error parsing serialized struct.');
+     *         return false;
      *     }
-     *   }
      *
-     *   if (!paint) {
-     *     log("Error parsing serialized struct.");
-     *     return -1;
-     *   }
+     *     paint.intensity++;
+     *     paintStr = JSON.stringify(paint); // be very careful to ensure your serialized JSON str cannot exceed limits
+     *     mc.world.setDynamicProperty(propertyName, paintStr);
      *
-     *   paint.intensity++;
-     *   paintStr = JSON.stringify(paint); // be very careful to ensure your serialized JSON str cannot exceed limits
-     *   mc.world.setDynamicProperty("samplelibrary:longerjson", paintStr);
+     *     return true;
+     * }
+     *
+     * updateWorldProperty('samplelibrary:longerjson');
      * ```
      */
     setDynamicProperty(identifier: string, value?: boolean | number | string | Vector3): void;
@@ -8800,7 +9393,6 @@ export class WorldAfterEvents {
      */
     readonly buttonPush: ButtonPushAfterEventSignal;
     /**
-     * @beta
      * @remarks
      * This event is fired when an entity event has been triggered
      * that will update the component definition state of an
@@ -8808,6 +9400,14 @@ export class WorldAfterEvents {
      *
      */
     readonly dataDrivenEntityTrigger: DataDrivenEntityTriggerAfterEventSignal;
+    /**
+     * @beta
+     * @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.
@@ -8859,6 +9459,13 @@ export class WorldAfterEvents {
      *
      */
     readonly entitySpawn: EntitySpawnAfterEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is fired after an explosion occurs.
+     *
+     */
+    readonly explosion: ExplosionAfterEventSignal;
     /**
      * @remarks
      * This event fires when a chargeable item completes charging.
@@ -9026,6 +9633,14 @@ export class WorldAfterEvents {
  */
 export class WorldBeforeEvents {
     private constructor();
+    /**
+     * @beta
+     * @remarks
+     * This event is triggered after an event has been added to an
+     * entity.
+     *
+     */
+    readonly effectAdd: EffectAddBeforeEventSignal;
     /**
      * @remarks
      * Fires before an entity is removed from the world (for
@@ -9033,6 +9648,13 @@ export class WorldBeforeEvents {
      *
      */
     readonly entityRemove: EntityRemoveBeforeEventSignal;
+    /**
+     * @beta
+     * @remarks
+     * This event is fired after an explosion occurs.
+     *
+     */
+    readonly explosion: ExplosionBeforeEventSignal;
     /**
      * @remarks
      * This event fires when an item is successfully used by a
@@ -9251,7 +9873,6 @@ export interface CameraSetRotOptions {
 }
 
 /**
- * @beta
  * Contains a set of updates to the component definition state
  * of an entity.
  */
@@ -9366,7 +9987,6 @@ export interface EntityDamageSource {
 }
 
 /**
- * @beta
  * Specifies additional filters that are used in registering a
  * data driven trigger event for entities.
  */
@@ -9449,6 +10069,161 @@ export interface EntityHitInformation {
 
 /**
  * Contains options for selecting entities within an area.
+ * @example testBlockConditional.ts
+ * ```typescript
+ * import { Dimension } from '@minecraft/server';
+ *
+ * // Having this command:
+ *
+ * // execute as @e[type=fox] positioned as @s if block ^ ^-1 ^ stone run summon salmon
+ *
+ * // Equivalent scripting code would be:
+ * function spawnFish(dimension: Dimension) {
+ *     dimension
+ *         .getEntities({
+ *             type: 'fox',
+ *         })
+ *         .filter(entity => {
+ *             const block = dimension.getBlock({
+ *                 x: entity.location.x,
+ *                 y: entity.location.y - 1,
+ *                 z: entity.location.z,
+ *             });
+ *
+ *             return block !== undefined && block.matches('minecraft:stone');
+ *         })
+ *         .forEach(entity => {
+ *             dimension.spawnEntity('salmon', entity.location);
+ *         });
+ * }
+ * ```
+ * @example testPlaySoundChained.ts
+ * ```typescript
+ * import { Dimension } from '@minecraft/server';
+ *
+ * // Having this command:
+ *
+ * // execute as @e[type=armor_stand,name=myArmorStand,tag=dummyTag1,tag=!dummyTag2] run playsound raid.horn @a
+ *
+ * // Equivalent scripting code would be:
+ * function playSounds(dimension: Dimension) {
+ *     const targetPlayers = dimension.getPlayers();
+ *     const originEntities = dimension.getEntities({
+ *         type: 'armor_stand',
+ *         name: 'myArmorStand',
+ *         tags: ['dummyTag1'],
+ *         excludeTags: ['dummyTag2'],
+ *     });
+ *
+ *     originEntities.forEach(entity => {
+ *         targetPlayers.forEach(player => {
+ *             player.playSound('raid.horn');
+ *         });
+ *     });
+ * }
+ * ```
+ * @example testSendMessageAllPlayers.ts
+ * ```typescript
+ * import { Dimension } from '@minecraft/server';
+ *
+ * // Having this command:
+ *
+ * // execute as @e[type=armor_stand,name=myArmorStand,tag=dummyTag1,tag=!dummyTag2] run tellraw @a { "rawtext": [{"translate": "hello.world" }] }
+ *
+ * // Equivalent scripting code would be:
+ * function sendMessagesToPlayers(dimension: Dimension) {
+ *     const targetPlayers = dimension.getPlayers();
+ *     const originEntities = dimension.getEntities({
+ *         type: 'armor_stand',
+ *         name: 'myArmorStand',
+ *         tags: ['dummyTag1'],
+ *         excludeTags: ['dummyTag2'],
+ *     });
+ *
+ *     originEntities.forEach(entity => {
+ *         targetPlayers.forEach(player => {
+ *             player.sendMessage({ rawtext: [{ translate: 'hello.world' }] });
+ *         });
+ *     });
+ * }
+ * ```
+ * @example testSetScoreBoardChained.ts
+ * ```typescript
+ * import { Dimension, world } from '@minecraft/server';
+ *
+ * // Having these commands:
+ *
+ * // scoreboard objectives add scoreObjective1 dummy
+ * // scoreboard players set @e[type=armor_stand,name=myArmorStand] scoreObjective1 -1
+ *
+ * // Equivalent scripting code would be:
+ * function setScores(dimension: Dimension) {
+ *     const objective = world.scoreboard.addObjective('scoreObjective1', 'dummy');
+ *     dimension
+ *         .getEntities({
+ *             type: 'armor_stand',
+ *             name: 'myArmorStand',
+ *         })
+ *         .forEach(entity => {
+ *             if (entity.scoreboardIdentity !== undefined) {
+ *                 objective.setScore(entity.scoreboardIdentity, -1);
+ *             }
+ *         });
+ * }
+ * ```
+ * @example testSummonMobChained.ts
+ * ```typescript
+ * import { Dimension } from '@minecraft/server';
+ *
+ * // Having this command:
+ *
+ * // execute as @e[type=armor_stand] run execute as @a[x=0,y=-60,z=0,c=4,r=15] run summon pig ~1 ~ ~
+ *
+ * // Equivalent scripting code would be:
+ * function spawnPigs(dimension: Dimension) {
+ *     const armorStandArray = dimension.getEntities({
+ *         type: 'armor_stand',
+ *     });
+ *     const playerArray = dimension.getPlayers({
+ *         location: { x: 0, y: -60, z: 0 },
+ *         closest: 4,
+ *         maxDistance: 15,
+ *     });
+ *     armorStandArray.forEach(entity => {
+ *         playerArray.forEach(player => {
+ *             dimension.spawnEntity('pig', {
+ *                 x: player.location.x + 1,
+ *                 y: player.location.y,
+ *                 z: player.location.z,
+ *             });
+ *         });
+ *     });
+ * }
+ * ```
+ * @example checkFeatherNearby.ts
+ * ```typescript
+ * import { DimensionLocation, EntityComponentTypes } from "@minecraft/server";
+ *
+ * // Returns true if a feather item entity is within 'distance' blocks of 'location'.
+ * function isFeatherNear(location: DimensionLocation, distance: number): boolean {
+ *     const items = location.dimension.getEntities({
+ *         location: location,
+ *         maxDistance: 20,
+ *     });
+ *
+ *     for (const item of items) {
+ *         const itemComp = item.getComponent(EntityComponentTypes.Item);
+ *
+ *         if (itemComp) {
+ *             if (itemComp.itemStack.typeId.endsWith('feather')) {
+ *                 return true;
+ *             }
+ *         }
+ *     }
+ *
+ *     return false;
+ * }
+ * ```
  */
 export interface EntityQueryOptions {
     /**
@@ -9677,6 +10452,22 @@ export interface EntityRaycastOptions {
  * @beta
  * Additional configuration options for the {@link
  * Dimension.createExplosion} method.
+ * @example createExplosions.ts
+ * ```typescript
+ * // Creates an explosion of radius 15 that does not break blocks
+ * import { DimensionLocation } from '@minecraft/server';
+ *
+ * function createExplosions(location: DimensionLocation) {
+ *     // Creates an explosion of radius 15 that does not break blocks
+ *     location.dimension.createExplosion(location, 15, { breaksBlocks: false });
+ *
+ *     // Creates an explosion of radius 15 that does not cause fire
+ *     location.dimension.createExplosion(location, 15, { causesFire: true });
+ *
+ *     // Creates an explosion of radius 10 that can go underwater
+ *     location.dimension.createExplosion(location, 10, { allowUnderwater: true });
+ * }
+ * ```
  */
 export interface ExplosionOptions {
     /**
@@ -9798,6 +10589,67 @@ export interface PlayerSoundOptions {
 
 /**
  * Defines a JSON structure that is used for more flexible.
+ * @example addTranslatedSign.ts
+ * ```typescript
+ * import { DimensionLocation, world, BlockPermutation, BlockComponentTypes } from '@minecraft/server';
+ *
+ * function placeTranslatedSign(location: DimensionLocation, text: string) {
+ *     const signBlock = location.dimension.getBlock(location);
+ *
+ *     if (!signBlock) {
+ *         console.warn('Could not find a block at specified location.');
+ *         return;
+ *     }
+ *     const signPerm = BlockPermutation.resolve('minecraft:standing_sign', { ground_sign_direction: 8 });
+ *     signBlock.setPermutation(signPerm);
+ *
+ *     const signComponent = signBlock.getComponent(BlockComponentTypes.Sign);
+ *     if (signComponent) {
+ *         signComponent.setText({ translate: 'item.skull.player.name', with: [text] });
+ *     } else {
+ *         console.error('Could not find a sign component on the block.');
+ *     }
+ * }
+ *
+ * placeTranslatedSign(
+ *     {
+ *         dimension: world.getDimension('overworld'),
+ *         x: 0,
+ *         y: 0,
+ *         z: 0,
+ *     },
+ *     'Steve',
+ * );
+ * ```
+ * @example showTranslatedMessageForm.ts
+ * ```typescript
+ * import { world, Player } from '@minecraft/server';
+ * import { MessageFormData, MessageFormResponse } from '@minecraft/server-ui';
+ *
+ * function showMessage(player: Player) {
+ *     const messageForm = new MessageFormData()
+ *         .title({ translate: 'permissions.removeplayer' })
+ *         .body({ translate: 'accessibility.list.or.two', with: ['Player 1', 'Player 2'] })
+ *         .button1('Player 1')
+ *         .button2('Player 2');
+ *
+ *     messageForm
+ *         .show(player)
+ *         .then((formData: MessageFormResponse) => {
+ *             // player canceled the form, or another dialog was up and open.
+ *             if (formData.canceled || formData.selection === undefined) {
+ *                 return;
+ *             }
+ *
+ *             console.warn(`You selected ${formData.selection === 0 ? 'Player 1' : 'Player 2'}`);
+ *         })
+ *         .catch((error: Error) => {
+ *             console.warn('Failed to show form: ' + error);
+ *         });
+ * };
+ *
+ * showMessage(world.getAllPlayers()[0]);
+ * ```
  */
 export interface RawMessage {
     /**
@@ -9949,6 +10801,30 @@ export interface ScriptEventMessageFilterOptions {
 
 /**
  * Contains additional options for teleporting an entity.
+ * @example teleportMovement.ts
+ * ```typescript
+ * import { world, system } from '@minecraft/server';
+ *
+ * const overworld = world.getDimension('overworld');
+ * const targetLocation = { x: 0, y: 0, z: 0 };
+ *
+ * const pig = overworld.spawnEntity('minecraft:pig', targetLocation);
+ *
+ * let inc = 1;
+ * const runId = system.runInterval(() => {
+ *     pig.teleport(
+ *         { x: targetLocation.x + inc / 4, y: targetLocation.y + inc / 4, z: targetLocation.z + inc / 4 },
+ *         {
+ *             facingLocation: targetLocation,
+ *         },
+ *     );
+ *
+ *     if (inc > 100) {
+ *         system.clearRun(runId);
+ *     }
+ *     inc++;
+ * }, 4);
+ * ```
  */
 export interface TeleportOptions {
     /**