@wq2/miniblox-sdk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,4711 @@
+import { Socket } from "socket.io-client";
+import {
+	Box3 as Box3$1,
+	Box3Helper,
+	Group,
+	Loader,
+	Mesh as Mesh$1,
+	Object3D as Object3D$1,
+	Quaternion as Quaternion$1,
+	Texture,
+	TextureLoader,
+	Vector3 as Vector3$2,
+} from "three";
+import { Vector3 as Vector3$3 } from "three/src/Three.Core.js";
+
+//#region src/math/plane.d.ts
+type directionStr = "horizontal" | "vertical";
+declare class Plane {
+	static HORIZONTAL: Plane;
+	static VERTICAL: Plane;
+	facings: EnumFacing$1[];
+	direction: directionStr;
+	constructor(direction: directionStr);
+	init(): void;
+	static getHorizontal(): EnumFacing$1[];
+	static randomHorizontal(): EnumFacing$1[];
+	static getVertical(): EnumFacing$1[];
+	random(): EnumFacing$1;
+	equals(other: Plane): boolean;
+}
+//#endregion
+//#region src/math/axis.d.ts
+declare class Axis {
+	name: string;
+	index: number;
+	plane: Plane;
+	static readonly X: Axis;
+	static readonly Y: Axis;
+	static readonly Z: Axis;
+	static readonly VALUES: Axis[];
+	constructor(name: string, plane: Plane, index: number);
+	equals(other: Axis): boolean;
+	notEquals(other: Axis): boolean;
+	inverseCrossProduct(): [EnumFacing$1, EnumFacing$1];
+	static byName(name: string): Axis;
+	toJSON(): this["name"];
+	isVertical(): boolean;
+	isHorizontal(): boolean;
+	getPlane(): this["plane"];
+}
+declare class AxisDirection {
+	static POSITIVE: AxisDirection;
+	static NEGATIVE: AxisDirection;
+	description: string;
+	offset: number;
+	constructor(offset: number, description: string);
+}
+//#endregion
+//#region src/math/facing.d.ts
+declare class EnumFacing$1 {
+	index: number;
+	opposite: number;
+	horizontalIndex: number;
+	name: string;
+	axisDirection: AxisDirection;
+	axis: Axis;
+	directionVec: Vector3$3;
+	static readonly DOWN: EnumFacing$1;
+	static readonly UP: EnumFacing$1;
+	static readonly NORTH: EnumFacing$1;
+	static readonly SOUTH: EnumFacing$1;
+	static readonly WEST: EnumFacing$1;
+	static readonly EAST: EnumFacing$1;
+	static readonly getByName: {
+		[name: string]: EnumFacing$1;
+	};
+	static readonly VALUES: EnumFacing$1[];
+	static readonly HORIZONTALS: EnumFacing$1[];
+	constructor(
+		index: number,
+		opposite: number,
+		horizontalIndex: number,
+		name: string,
+		axisDirection: AxisDirection,
+		axis: Axis,
+		directionVec: Vector3$3,
+	);
+	getOpposite(): EnumFacing$1;
+	getHorizontalIndex(): this["horizontalIndex"];
+	isHorizontal(): this["axis"]["isHorizontal"];
+	toJSON(): this["name"];
+	valueOf(): this["name"];
+	toProto(): this["name"];
+	getAxis(): this["axis"];
+	getIndex(): this["index"];
+	rotateAround(u: Axis): EnumFacing$1;
+	rotateY(): EnumFacing$1;
+	rotateX(): EnumFacing$1;
+	rotateZ(): EnumFacing$1;
+	rotateYCCW(): EnumFacing$1;
+	getFrontOffsetX(): number;
+	getFrontOffsetY(): number;
+	getFrontOffsetZ(): number;
+	static getHorizontal(idx: number): EnumFacing$1;
+	static random(): EnumFacing$1;
+	static fromIndex(index: number): EnumFacing$1;
+	static fromVector(vec: Vector3$3): EnumFacing$1;
+	toVector(): Vector3$3;
+	static toVector(facing: EnumFacing$1): Vector3$3;
+	toArray(): [number, number, number];
+	static fromAngle(angle: number): EnumFacing$1;
+	static fromJSON(json: string): EnumFacing$1;
+	static fromDirectionAndAxis(
+		axisDirection: AxisDirection,
+		axis: Axis,
+	): EnumFacing$1;
+	toAngleRadians(): number;
+}
+//#endregion
+//#region src/render/RenderEntity.d.ts
+declare class RenderEntity extends Group {
+	rotYaw: Quaternion$1;
+	rotPitch: Quaternion$1;
+	entity: Entity$1;
+	debugMesh: Mesh$1;
+}
+//#endregion
+//#region src/items/Item.d.ts
+// Base Item class
+declare class Item$1 {
+	name: string;
+	maxStackSize: number;
+	maxDamage: number;
+	hasSubtypes: boolean;
+	getUnlocalizedName(): string;
+	getItemStackDisplayName(stack: ItemStack$1): string;
+	onItemUse(
+		stack: ItemStack$1,
+		player: Entity$1,
+		world: World$1,
+		pos: Vector3$2,
+		side: EnumFacing$1,
+		hitX: number,
+		hitY: number,
+		hitZ: number,
+	): boolean;
+	onItemRightClick(
+		stack: ItemStack$1,
+		world: World$1,
+		player: Entity$1,
+	): ItemStack$1;
+	getMaxItemUseDuration(stack: ItemStack$1): number;
+	getItemUseAction(stack: ItemStack$1): string;
+	onPlayerStoppedUsing(
+		stack: ItemStack$1,
+		world: World$1,
+		player: Entity$1,
+		timeLeft: number,
+	): void;
+	hitEntity(stack: ItemStack$1, target: Entity$1, attacker: Entity$1): boolean;
+	onBlockDestroyed(
+		stack: ItemStack$1,
+		world: World$1,
+		block: Block,
+		pos: Vector3$2,
+		player: Entity$1,
+	): boolean;
+	canHarvestBlock(block: Block): boolean;
+	getStrVsBlock(stack: ItemStack$1, block: Block): number;
+}
+// ItemBlock - Placeable blocks
+declare class ItemBlock extends Item$1 {
+	block: Block;
+	getBlock(): Block;
+	placeBlockAt(
+		stack: ItemStack$1,
+		player: Entity$1,
+		world: World$1,
+		pos: Vector3$2,
+		side: EnumFacing$1,
+		hitX: number,
+		hitY: number,
+		hitZ: number,
+		metadata: number,
+	): boolean;
+}
+// ItemSword - Swords
+declare class ItemSword extends Item$1 {
+	attackDamage: number;
+	weaponMaterial: string;
+	getAttackDamage(): number;
+}
+// ItemBow - Bows
+declare class ItemBow extends Item$1 {
+	maxItemUseDuration: number;
+}
+declare class ItemArmor extends Item$1 {
+	armorType: number;
+	/** **IMPORTANT**: USE DUMPS OR AUTO REMAP PROXY */
+	damageReduceAmount: number;
+	maxDamage: number;
+	renderIndex: number;
+	material: string;
+	getArmorMaterial(): string;
+	getColor(stack: ItemStack$1): number;
+	removeColor(stack: ItemStack$1): void;
+	hasColor(stack: ItemStack$1): boolean;
+}
+declare class ItemFood extends Item$1 {
+	healAmount: number;
+	saturationModifier: number;
+	isWolfsFavoriteMeat: boolean;
+	alwaysEdible: boolean;
+	getHealAmount(stack: ItemStack$1): number;
+	getSaturationModifier(stack: ItemStack$1): number;
+}
+declare class ItemTool extends Item$1 {
+	efficiencyOnProperMaterial: number;
+	damageVsEntity: number;
+	toolMaterial: string;
+	getToolMaterial(): string;
+	getStrVsBlock(stack: ItemStack$1, block: Block): number;
+}
+declare class ItemPickaxe extends ItemTool {}
+declare class ItemAppleGold extends ItemFood {}
+interface EnchantmentData {
+	id: number;
+	lvl: number;
+}
+declare class ItemStack$1 {
+	item: Item$1;
+	stackSize: number;
+	itemDamage: number;
+	getItem(): Item$1;
+	getDisplayName(): string;
+	getEnchantmentTagList(): EnchantmentData[] | null;
+	hasEffect(): boolean;
+	isItemEnchanted(): boolean;
+	isItemEnchantable(): boolean;
+	getMaxStackSize(): number;
+	isStackable(): boolean;
+	isItemDamaged(): boolean;
+	getItemDamage(): number;
+	getMaxDamage(): number;
+	attemptDamageItem(amount: number, random: unknown): boolean;
+	damageItem(amount: number, entity: Entity$1): void;
+	hitEntity(target: Entity$1, player: Entity$1): void;
+	onBlockDestroyed(
+		world: World$1,
+		block: Block,
+		pos: unknown,
+		player: Entity$1,
+	): void;
+	canHarvestBlock(block: Block): boolean;
+	interactWithEntity(player: Entity$1, target: Entity$1): boolean;
+	copy(): ItemStack$1;
+	areItemStackTagsEqual(other: ItemStack$1): boolean;
+	areItemStacksEqual(other: ItemStack$1): boolean;
+	isItemEqual(other: ItemStack$1): boolean;
+	getTooltip(player: Entity$1, advanced: boolean): string[];
+	hasDisplayName(): boolean;
+	setStackDisplayName(name: string): ItemStack$1;
+	clearCustomName(): void;
+	hasTagCompound(): boolean; // TODO: idk what types these are, assuming strings?
+	getTagCompound(): string;
+	setTagCompound(nbt: string): void;
+}
+// Global Items registry
+declare const Items: {
+	readonly emerald_sword: Item$1;
+	readonly diamond_sword: ItemSword;
+	readonly iron_sword: ItemSword;
+	readonly stone_sword: ItemSword;
+	readonly wooden_sword: ItemSword;
+	readonly bow: ItemBow;
+	readonly arrow: Item$1;
+	readonly golden_apple: ItemAppleGold;
+	readonly apple: ItemFood;
+	readonly bread: ItemFood;
+	readonly cooked_beef: ItemFood;
+	readonly cooked_porkchop: ItemFood;
+	readonly diamond_helmet: ItemArmor;
+	readonly diamond_chestplate: ItemArmor;
+	readonly diamond_leggings: ItemArmor;
+	readonly diamond_boots: ItemArmor;
+	readonly iron_helmet: ItemArmor;
+	readonly iron_chestplate: ItemArmor;
+	readonly iron_leggings: ItemArmor;
+	readonly iron_boots: ItemArmor;
+	readonly chainmail_helmet: ItemArmor;
+	readonly chainmail_chestplate: ItemArmor;
+	readonly chainmail_leggings: ItemArmor;
+	readonly chainmail_boots: ItemArmor;
+	readonly diamond_pickaxe: ItemPickaxe;
+	readonly iron_pickaxe: ItemPickaxe;
+	readonly stone_pickaxe: ItemPickaxe;
+	readonly wooden_pickaxe: ItemPickaxe;
+	readonly ender_pearl: Item$1;
+	readonly snowball: Item$1;
+	readonly egg: Item$1;
+	readonly flint_and_steel: Item$1;
+	readonly fire_charge: Item$1; // Add more items as needed
+	[key: string]: Item$1;
+};
+//#endregion
+//#region src/render/RenderLivingEntity.d.ts
+declare class RenderLivingEntity extends RenderEntity {
+	nameTag: Group;
+	skeleton: Group;
+	torso: Object3D$1;
+	leftElbowJoint: Object3D$1;
+	rightElbowJoint: Object3D$1;
+	leftShoulder: Object3D$1;
+	rightShoulder: Object3D$1;
+	leftShoulderJoint: Object3D$1;
+	rightShoulderJoint: Object3D$1;
+	rightHand: Object3D$1;
+	leftKneeJoint: Object3D$1;
+	rightKneeJoint: Object3D$1;
+	leftHip: Object3D$1;
+	rightHip: Object3D$1;
+	leftHipJoint: Object3D$1;
+	rightHipJoint: Object3D$1;
+	headPivot: Group;
+	neck: Object3D$1;
+	body: Group;
+	armorMesh: Mesh$1;
+	meshes: Mesh$1[];
+	item: Item$1;
+	lastActiveItem: Item$1;
+	handMesh: Mesh$1;
+	handTesr: unknown;
+	prevCustomName: string;
+}
+//#endregion
+//#region src/render/RenderPlayer.d.ts
+declare class RenderPlayer extends RenderLivingEntity {
+	model: ModelPlayer; // ModelPlayer
+	capeMesh: Mesh$1;
+	hatMesh: Mesh$1;
+	punchingT: number;
+	canvas: HTMLCanvasElement;
+}
+//#endregion
+//#region src/undefined.d.ts
+/**
+ * Contains types which are just an alias to `unknown`.
+ * Each type is here either because they aren't important (i.e. only useful server-sided) or I haven't gotten around to making types for them yet.
+ */
+//#region Needs Typings
+//#region Required
+type Inventory$1 = unknown;
+type InventoryEnderChest = unknown;
+type PotionEffect = unknown;
+//#endregion
+//#region Additional
+type DataWatcher = unknown;
+type EffectsManager = unknown;
+type FoodStats = unknown;
+type AttributeMap = unknown;
+type CombatTracker = unknown;
+type TileEntitySign = unknown;
+type CommandBlockLogic = unknown;
+type Profile = unknown;
+type GameProfile = unknown;
+//#endregion
+//#endregion
+//#region Useless
+type ICrafting = unknown;
+//#endregion
+//#region src/world/damageSource.d.ts
+declare class DamageSource {
+	unblockable: boolean;
+	isDamageAllowedInCreativeMode: boolean;
+	damageIsAbsolute: boolean;
+	hungerDamage: number;
+	fireDamage: number;
+	projectile: boolean;
+	difficultyScaled: boolean;
+	magicDamage: boolean;
+	explosion: boolean;
+	damageType: string;
+	damageSourceEntity?: Entity;
+	isThornsDamage: boolean;
+	indirectEntity?: Entity;
+	constructor(damageType: string, entity: Entity, p?: Entity);
+	static causeMobDamage(mob: EntityLivingBase): DamageSource;
+	static causePlayerDamage(player: EntityPlayer): DamageSource;
+	static causeArrowDamage(u: Entity, h: Entity): DamageSource;
+	static causeFireballDamage(e: Entity, ie: Entity): DamageSource;
+	static causeThrownDamage(e: Entity, ie: Entity): DamageSource;
+	static causeIndirectMagicDamage(e: Entity, ie: Entity): DamageSource;
+	static causeThornsDamage(e: Entity): DamageSource;
+	static setExplosionSource(u: unknown): DamageSource;
+	isProjectile(): this["projectile"];
+	setProjectile(): this;
+	isExplosion(): this["explosion"];
+	setExplosion(): this;
+	isUnblockable(): this["unblockable"];
+	getHungerDamage(): this["hungerDamage"];
+	canHarmInCreative(): this["isDamageAllowedInCreativeMode"];
+	isDamageAbsolute(): this["isDamageAbsolute"];
+	getSourceOfDamage(): Entity | null;
+	getEntity(): Entity | null;
+	setDamageBypassesArmor(): this;
+	setDamageAllowedInCreativeMode(): this;
+	setDamageIsAbsolute(): this;
+	setFireDamage(): this;
+	getDeathMessage(e: Entity): string;
+	isFireDamage(): this["fireDamage"];
+	getDamageType(): this["damageType"];
+	setDifficultyScaled(): this;
+	isDifficultyScaled(): this["difficultyScaled"];
+	isMagicDamage(): this["magicDamage"];
+	setMagicDamage(): this;
+	isCreativePlayer(): boolean;
+	getIsThornsDamage(): this["isThornsDamage"];
+	equals(other: DamageSource): boolean;
+	setIsThornsDamage(): this;
+}
+//#endregion
+//#region src/entities/Entity.d.ts
+declare class Entity$1 {
+	static nextEntityID: number;
+	mesh: RenderPlayer;
+	id: number;
+	world: World$1;
+	pos: Vector3$2;
+	prevPos: Vector3$2;
+	serverPos: Vector3$2;
+	noPhysics: boolean;
+	yaw: number;
+	pitch: number;
+	prevYaw: number;
+	prevPitch: number;
+	ticksExisted: number;
+	dead: boolean;
+	width: number;
+	height: number;
+	boundingBox: Box3$1;
+	isAirborne: boolean;
+	inWeb: boolean;
+	inWater: boolean;
+	inLava: boolean;
+	inCloud: boolean;
+	fire: number;
+	fireResistance: number;
+	immuneToFire: boolean;
+	onGround: boolean;
+	isCollided: boolean;
+	isCollidedVertically: boolean;
+	isCollidedHorizontally: boolean;
+	stepHeight: number;
+	fallDistance: number;
+	sneak: boolean;
+	riddenByEntity: Entity$1 | null;
+	ridingEntity: Entity$1 | null;
+	inPortal: boolean;
+	velocityChanged: boolean;
+	timeUntilPortal: number;
+	dataWatcher: DataWatcher;
+	invulnerable: boolean;
+	dimension: number;
+	motion: Vector3$2;
+	nextStepDistance: number;
+	distanceWalkedModified: number;
+	distanceWalkedOnStepModified: number;
+	portalCounter: number;
+	portalBlock: BlockPos$1 | null;
+	lastUpdate: number;
+	constructor(world: World$1, profile?: Profile);
+	onKillCommand(): void;
+	getDisplayName(): string;
+	getName(): string;
+	isInWater(): boolean;
+	isInLava(): boolean;
+	isEating(): boolean;
+	setEating(eating: boolean): void;
+	entityInit(): void;
+	getDataWatcher(): DataWatcher;
+	dwReadB(id: number): boolean;
+	dwSetB(id: number, state: boolean): void;
+	getCustomNameTag(): string;
+	setCustomNameTag(v: string): void;
+	getAlwaysRenderNameTag(): boolean;
+	setAlwaysRenderNameTag(v: boolean): void;
+	onDataWatcherUpdate(id: number): void;
+	equals(other: unknown): boolean;
+	getEntityBoundingBox(): Box3$1;
+	getRotationYawHead(): number;
+	setSize(width: number, height: number): void;
+	setVelocity(x: number, y: number, z: number): void;
+	setPositionAndUpdate(x: number, y: number, z: number): void;
+	setPosition(vec: Vector3$2): void;
+	setPosition(x: number, y: number, z: number): void;
+	setPositionAndRotation(
+		x: number,
+		y: number,
+		z: number,
+		yaw: number,
+		pitch: number,
+	): void;
+	setPositionAndRotation2(
+		x: number,
+		y: number,
+		z: number,
+		yaw: number,
+		pitch: number,
+		_: unknown,
+		S?: boolean,
+	): void;
+	setRotation(yaw: number, pitch: number): void;
+	setLocationAndAngles(
+		x: number,
+		y: number,
+		z: number,
+		yaw?: number,
+		pitch?: number,
+	): void;
+	offsetBBox(offset: Vector3$2): this["boundingBox"];
+	setEntityBoundingBox(box: Box3$1): void;
+	resetPositionToBB(): void;
+	getEyeHeight(): number;
+	getPartialTicks(): number;
+	update(): void;
+	kill(): void;
+	preparePlayerToSpawn(): void;
+	getMaxInPortalTime(): number;
+	setWorld(world: World$1): void;
+	travelToDimension(dimension: string): void;
+	copyDataFromOld(oldEntity: Entity$1): void;
+	onEntityUpdate(): void;
+	setCurrentItemOrArmor(i: number, v: ItemStack | null): void;
+	isBurning(): boolean;
+	/**
+	 * returns null if this isn't a {@linkcode EntityLivingBase}
+	 */
+	getInventory(): Inventory | null;
+	toJSON(): {
+		id: number;
+		pos: Vector3$2;
+		onGround: boolean;
+	};
+	fromJSON(data: { id: number; pos: Vector3$2; onGround: boolean }): void;
+	testSneaking(u: unknown, h: unknown): void;
+	testStepUp(u: unknown, h: unknown, p: unknown): boolean;
+	handleWaterMovement(): boolean;
+	fall(distance: number, damageMultiplier: number): void;
+	updateFallState(
+		y: number,
+		onGround: boolean,
+		block: Block$1 | null,
+		pos: BlockPos$1,
+	): void;
+	handleStatusUpdate(u: unknown): void;
+	canBePushed(): boolean;
+	isSilent(): boolean;
+	isOnLadder(): boolean;
+	getLadderSpeed(): 0.2 | 0.3;
+	canTriggerWalking(): boolean;
+	isOffsetPositionInLiquid(u: unknown, h: unknown, p: unknown): boolean;
+	isLiquidPresentInAABB(u: Box3$1): boolean;
+	moveFlying(dX: number, dY: number, dZ: number): void;
+	moveEntity(dX: number, dY: number, dZ: number): void;
+	playSound(x: number, y: number, z: number): void;
+	applyEntityCollision(entity: Entity$1): void;
+	addVelocity(x: number, y: number, z: number): void;
+	dealFireDamage(damage: number): void;
+	setFire(ticks: number): void;
+	doBlockCollisions(): void;
+	isOpenBlockSpace(u: Vector3$2): boolean;
+	isEntityInsideOpaqueBlock(): boolean;
+	isInsideOfMaterial(u: unknown): boolean;
+	pushOutOfBlocks(x: number, y: number, z: number): boolean;
+	canBeCollidedWith(): boolean;
+	onCollideWithPlayer(u: unknown): void;
+	getLook(): unknown;
+	canCommandSenderUseCommand(u: unknown, h: unknown): boolean;
+	getEyePos(): Vector3$2;
+	canAttackWithItem(): boolean;
+	hitByEntity(u: unknown): boolean;
+	attackEntityFrom(source: DamageSource, amount: number): boolean;
+	setBeenAttacked(): void;
+	isEntityInvulnerable(u: unknown): boolean;
+	onKillEntity(u: unknown): void;
+	setOnFireFromLava(): void;
+	setDead(): void;
+	isEntityAlive(): boolean;
+	setEntityState(u: unknown, h: unknown): void;
+	onChunkLoad(): void;
+	dropItem2(u: unknown, h: unknown): unknown;
+	dropItemWithOffset(u: unknown, h: unknown, p: number): unknown;
+	getDistanceSqToEntity(u: Entity$1): number;
+	setSprinting(sprinting: boolean): void;
+	isSprinting(): boolean;
+	isInvisible(): boolean;
+	/**
+	 * Checks if this entity is invisible to the {@link player}
+	 * @param player the player to check if this entity is invisible to
+	 */
+	isInvisibleTo(player: Entity$1): boolean;
+	setInvisible(invisible: boolean): void;
+	entityDropItem(stack: ItemStack, offsetY: number): EntityItem;
+	doesEntityNotTriggerPressurePlate(): boolean;
+	getHorizontalFacing(): EnumFacing$1;
+	/** gets the **BLOCK** position of the player. */
+	getPosition(): BlockPos$1;
+	getExplosionResistance(
+		explosion: Explosion,
+		world: World$1,
+		pos: BlockPos$1,
+		blockState: BlockState$1,
+	): float;
+	verifyExplosion(
+		explosion: Explosion,
+		worldObj: World$1,
+		x: number,
+		y: number,
+		z: number,
+	): boolean;
+	isImmuneToExplosions(): boolean;
+	getDistance(x: number, y: number, z: number): number;
+	resetHeight(): void;
+	getMaxFallHeight(): number;
+	writeEntityToNBT(nbt: unknown): void;
+	readEntityFromNBT(nbt: unknown): void;
+	writeToNBT(u: unknown): void;
+	getCollisionBorderSize(): number;
+	readFromNBT(u: unknown): void;
+	isOverworld(): boolean;
+	interactFirst(player: Entity$1): boolean;
+	applyEnchantments(u: unknown, h: unknown): void;
+	isRiding(): boolean;
+	getYOffset(): number;
+	getMountedYOffset(): number;
+	updateRiderPosition(): void;
+	updateRidden(): void;
+	mountEntity(e: Entity$1 | null): void;
+	updatePortal(u: unknown): void;
+	getPortalCooldown(): number;
+}
+//#endregion
+//#region src/entities/EntityArrow.d.ts
+declare enum EntityName {
+	UNDEFINED,
+	ITEM,
+	PLAYER,
+	ARROW,
+	SNOWBALL,
+	ENDER_PEARL,
+	EGG,
+	POTION,
+	ITEM_FRAME,
+	FALLING_BLOCK,
+	TNT,
+	FIREBALL,
+	PIG,
+	COW,
+	CHICKEN,
+	SHEEP,
+	ZOMBIE,
+	ZOMBIE_COWMAN,
+	SKELETON,
+	CREEPER,
+	SLIME,
+	SPIDER,
+	BOAT,
+	SNOWMAN,
+	GHOST,
+}
+declare class EntityArrow extends Entity$1 {
+	type: "arrow";
+	identifier: EntityName;
+	shootingEntity: Entity$1;
+	lastPos: Vector3$2;
+	lastVel: Vector3$2;
+	prevVel: Vector3$2;
+	vel: Vector3$2;
+	acc: Vector3$2;
+	damage: number;
+	knockbackStrength: number;
+	canBePickedUp: boolean;
+	inGround: boolean;
+	ticksInGround: number;
+	ticksInAir: number;
+	xTile: number;
+	yTile: number;
+	zTile: number;
+	inTile: boolean;
+	arrowShake: number;
+	lastArrowShake: number;
+	constructor(
+		world: World$1,
+		shootingEntity: Entity$1,
+		idk: number | Vector3$2,
+		idk2: number,
+		idk3: number,
+	);
+	setDamage(h: number): void;
+	getDamage(): number;
+	setKnockbackStrength(h: number): void;
+	setThrowableHeading(
+		mX: number,
+		mY: number,
+		mZ: number,
+		y: number,
+		x: number,
+	): void;
+	setIsCritical(h: boolean): void;
+	getIsCritical(): boolean;
+}
+//#endregion
+//#region src/entities/EntityItem.d.ts
+declare class EntityItem$1 extends Entity$1 {
+	identifier: EntityName.ITEM; // EntityName.ITEM
+	age: number;
+	delayBeforeCanPickup: number;
+	health: number;
+	constructor(world: World$1, stack?: ItemStack$1, pos?: Vector3$2);
+	setEntityItemStack(stack: ItemStack$1): void;
+	canTriggerWalking(): false;
+	setPickupDelay(delay: number): void;
+	setDefaultPickupDelay(): void;
+}
+//#endregion
+//#region src/effects/effectRenderer.d.ts
+declare class EntityFX extends Entity {
+	sprite: Sprite;
+	mesh_: Mesh;
+	particleTextureIndexX: number;
+	particleTextureIndexY: number;
+	particleTextureJitterX: number;
+	particleTextureJitterY: number;
+	particleAge: number;
+	particleMaxAge: number;
+	particleScale: number;
+	particleGravity: number;
+	particleRed: number;
+	particleGreen: number;
+	particleBlue: number;
+	particleAlpha: number;
+	constructor(
+		world: World$1,
+		xP: number,
+		yP: number,
+		zP: number,
+		bl: boolean,
+		initialYM?: number,
+		initialZM?: number,
+	);
+	multiplyVelocity(multiplier: number): this;
+	multipleParticleScaleBy(v: number): this;
+	setRBGColorF(r: number, g: number, b: number): void;
+	getRedColorF(): this["particleRed"];
+	getGreenColorF(): this["particleGreen"];
+	getBlueColorF(): this["particleBlue"];
+	getAlpha(): this["particleAlpha"];
+	canTriggerWalking(): boolean;
+	entityInit(): void;
+	update(): void;
+	renderParticle(scene: GameScene, entity: Entity, g: number): void;
+	remove(obj: Object3D): void;
+	getFXLayer(): number;
+	setParticleTextureIndex(idx: number): void;
+	nextTextureIndexX(): void;
+	canAttackWithItem(): boolean;
+}
+declare class EnumParticleTypes$1 {
+	static readonly PARTICLES: Map<number, EnumParticleTypes$1>;
+	static readonly PARTICLE_NAMES: string[];
+	static readonly EXPLOSION_NORMAL: EnumParticleTypes$1;
+	static readonly EXPLOSION_LARGE: EnumParticleTypes$1;
+	static readonly EXPLOSION_HUGE: EnumParticleTypes$1;
+	static readonly FIREWORKS_SPARK: EnumParticleTypes$1;
+	static readonly WATER_BUBBLE: EnumParticleTypes$1;
+	static readonly WATER_SPLASH: EnumParticleTypes$1;
+	static readonly WATER_WAKE: EnumParticleTypes$1;
+	static readonly SUSPENDED: EnumParticleTypes$1;
+	static readonly SUSPENDED_DEPTH: EnumParticleTypes$1;
+	static readonly CRIT: EnumParticleTypes$1;
+	static readonly CRIT_MAGIC: EnumParticleTypes$1;
+	static readonly SMOKE_NORMAL: EnumParticleTypes$1;
+	static readonly SMOKE_LARGE: EnumParticleTypes$1;
+	static readonly SPELL: EnumParticleTypes$1;
+	static readonly SPELL_INSTANT: EnumParticleTypes$1;
+	static readonly SPELL_MOB: EnumParticleTypes$1;
+	static readonly SPELL_MOB_AMBIENT: EnumParticleTypes$1;
+	static readonly SPELL_WITCH: EnumParticleTypes$1;
+	static readonly DRIP_WATER: EnumParticleTypes$1;
+	static readonly DRIP_LAVA: EnumParticleTypes$1;
+	static readonly VILLAGER_ANGRY: EnumParticleTypes$1;
+	static readonly VILLAGER_HAPPY: EnumParticleTypes$1;
+	static readonly TOWN_AURA: EnumParticleTypes$1;
+	static readonly NOTE: EnumParticleTypes$1;
+	static readonly PORTAL: EnumParticleTypes$1;
+	static readonly ENCHANTMENT_TABLE: EnumParticleTypes$1;
+	static readonly FLAME: EnumParticleTypes$1;
+	static readonly LAVA: EnumParticleTypes$1;
+	static readonly FOOTSTEP: EnumParticleTypes$1;
+	static readonly CLOUD: EnumParticleTypes$1;
+	static readonly REDSTONE: EnumParticleTypes$1;
+	static readonly SNOWBALL: EnumParticleTypes$1;
+	static readonly SNOW_SHOVEL: EnumParticleTypes$1;
+	static readonly SLIME: EnumParticleTypes$1;
+	static readonly HEART: EnumParticleTypes$1;
+	static readonly BARRIER: EnumParticleTypes$1;
+	static readonly ITEM_CRACK: EnumParticleTypes$1;
+	static readonly BLOCK_CRACK: EnumParticleTypes$1;
+	static readonly BLOCK_DUST: EnumParticleTypes$1;
+	static readonly WATER_DROP: EnumParticleTypes$1;
+	static readonly ITEM_TAKE: EnumParticleTypes$1;
+	static readonly MOB_APPEARANCE: EnumParticleTypes$1;
+	static readonly COLOR: EnumParticleTypes$1;
+	particleName: string;
+	particleID: number;
+	shouldIgnoreRange: boolean;
+	argumentCount: number;
+	constructor(
+		name: string,
+		id: number,
+		ignoreRange: boolean,
+		argCount?: number,
+	);
+	static getParticleNames(): (typeof EnumParticleTypes$1)["PARTICLE_NAMES"];
+	getParticleName(): this["particleName"];
+	getParticleID(): this["particleID"];
+	getArgumentCount(): this["argumentCount"];
+	getShouldIgnoreRange(): this["shouldIgnoreRange"];
+	hasArguments(): boolean;
+	static getParticleFromId(id: number): EnumParticleTypes$1 | undefined;
+}
+declare class EffectRenderer$1 {
+	scene: GameScene;
+	isGuiPlayerRenderer: boolean;
+	fxLayers: EntityFX[][][];
+	particleEmitters: EntityParticleEmitter[];
+	particleTypes: Map<number, EntityFXFactory>;
+	constructor(scene: GameScene, isGuiPlayerRenderer?: boolean);
+	registerVanillaParticles(): void;
+	registerParticle(id: number, h: EntityFXFactory): void;
+	emitParticleAtEntity(
+		world: World$1,
+		entity: Entity,
+		particleType: EnumParticleTypes$1,
+	): void;
+	spawnEffectParticle(
+		world: ClientWorld,
+		particle: EnumParticleTypes$1,
+		xOff: number,
+		yOff: number,
+		zOff: number,
+		idk1: unknown,
+		idk2: unknown,
+		idk3: unknown,
+		pos: Vector3,
+		...w: unknown[]
+	): void;
+	addEffect(e: EntityFX): void;
+	updateEffects(): void;
+	updateEffectLayer(layer: number): void;
+	updateEffectAlphaLayer(alphaLayer: EntityFX[]): void;
+	/** calls entity.update() within a try clause */
+	tickParticle(entity: EntityFX): void;
+	renderParticles(e: Entity, n?: number): void;
+	addBlockDestroyEffects(pos: Vector3, state: BlockState, world: World$1): void;
+	addBlockHitEffects(pos: BlockPos, facing: EnumFacing, world: World$1): void;
+	/**
+	 * if the math.random is less than the particle chance setting / 100, or the react location is `/account`.
+	 */
+	canSpawnParticle(): boolean;
+}
+//#endregion
+//#region src/enums.d.ts
+declare enum EnumDifficulty {
+	PEACEFUL = 0,
+	EASY = 1,
+	NORMAL = 2,
+	HARD = 3,
+}
+declare enum Equipment_Slot$1 {
+	MAIN_HAND = 0,
+	OFF_HAND = 1,
+	FEET = 2,
+	LEGS = 3,
+	CHEST = 4,
+	HEAD = 5,
+}
+declare enum EnumCreatureAttribute {
+	UNDEFINED = 0,
+	UNDEAD = 1,
+	ARTHROPOD = 2,
+}
+//#endregion
+//#region src/effects/enchantments.d.ts
+declare enum EnumEnchantmentType {
+	ARMOR,
+	ARMOR_FEET,
+	ARMOR_LEGS,
+	ARMOR_TORSO,
+	ARMOR_HEAD,
+	WEAPON,
+	DIGGER,
+	FISHING_ROD,
+	BREAKABLE,
+	BOW,
+}
+declare abstract class Enchantment {
+	/**
+	 * Initialized in {@linkcode Enchantment.init init} to be every non-null enchantment in {@linkcode Enchantment.enchantmentsList enchantmentsList}
+	 */
+	static readonly enchantmentsBookList: Enchantment[];
+	/** "map array" of enchantment ID -> enchantment object. used for checking duplicates in the constructor */
+	static readonly enchantmentsList: Enchantment[];
+	/** map of enchantment name -> enchantment. in MCP-919, the map key would be a resource location. */
+	static readonly locationEnchantments: Map<string, Enchantment>;
+	readonly effectId: number;
+	readonly weight: number;
+	readonly type: EnumEnchantmentType;
+	readonly name: string;
+	/**
+	 * Constructs an enchantment and puts it in the lookup tables {@linkcode Enchantment.enchantmentsList enchantmentsList} and {@linkcode Enchantment.locationEnchantments locationEnchantments}.
+	 * @param enchantmentId an Enchantment ID **UNIQUE** to this enchantment.
+	 * 	If another enchantment is constructed with the same ID already, the constructor will throw an error.
+	 * 	This is erroneously called an effectID in the fields.
+	 */
+	constructor(
+		enchantmentId: number,
+		name: string,
+		weight: number,
+		type: EnumEnchantmentType,
+	);
+	static getEnchantmentById(id: number): Enchantment | null;
+	static getEnchantmentByLocation(
+		location,
+	): ReturnType<(typeof Enchantment)["locationEnchantments"]["get"]>;
+	/** gets all location enchantments. Yet another Searge fallback name exposing the fact that this is Minecraft ported to the browser! */
+	static func_181077_c(): ReturnType<
+		(typeof Enchantment)["locationEnchantments"]["keys"]
+	>;
+	getWeight(): this["weight"];
+	getMinLevel(): number;
+	getMaxLevel(): number;
+	getMinEnchantability(level: number): number;
+	getMaxEnchantability(level: number): number;
+	calcModifierDamage(level: number, source: DamageSource): number;
+	calcDamageByCreature(
+		level: number,
+		creatureType: EnumCreatureAttribute,
+	): number;
+	canApplyTogether(other: Enchantment): boolean;
+	setName(name: string): this;
+	getName(): this["name"];
+	/**
+	 * @param level enchantment level
+	 * @returns `{translated enchantment name} {roman numeral of level}`
+	 */
+	getTranslatedName(level: number): `${string} ${string}`;
+	canApply(on: ItemStack$1): boolean;
+	onEntityDamaged(
+		user: EntityLivingBase$1,
+		target: Entity$1,
+		level: number,
+	): void;
+	onUserHurt(user: EntityLivingBase$1, attacker: Entity$1, level: number): void;
+	static init(): void;
+	/**
+	 * @param n number to convert to Roman numeral
+	 * @returns a roman numeral for numbers `1-20`. anything out of the range is just `n.toString()`
+	 */
+	static getRomanNumber(n: number): string;
+}
+declare class EnchantmentProtection extends Enchantment {
+	protectionType: number;
+	static readonly protectionName = [
+		"all",
+		"fire",
+		"fall",
+		"explosion",
+		"projectile",
+	];
+	static readonly baseEnchantability = [1, 10, 5, 5, 3];
+	static readonly levelEnchantability = [11, 8, 6, 8, 6];
+	static readonly thresholdEnchantability = [20, 12, 10, 12, 15];
+	constructor(
+		enchantmentId: number,
+		name: string,
+		weight: number,
+		protectionType: number,
+	);
+	getMinEnchantability(level: number): number;
+	getMaxEnchantability(level: number): number;
+	getMaxLevel(): number;
+	calcModifierDamage(level: number, source: DamageSource): number;
+	canApplyTogether(other: Enchantment): boolean;
+	static getFireTimeForEntity(e: EntityLivingBase$1, fireTime: number): number;
+	/** gets blast fire time. Vector can't make a block game without pasting from Minecraft, so obviously this is from MCP. */
+	static func_92092_a(e: EntityLivingBase$1, fireTime: number): number;
+}
+// biome-ignore lint/complexity/noStaticOnlyClass: This is how Miniblox does it...
+declare class Enchantments {
+	static readonly protection = new EnchantmentProtection(
+		0,
+		"protection",
+		10,
+		0,
+	);
+	static readonly fireProtection = new EnchantmentProtection(
+		1,
+		"fire_protection",
+		5,
+		1,
+	);
+	static readonly featherFalling = new EnchantmentProtection(
+		2,
+		"feather_falling",
+		5,
+		2,
+	);
+	static readonly blastProtection = new EnchantmentProtection(
+		3,
+		"blast_protection",
+		2,
+		3,
+	);
+	static readonly projectileProtection = new EnchantmentProtection(
+		4,
+		"projectile_protection",
+		5,
+		4,
+	);
+	static readonly thorns = new EnchantmentThorns(7, "thorns", 1);
+	static readonly sharpness = new EnchantmentDamage(16, "sharpness", 10, 0);
+	static readonly smite = new EnchantmentDamage(17, "smite", 5, 1);
+	static readonly baneOfArthropods = new EnchantmentDamage(
+		18,
+		"bane_of_arthropods",
+		5,
+		2,
+	);
+	static readonly knockback = new EnchantmentKnockback(19, "knockback", 5);
+	static readonly fireAspect = new EnchantmentFireAspect(20, "fire_aspect", 2);
+	static readonly looting = new EnchantmentLootBonus(
+		21,
+		"looting",
+		2,
+		EnumEnchantmentType.WEAPON,
+	);
+	static readonly efficiency = new EnchantmentDigging(32, "efficiency", 10);
+	static readonly silkTouch = new EnchantmentUntouching(33, "silk_touch", 1);
+	static readonly unbreaking = new EnchantmentDurability(34, "unbreaking", 5);
+	static readonly fortune = new EnchantmentLootBonus(
+		35,
+		"fortune",
+		2,
+		EnumEnchantmentType.DIGGER,
+	);
+	static readonly power = new EnchantmentArrowDamage(48, "power", 10);
+	static readonly punch = new EnchantmentArrowKnockback(49, "punch", 2);
+	static readonly flame = new EnchantmentArrowFire(50, "flame", 2);
+	static readonly infinity = new EnchantmentArrowInfinite(51, "infinity", 1);
+	static readonly luckOfTheSea = new EnchantmentLootBonus(
+		61,
+		"luck_of_the_sea",
+		2,
+		EnumEnchantmentType.FISHING_ROD,
+	);
+	/** does nothing basically I forgor */
+	static init(): void;
+}
+//#endregion
+//#region src/effects/potion.d.ts
+// biome-ignore lint/complexity/noStaticOnlyClass: Miniblox's code, can't fix ts.
+declare class Potions {
+	static readonly moveSpeed: Potion;
+	static readonly moveSlowdown: Potion;
+	static readonly digSpeed: Potion;
+	static readonly digSlowdown: Potion;
+	static readonly damageBoost: Potion;
+	static readonly heal: Potion;
+	static readonly harm: Potion;
+	static readonly jump: Potion;
+	static readonly confusion: Potion;
+	static readonly regeneration: Potion;
+	static readonly resistance: Potion;
+	static readonly fireResistance: Potion;
+	static readonly waterBreathing: Potion;
+	static readonly invisibility: Potion;
+	static readonly blindness: Potion;
+	static readonly nightVision: Potion;
+	static readonly hunger: Potion;
+	static readonly weakness: Potion;
+	static readonly poison: Potion;
+	static readonly wither: Potion;
+	static readonly healthBoost: Potion;
+	static readonly absorption: Potion;
+	static readonly saturation: Potion;
+}
+declare class Potion {
+	static potionTypes: Potion[];
+	static potionMap: Map;
+	id: number;
+	attributeModifierMap: Map<unknown, AttributeModifier>;
+	isBadEffect: boolean;
+	liquidColor: unknown;
+	name: string;
+	statusIconIndex: number;
+	effectiveness: number;
+	usable: boolean;
+	getLiquidColor(): this["liquidColor"];
+	getName(): this["name"];
+	setPotionName(name: string): this;
+	hasStatusIcon(): boolean;
+	getStatusIconIndex(): this["statusIconIndex"];
+	getDurationString(): string | undefined;
+	getEffectiveness(): this["effectiveness"];
+	setEffectiveness(effectiveness: number): this;
+	isUsable(): this["usable"];
+	registerPotionAttributeModifier(u, h, p, g): this;
+	getAttributeModifierMap(): this["attributeModifierMap"];
+	removeAttributesModifiersFromEntity(u, entity: Entity$1, p): void;
+	applyAttributesModifiersToEntity(u, entity: Entity$1, p): void;
+	getAttributeModifierAmount(amplifier: number, modifier: AttributeModifier);
+}
+//#endregion
+//#region src/inventory/Inventory.d.ts
+type Crafter = unknown;
+declare class InventoryBasic {
+	inventoryTitle: string;
+	slotsCount: number;
+	inventoryContents: ItemStack$1[];
+	crafters: Crafter[] | null;
+	constructor(inventoryTitle: string, slotsCount: number);
+	/**
+	 * adds a new crafter to the inventory.
+	 * if this.crafters is null, we set it to an empty array.
+	 * in either case, `this.crafters.push(crafter)` is called.
+	 */
+	func_110134_a(crafter: Crafter): void;
+	getInventory(): this["inventoryContents"];
+	getStackInSlot(slot: number): ItemStack$1 | null;
+	decrStackSize(idx: number, count: number): ItemStack$1 | null;
+	func_174894_a(stack: ItemStack$1): ItemStack$1;
+	removeStackFromSlot(idx: number): ItemStack$1 | null;
+	setInventorySlotContents(idx: number, stack: ItemStack$1): void;
+	getSizeInventory(): this["slotsCount"];
+	getName(): this["inventoryTitle"];
+	getDisplayName(): string;
+	getInventoryStackLimit(): number;
+	markDirty(): void;
+	isUseableByPlayer(plr: EntityPlayer$1): boolean;
+	openInventory(plr: EntityPlayer$1): void;
+	closeInventory(plr: EntityPlayer$1): void;
+	isItemValidForSlot(index: number, stack: ItemStack$1): boolean;
+	getField(id: number): number;
+	setField(id: number, value: number): void;
+	getFieldCount(): number;
+	clear(): void;
+}
+declare class InventoryPlayer extends InventoryBasic {
+	currentItem: number;
+	main: (ItemStack$1 | null)[];
+	armor: (ItemStack$1 | null)[];
+	getCurrentItem(): ItemStack$1 | null;
+	hasItem?(item: Item): boolean;
+	addItemStackToInventory(stack: ItemStack$1): boolean;
+	canHarvestBlock(block: Block): boolean;
+	armorItemInSlot(slot: number): ItemStack$1 | null;
+	getTotalArmorValue(): number;
+	damageArmor(damage: number): void;
+	dropAllItems(): void;
+	hasCustomName(): boolean;
+}
+//#endregion
+//#region src/slot/Slot.d.ts
+declare class Slot {
+	slotIndex: number;
+	inventory: InventoryBasic;
+	slotNumber: number;
+	xDisplayPosition: number;
+	yDisplayPosition: number;
+	/**
+	 * @param inventory The inventory we want to extract a slot from.
+	 * @param index The index of the slot in the inventory.
+	 * @param _xDisplayPos unused parameter left over from MCP code.
+	 * @param _yDisplayPos unused parameter left over from MCP code.
+	 */
+	constructor(
+		inventory: InventoryBasic,
+		index: number,
+		_xDisplayPos: number,
+		_yDisplayPos: number,
+	);
+	/**
+	 * if p2 has more items than p1, onCrafting(item,countIncrease) is called
+	 */
+	onSlotChange(p1: ItemStack$1 | null, p2: ItemStack$1 | null): void;
+	onCrafting(stack: ItemStack$1, amount: number): void;
+	onCrafting(stack: ItemStack$1): void;
+	onPickupFromSlot(plr: EntityPlayer$1, stack: ItemStack$1): void;
+	isItemValid(stack: ItemStack$1): boolean;
+	getStack(): ItemStack$1;
+	getHasStack(): boolean;
+	putStack(stack: ItemStack$1): void;
+	onSlotChanged(): void;
+	getSlotStackLimit(): number;
+	getItemStackLimit(stack: ItemStack$1): number;
+	getSlotTexture(): string | null;
+	decrStackSize(count: number): ItemStack$1 | null;
+	canTakeStack(player: EntityPlayer$1): boolean;
+	canBeHovered(): boolean;
+	isHere(inv: InventoryBasic, slot: number): boolean;
+}
+//#endregion
+//#region src/slot/SlotActionType.d.ts
+declare enum SlotActionType {
+	/**
+	 * Left-click pickup/place (clickedButton == 0).
+	 * - If slot is empty: places held item
+	 * - If slot has item and held item is same type: combines stacks
+	 * - If slot has item and held item is different: swaps them
+	 * - If slot ID is -999 (outside container): drops entire held stack
+	 */
+	PICKUP_LEFT = 0,
+	/**
+	 * Right-click pickup/place (clickedButton == 1).
+	 * - SPECIAL: Acts as QUICK_MOVE in this JS version (shift-click behavior)
+	 * - transferStackInSlot() is called to move item to player inventory
+	 * - If same item type exists in slot, retries the action
+	 * - If slot ID is -999: drops 1 item from held stack
+	 */
+	PICKUP_RIGHT = 1,
+	/**
+	 * Number key swap (0-9 for hotbar slots).
+	 * - Swaps clicked slot with hotbar slot specified by clickedButton
+	 * - If hotbar slot is empty and slot is valid: places item there
+	 * - If both slot and hotbar have items: exchanges them
+	 * - If hotbar inventory is different player: adds to empty slots first
+	 */
+	SWAP = 2,
+	/**
+	 * Creative mode item duplication.
+	 * - Requires: player.abilities.creative == true AND held stack is null
+	 * - Clones clicked slot's item to full max stack size
+	 * - Places cloned full-size stack in cursor
+	 */
+	CLONE = 3,
+	/**
+	 * Drop key action.
+	 * - Requires: held stack is null AND slot ID >= 0
+	 * - clickedButton == 0: drops 1 item
+	 * - clickedButton == 1: drops entire slot stack
+	 * - Calls onPickupFromSlot() before dropping
+	 */
+	THROW = 4,
+	/**
+	 * Drag to distribute items across multiple slots.
+	 * - dragEvent 0: Start drag, validates drag mode
+	 *   - dragMode 0: even split across slots
+	 *   - dragMode 1: one item per slot
+	 *   - dragMode 2: creative fill (creative mode only)
+	 * - dragEvent 1: Collecting phase, adds valid slots to dragSlots set
+	 *   - Requires: slot stackSize > dragSlots.size
+	 * - dragEvent 2: Distribution phase, splits held stack across collected slots
+	 *   - Uses dragMode to compute distribution
+	 *   - Requires: held stackSize >= dragSlots.size
+	 */
+	QUICK_CRAFT = 5,
+	/**
+	 * Shift-click to auto-move items (double-click in Java, mode 6 in JS).
+	 * - Scans through slots in two passes:
+	 *   - Pass 1 (if clickedButton==0): forward scan, prioritizes partially-filled stacks
+	 *   - Pass 2: continues to fill stacks to max capacity
+	 *   - If clickedButton==1: reverse scan (from end to start)
+	 * - Merges with existing stacks or finds empty slots
+	 * - Respects canMergeSlot() and canAddItemToSlot() checks
+	 * - Calls detectAndSendChanges() at end
+	 */
+	QUICK_MOVE = 6,
+}
+//#endregion
+//#region src/container/Container.d.ts
+declare class Container {
+	windowId: number;
+	transactionID: number;
+	dragMode: number;
+	dragEvent: number;
+	crafters: Array<ICrafting>;
+	playerList: Set<EntityPlayer$1>;
+	inventoryItemStacks: ItemStack$1[];
+	inventorySlots: (Slot | null)[];
+	dragSlots: Set<Slot>;
+	addSlotToContainer(slot: Slot): Slot;
+	onCraftGuiOpened(u): void;
+	/** every ItemStack from {@linkcode Container.inventorySlots} */
+	getInventory(): ItemStack$1[];
+	detectAndSendChanges(): void;
+	enchantItem(_u, _h): boolean;
+	getSlot(id: number): Slot | undefined;
+	transferStackInSlot(_u, id): ItemStack$1 | null;
+	static extractDragMode(from: number): number;
+	static getDragEvent(from: number): number;
+	/**
+	 * seems to only be used with dragging in GuiContainer.
+	 * @param a 0-2, which correspond to PICKUP_LEFT, PICKUP_RIGHT, and SWAP.
+	 * @param b seems to only be used with this.dragSplittingLimit
+	 * @returns `(a & 3) | ((b & 3) << 2)`
+	 */
+	static getButtonType(a: number, b: number): number;
+	/**
+	 * Checks if a drag mode is valid for the player.
+	 * @param mode the drag mode
+	 * @param player the player executing this drag mode
+	 * @returns if the drag mode is valid (mode 0 and 1 are unconditionally permitted, and mode 2 is only permitted when in creative)
+	 */
+	static isValidDragMode(mode: number, player: EntityPlayer$1): boolean;
+	/** resets the drag state variables. sets {@linkcode Container.dragEvent dragEvent} to 0 and clears all items in {@linkcode Container.dragSlots dragSlots} */
+	resetDrag(): void;
+	static canAddItemToSlot(
+		slot: Slot,
+		other: Slot,
+		stackSizeMatters: boolean,
+	): boolean;
+	static computeStackSize(
+		slots: Set<Slot>,
+		dragMode: number,
+		dragStack: ItemStack$1,
+		slotStackSize: number,
+	): void;
+	canDragIntoSlot(_u): boolean;
+	slotClick(
+		slotId: number,
+		clickedButton: number,
+		mode: number,
+		player: EntityPlayer$1,
+	): ItemStack$1 | null;
+	canMergeSlot(_u, _h): boolean;
+	retrySlotClick(
+		slotId: number,
+		clickedButton: number,
+		_modeUnused: number,
+		player: EntityPlayer$1,
+	): void;
+	onContainerClosed(player: EntityPlayer$1): void;
+	onCraftMatrixChanged(_u): void;
+	putStackInSlot(id: number, stack: ItemStack$1): void;
+	putStacksInSlots(stacks: ItemStack$1[]): void;
+	updateProgressBar(_id: number, _data: number): void;
+	getNextTransactionID(_player: InventoryPlayer): number;
+	getCanCraft(player: EntityPlayer$1): boolean;
+	setCanCraft(target: EntityPlayer$1, canCraft: boolean): void;
+	mergeItemStack(
+		stack: ItemStack$1,
+		startIndex: number,
+		endIndex: number,
+		reverseDirection: boolean,
+	): boolean;
+	static calcRedstone(inv: InventoryBasic): number;
+	static calcRedstone(anythingElse: unknown): 0;
+	static calcRedstone(inv: InventoryBasic): number;
+	static calcRedstoneFromInventory(inv: null): 0;
+	static calcRedstoneFromInventory(inv: InventoryBasic | null): number;
+}
+//#endregion
+//#region src/container/ContainerPlayer.d.ts
+declare class ContainerPlayer extends Container {
+	readonly isLocalWorld: boolean;
+	readonly thePlayer: EntityPlayer$1;
+	constructor(
+		playerInventory: InventoryPlayer,
+		isLocalWorld: boolean,
+		thePlayer: EntityPlayer$1,
+	);
+	canInteractWith(_player: EntityPlayer$1): boolean;
+	transferStackInSlot(plr: EntityPlayer$1, index: number): ItemStack$1 | null;
+}
+//#endregion
+//#region src/game/gamemode.d.ts
+// GameMode and Abilities extracted from Impact
+declare class GameMode {
+	static readonly SURVIVAL: GameMode;
+	static readonly CREATIVE: GameMode;
+	static readonly ADVENTURE: GameMode;
+	static readonly SPECTATOR: GameMode;
+	static fromId(id: string | number): GameMode;
+	static fromName(name: string): GameMode;
+	getId(): number;
+	getName(): string;
+	isSurvivalOrAdventure(): boolean;
+	isCreative(): boolean;
+	isSurvival(): boolean;
+	isAdventure(): boolean;
+	isSpectator(): boolean;
+}
+declare class Abilities {
+	disableDamage: boolean;
+	isFlying: boolean;
+	allowFlying: boolean;
+	isCreativeMode: boolean;
+	allowEdit: boolean;
+	flySpeed: number;
+	walkSpeed: number;
+	getFlySpeed(): number;
+	setFlySpeed(speed: number): void;
+	getWalkSpeed(): number;
+	setPlayerWalkSpeed(speed: number): void;
+}
+//#endregion
+//#region src/game/team.d.ts
+declare class Team$1 {
+	color: string;
+	members: EntityPlayer$1[];
+	friendlyFire: boolean;
+	prefix: string;
+	name: string;
+	displayName?: string;
+	constructor(name: string, displayName?: string);
+	isEqual(other: Team$1): boolean;
+	getName(): this["name"];
+	getDisplayName(): this["displayName"] extends undefined
+		? this["name"]
+		: this["displayName"];
+	setDisplayName(displayName?: string): void;
+	setPrefix(prefix: string): void;
+	addMember(member: EntityPlayer$1): void;
+	removeMember(member: EntityPlayer$1): void;
+	empty(): void;
+	setColor(color: string): void;
+	setFriendlyFire(friendlyFire: boolean): void;
+	canAttack(otherTeam: Team$1): boolean;
+}
+//#endregion
+//#region src/network/packetTypes.d.ts
+/** SPacket / Serverbound packets */
+type C2SPacket =
+	| SPacketAdminAction
+	| SPacketAnalytics
+	| SPacketClickWindow
+	| SPacketCloseWindow
+	| SPacketConfirmTransaction
+	| SPacketEnchantItem
+	| SPacketEntityAction
+	| SPacketHeldItemChange
+	| SPacketLoginStart
+	| SPacketMessage
+	| SPacketOpenShop
+	| SPacketPing
+	| SPacketPlayerAbilities
+	| SPacketPlayerAction
+	| SPacketPlayerPosLook
+	| SPacketRespawn
+	| SPacketTabComplete$1
+	| SPacketUpdateSign
+	| SPacketUseEntity
+	| SPacketUpdateCommandBlock
+	| SPacketQueueNext
+	| SPacketPlayerInput
+	| SPacketBreakBlock
+	| SPacketClick
+	| SPacketCraftItem
+	| SPacketPlaceBlock
+	| SPacketRequestChunk
+	| SPacketUpdateInventory
+	| SPacketUseItem;
+/** CPacket / Clientbound packets */
+type S2CPacket =
+	| CPacketAnimation$1
+	| CPacketBlockAction$1
+	| CPacketBlockUpdate$1
+	| CPacketChangeServers$1
+	| CPacketChunkData$1
+	| CPacketCloseWindow$1
+	| CPacketConfirmTransaction$1
+	| CPacketDestroyEntities$1
+	| CPacketDisconnect$1
+	| CPacketEntityAction$1
+	| CPacketEntityEquipment$1
+	| CPacketEntityMetadata$1
+	| CPacketEntityPositionAndRotation$1
+	| CPacketEntityRelativePositionAndRotation$1
+	| CPacketEntityStatus$1
+	| CPacketEntityVelocity$1
+	| CPacketExplosion$1
+	| CPacketJoinGame$1
+	| CPacketLeaderboard$1
+	| CPacketLocalStorage$1
+	| CPacketMessage$1
+	| CPacketOpenWindow$1
+	| CPacketParticles$1
+	| CPacketPlayerList$1
+	| CPacketPlayerPosition$1
+	| CPacketPlayerPosLook$1
+	| CPacketPlayerReconciliation$1
+	| CPacketPong$1
+	| CPacketRespawn$1
+	| CPacketScoreboard$1
+	| CPacketServerInfo$1
+	| CPacketSetSlot$1
+	| CPacketSignEditorOpen$1
+	| CPacketSoundEffect$1
+	| CPacketSpawnEntity$1
+	| CPacketSpawnPlayer$1
+	| CPacketTabComplete$1
+	| CPacketTitle$1
+	| CPacketUpdate$1
+	| CPacketUpdateHealth$1
+	| CPacketUpdateLeaderboard$1
+	| CPacketUpdateScoreboard$1
+	| CPacketUpdateSign$1
+	| CPacketUpdateStatus$1
+	| CPacketWindowItems$1
+	| CPacketWindowProperty$1
+	| CPacketUseBed$1
+	| CPacketQueueNext$1
+	| CPacketSpawnExperienceOrb$1
+	| CPacketSetExperience$1
+	| CPacketOpenShop$1
+	| CPacketShopProperties$1
+	| CPacketEntityProperties$1
+	| CPacketEntityEffect$1
+	| CPacketRemoveEntityEffect$1
+	| CPacketUpdateCommandBlock$1
+	| CPacketEntityAttach$1
+	| CPacketServerMetadata$1
+	| CPacketTimeUpdate$1;
+// note: Miniblox's ClientDecoder handles these by re-triggering the receive packet event for client bound combined packets.
+/*| packets.ClientBoundCombined*/
+type AnyPacket$1 = C2SPacket | S2CPacket;
+//#endregion
+//#region src/packets/Packet.d.ts
+declare class Message<T extends object> {
+	constructor(data?: T);
+}
+declare class SPacketLoginStart extends Message<SPacketLoginStart> {
+	session?: string;
+	hydration?: string;
+	metricsId: string;
+	requestedUuid?: string;
+	clientVersion: string;
+}
+declare class PBItemStack extends Message<PBItemStack> {
+	/**
+	 * @type {PBItemStack}
+	 */
+	static EMPTY: PBItemStack;
+	present: boolean;
+	id?: number;
+	stackSize?: number;
+	durability?: number;
+	data: string;
+}
+declare class PBBlockPos extends Message<PBBlockPos> {
+	x: number;
+	y: number;
+	z: number;
+}
+declare class PBVector3 extends Message<PBVector3> {
+	x: number;
+	y: number;
+	z: number;
+}
+declare class PBFloatVector3 extends Message<PBFloatVector3> {
+	x: number;
+	y: number;
+	z: number;
+	constructor(pos: {
+		x: number;
+		y: number;
+		z: number;
+	});
+}
+declare class CPacketEntityVelocity$1 extends Message<CPacketEntityVelocity$1> {
+	id: number;
+	motion: PBFloatVector3;
+}
+declare class CPacketChunkData$1 extends Message<CPacketChunkData$1> {
+	x: number;
+	z: number;
+	cells: PBCell[];
+	tileEntities: PBTileEntity[];
+	dimension: number;
+	biomes: number[];
+}
+declare class PBCell extends Message<PBCell> {
+	y: number;
+	bitsPerEntry: number;
+	palette: number;
+	bitArray: Uint8Array;
+	blockRefCount: number;
+}
+declare class PBTileEntity extends Message<PBTileEntity> {
+	x: number;
+	y: number;
+	z: number;
+	nbt: Uint8Array;
+}
+declare class CPacketEntityEquipment$1 extends Message<CPacketEntityEquipment$1> {
+	id: number;
+	equipment: Equipment[];
+}
+declare class Equipment extends Message<Equipment> {
+	slot: Equipment_Slot;
+	item: PBItemStack;
+}
+declare class SPacketUpdateInventory extends Message<SPacketUpdateInventory> {
+	main: PBItemStack[];
+	armor: PBItemStack[];
+	idkWhatThisIs: PBItemStack;
+}
+declare class CPacketUpdateSign$1 extends Message<CPacketUpdateSign$1> {
+	pos: PBBlockPos;
+	lines: string[];
+}
+declare class CPacketUpdateCommandBlock$1 extends Message<CPacketUpdateCommandBlock$1> {
+	pos: PBBlockPos;
+	command: string;
+	commands: string[];
+	repeat: boolean;
+}
+declare class SPacketCloseWindow extends Message<SPacketCloseWindow> {
+	windowId: number;
+}
+declare class SPacketEntityAction extends Message<SPacketEntityAction> {
+	id: number;
+	sneak?: boolean;
+	sprinting?: boolean;
+	punching?: boolean;
+	fire?: boolean;
+	stopSleeping?: boolean;
+}
+declare class SPacketPlayerAbilities extends Message<SPacketPlayerAbilities> {
+	isFlying: boolean;
+}
+declare class SPacketPlayerPosLook extends Message<SPacketPlayerPosLook> {
+	pos?: PBFloatVector3;
+	yaw?: number;
+	pitch?: number;
+	onGround: boolean;
+}
+declare class Vector3$1 {
+	x: number;
+	y: number;
+	z: number;
+	constructor(data: {
+		x: number;
+		y: number;
+		z: number;
+	});
+}
+declare class SPacketRespawn$1 {}
+declare class SPacketOpenShop extends Message<SPacketOpenShop> {}
+declare class SPacketBreakBlock extends Message<SPacketBreakBlock> {
+	location: PBBlockPos;
+	start: boolean;
+}
+declare class SPacketClick extends Message<SPacketClick> {
+	location: PBBlockPos;
+}
+declare class SPacketPlaceBlock extends Message<SPacketPlaceBlock> {
+	positionIn: PBBlockPos;
+	side: PBEnumFacing;
+	hitX: number;
+	hitY: number;
+	hitZ: number;
+}
+declare class SPacketUseItem extends Message<SPacketUseItem> {}
+declare class SPacketClickWindow extends Message<SPacketClickWindow> {
+	windowId: number;
+	slotId: number;
+	button: number;
+	/**
+	 * the click mode, prefer using the enum unless you need a custom mode (i.e. exploiting bugs)
+	 */
+	mode: SlotActionType | number;
+	itemStack: PBItemStack;
+	transactionId: number;
+}
+declare class SPacketPlayerAction extends Message<SPacketPlayerAction> {
+	position: PBBlockPos;
+	facing: PBEnumFacing;
+	action: PBAction;
+}
+declare class SPacketUseEntity extends Message<SPacketUseEntity> {
+	id: number;
+	action: SPacketUseEntity_Action;
+	hitVec?: PBFloatVector3;
+}
+declare class SPacketMessage extends Message<SPacketMessage> {
+	text: string;
+}
+declare class CPacketAnimation$1 extends Message<CPacketAnimation$1> {
+	id: number;
+	type: number;
+}
+declare class CPacketBlockAction$1 extends Message<CPacketBlockAction$1> {
+	blockPos: PBBlockPos;
+	instrument: number;
+	pitch: number;
+	blockId: number;
+}
+declare class CPacketBlockUpdate$1 extends Message<CPacketBlockUpdate$1> {
+	id: number;
+	x: number;
+	y: number;
+	z: number;
+	prerender?: boolean;
+}
+declare class CPacketChangeServers$1 extends Message<CPacketChangeServers$1> {
+	url: string;
+}
+declare class CPacketCloseWindow$1 extends Message<CPacketCloseWindow$1> {
+	windowId: number;
+}
+declare class CPacketConfirmTransaction$1 extends Message<CPacketConfirmTransaction$1> {
+	windowId: number;
+	uid: number;
+	accepted: boolean;
+}
+declare class CPacketDestroyEntities$1 extends Message<CPacketDestroyEntities$1> {
+	ids: number[];
+}
+declare class CPacketDisconnect$1 extends Message<CPacketDisconnect$1> {
+	reason: string;
+}
+declare class CPacketEntityAction$1 extends Message<CPacketEntityAction$1> {
+	id: number;
+	sneak?: boolean;
+	sprinting?: boolean;
+	punching?: boolean;
+	fire?: boolean;
+}
+declare class CPacketEntityAttach$1 extends Message<CPacketEntityAttach$1> {
+	leash: number;
+	entity: number;
+	vehicle: number;
+}
+declare class CPacketEntityMetadata$1 extends Message<CPacketEntityMetadata$1> {
+	id: number;
+	data: PBWatchableObject[];
+}
+declare class PBWatchableObject extends Message<PBWatchableObject> {
+	dataValueId: number;
+	objectType: number;
+	intValue?: number;
+	floatValue?: number;
+	stringValue?: string;
+	vector?: PBVector3;
+	itemStack?: PBItemStack;
+	blockPos?: PBBlockPos;
+}
+declare class CPacketEntityPositionAndRotation$1 extends Message<CPacketEntityPositionAndRotation$1> {
+	id: number;
+	pos?: PBVector3;
+	vel?: PBVector3;
+	yaw?: number;
+	pitch?: number;
+	onGround?: boolean;
+}
+declare class CPacketEntityRelativePositionAndRotation$1 extends Message<CPacketEntityRelativePositionAndRotation$1> {
+	id: number;
+	pos: PBVector3;
+	vel: PBVector3;
+	yaw: number;
+	pitch: number;
+	onGround: boolean;
+}
+declare class CPacketEntityStatus$1 extends Message<CPacketEntityStatus$1> {
+	entityId: number;
+	entityStatus: number;
+}
+declare class CPacketExplosion$1 extends Message<CPacketExplosion$1> {
+	pos: PBFloatVector3;
+	strength: number;
+	blocks: PBBlockPos[];
+	playerPos?: PBFloatVector3;
+}
+declare class PBCosmetics extends Message<PBCosmetics> {
+	skin: string;
+	cape: string;
+	aura: string;
+	trail: string;
+	color: string;
+	hat: string;
+}
+declare class CPacketServerInfo$1 extends Message<CPacketServerInfo$1> {
+	serverId: string;
+	serverName: string;
+	serverVersion: string;
+	serverCategory: string;
+	accessControl: string;
+	worldType: string;
+	doDaylightCycle: boolean | null;
+	inviteCode: string | null;
+	cheats: boolean | null;
+	pvpEnabled: boolean | null;
+	startTime: bigint;
+	playerPermissionEntries: PlayerPermissionEntry[];
+	metadata: string | null;
+	commandBlocksEnabled: boolean | null;
+}
+declare class PlayerPermissionEntry extends Message<PlayerPermissionEntry> {
+	uuid: string;
+	username: string;
+	permissionLevel: number;
+	color: string | null;
+	rank: number | null;
+	level: number | null;
+	verified: boolean | null;
+	toString(): string;
+}
+declare class CPacketJoinGame$1 extends Message<CPacketJoinGame$1> {
+	canConnect: boolean;
+	errorMessage: string;
+	tick: number;
+	gamemode: string;
+	name: string;
+	enablePlayerCollision: boolean;
+	cosmetics: PBCosmetics;
+	rank: string;
+	serverInfo: CPacketServerInfo$1;
+	uuid: string;
+	dimension: number;
+}
+declare class CPacketLeaderboard$1 extends Message<CPacketLeaderboard$1> {
+	id: string;
+	pos: PBVector3;
+	yaw: number | null;
+	title: string;
+	content: string[];
+}
+declare class CPacketLocalStorage$1 extends Message<CPacketLocalStorage$1> {
+	action: CPacketLocalStorage_Action;
+	key: string;
+	value: string | null;
+}
+/** @enum */
+declare const CPacketLocalStorage_Action: {
+	DEFAULT: number;
+	0: string;
+	REMOVE: number;
+	1: string;
+	SET: number;
+	2: string;
+};
+declare class CPacketMessage$1 extends Message<CPacketMessage$1> {
+	text?: string;
+	id?: string;
+	color?: string;
+	discard?: boolean;
+	toast?: boolean;
+	timer?: number;
+}
+declare class CPacketOpenShop$1 extends Message<CPacketOpenShop$1> {
+	type: string;
+}
+declare class CPacketOpenWindow$1 extends Message<CPacketOpenWindow$1> {
+	windowId: number;
+	guiID: string;
+	title?: string;
+	size?: number;
+}
+declare class CPacketParticles$1 extends Message<CPacketParticles$1> {
+	particleId: number;
+	longDistance?: boolean;
+	x?: number;
+	y?: number;
+	z?: number;
+	xOffset?: number;
+	yOffset?: number;
+	zOffset?: number;
+	speed?: number;
+	count?: number;
+	particleArguments: number[];
+}
+declare class CPacketPlayerList$1 extends Message<CPacketPlayerList$1> {
+	players: PlayerData[];
+}
+declare class PlayerData extends Message<PlayerData> {
+	id: number;
+	uuid: string;
+	permissionLevel: number;
+	ping?: number;
+	name?: string;
+	color?: string;
+	rank?: string;
+	level?: number;
+	verified?: boolean;
+}
+declare class CPacketPlayerPosLook$1 extends Message<CPacketPlayerPosLook$1> {
+	x: number;
+	y: number;
+	z: number;
+	yaw: number;
+	pitch: number;
+}
+declare class CPacketPlayerPosition$1 extends Message<CPacketPlayerPosition$1> {
+	x: number;
+	y: number;
+	z: number;
+}
+declare class CPacketPlayerReconciliation$1 extends Message<CPacketPlayerReconciliation$1> {
+	x: number;
+	y: number;
+	z: number;
+	yaw: number;
+	pitch: number;
+	lastProcessedInput: number;
+	reset?: boolean;
+}
+declare class CPacketPong$1 extends Message<CPacketPong$1> {
+	time: number;
+	mspt: number;
+	tick: number;
+}
+declare class CPacketRespawn$1 extends Message<CPacketRespawn$1> {
+	notDeath?: boolean;
+	client?: boolean;
+	dimension?: number;
+}
+declare class CPacketScoreboard$1 extends Message<CPacketScoreboard$1> {
+	title: string;
+	content: ScoreboardContent[];
+}
+declare class ScoreboardContent extends Message<ScoreboardContent> {
+	columns: string[];
+}
+declare class CPacketServerMetadata$1 extends Message<CPacketServerMetadata$1> {
+	metadata: string;
+}
+declare class CPacketSetSlot$1 extends Message<CPacketSetSlot$1> {
+	windowId: number;
+	slot: number;
+	slotData: PBItemStack;
+}
+declare class CPacketSignEditorOpen$1 extends Message<CPacketSignEditorOpen$1> {
+	signPosition: PBBlockPos;
+}
+declare class CPacketSoundEffect$1 extends Message<CPacketSoundEffect$1> {
+	sound: string;
+	location?: PBVector3;
+	volume?: number;
+	pitch?: number;
+}
+declare class CPacketSpawnEntity$1 extends Message<CPacketSpawnEntity$1> {
+	id: number;
+	type: number;
+	pos?: PBVector3;
+	yaw?: number;
+	pitch?: number;
+	motion?: PBFloatVector3;
+	item?: PBItemStack;
+	shooterId?: number;
+	state?: number;
+	texture?: string;
+}
+declare class CPacketSpawnExperienceOrb$1 extends Message<CPacketSpawnExperienceOrb$1> {
+	id: number;
+	x: number;
+	y: number;
+	z: number;
+	xpValue: number;
+}
+declare class CPacketSpawnPlayer$1 extends Message<CPacketSpawnPlayer$1> {
+	id: number;
+	name: string;
+	gamemode: string;
+	operator?: boolean;
+	pos: PBFloatVector3;
+	yaw: number;
+	pitch: number;
+	cosmetics: PBCosmetics;
+	rank?: string;
+	socketId: string;
+}
+declare class CPacketTabComplete$1 extends Message<CPacketTabComplete$1> {
+	matches: string[];
+}
+declare class CPacketTitle$1 extends Message<CPacketTitle$1> {
+	title: string;
+	duration: number;
+}
+declare class CPacketUpdateHealth$1 extends Message<CPacketUpdateHealth$1> {
+	id: number;
+	hp?: number;
+	food?: number;
+	foodSaturation?: number;
+	oxygen?: number;
+}
+declare class CPacketUpdateLeaderboard$1 extends Message<CPacketUpdateLeaderboard$1> {
+	id: string;
+	content: string[];
+}
+declare class CPacketUpdateScoreboard$1 extends Message<CPacketUpdateScoreboard$1> {
+	index: number;
+	columns: string[];
+}
+declare class CPacketUpdateStatus$1 extends Message<CPacketUpdateStatus$1> {
+	id: number;
+	mode?: number;
+	rank?: string;
+	color?: string;
+	hidePlayers?: boolean;
+}
+declare class CPacketUpdate$1 extends Message<CPacketUpdate$1> {
+	tick: number;
+	t: number;
+	mspt: number;
+}
+declare class CPacketWindowItems$1 extends Message<CPacketWindowItems$1> {
+	windowId: number;
+	items: PBItemStack[];
+}
+declare class CPacketWindowProperty$1 extends Message<CPacketWindowProperty$1> {
+	windowId: number;
+	varIndex: number;
+	varValue: number;
+}
+declare class SPacketRespawn extends Message<SPacketRespawn> {}
+declare class SPacketTabComplete$1 {
+	message: string;
+}
+declare class SPacketCraftItem extends Message<SPacketCraftItem> {
+	data: string;
+}
+declare class SPacketRequestChunk extends Message<SPacketRequestChunk> {
+	x: number;
+	z: number;
+}
+declare class SPacketAdminAction extends Message<SPacketAdminAction> {
+	action: {
+		case: undefined;
+	};
+}
+declare class KickPlayer extends Message<KickPlayer> {}
+declare class BanPlayer extends Message<BanPlayer> {
+	uuid: string;
+}
+declare class UnbanPlayer extends Message<UnbanPlayer> {
+	uuid: string;
+}
+declare class StopServer extends Message<StopServer> {}
+declare class PromotePlayer extends Message<PromotePlayer> {
+	uuid: string;
+}
+declare class DemotePlayer extends Message<DemotePlayer> {
+	uuid: string;
+}
+declare class UpdateAccessControl extends Message<UpdateAccessControl> {
+	accessControl: string;
+}
+declare class UpdateCheats extends Message<UpdateCheats> {
+	cheats: string;
+}
+declare class UpdatePvP extends Message<UpdatePvP> {
+	enabled: boolean;
+}
+declare class SPacketAnalytics extends Message<SPacketAnalytics> {
+	fps: number;
+	ping: number;
+}
+declare class SPacketConfirmTransaction extends Message<SPacketConfirmTransaction> {
+	windowId: number;
+	actionNumber: number;
+	accepted: boolean;
+}
+declare class SPacketHeldItemChange extends Message<SPacketHeldItemChange> {
+	slot: number;
+}
+declare class SPacketPlayerInput extends Message<SPacketPlayerInput> {
+	sequenceNumber: number;
+	left: boolean;
+	right: boolean;
+	up: boolean;
+	down: boolean;
+	yaw: number;
+	pitch: number;
+	jump: boolean;
+	sneak: boolean;
+	sprint: boolean;
+	pos: PBFloatVector3;
+}
+declare class SPacketPing extends Message<SPacketPing> {
+	time: number;
+}
+declare class SPacketUpdateSign extends Message<SPacketUpdateSign> {
+	pos: PBBlockPos;
+	lines: string[];
+}
+declare class CPacketEntityEffect$1 extends Message<CPacketEntityEffect$1> {
+	id: number;
+	effectId: number;
+	amplifier: number;
+	duration: number;
+	hideParticles: boolean;
+}
+declare class CPacketEntityProperties$1 extends Message<CPacketEntityProperties$1> {
+	id: number;
+	data: PBSnapshot[];
+}
+declare class PBSnapshot extends Message<PBSnapshot> {
+	id: string;
+	value: number;
+	modifiers: PBModifier[];
+}
+declare class PBModifier extends Message<PBModifier> {
+	id: string;
+	amount: number;
+	operation: number;
+}
+declare class CPacketQueueNext$1 extends Message<CPacketQueueNext$1> {
+	minigameId: string;
+	minigameConfig: string;
+}
+declare class CPacketRemoveEntityEffect$1 extends Message<CPacketRemoveEntityEffect$1> {
+	id: number;
+	effectId: number;
+}
+declare class CPacketSetExperience$1 extends Message<CPacketSetExperience$1> {
+	experience: number;
+	experienceTotal: number;
+	level: number;
+}
+declare class CPacketShopProperty extends Message<CPacketShopProperty> {
+	name?: string;
+	value?: string;
+}
+declare class CPacketShopProperties$1 extends Message<CPacketShopProperties$1> {
+	properties: CPacketShopProperty[];
+}
+declare class CPacketUseBed$1 extends Message<CPacketUseBed$1> {
+	id: number;
+	bedPos: PBBlockPos;
+}
+declare class CPacketTimeUpdate$1 extends Message<CPacketTimeUpdate$1> {
+	totalTime: number;
+	worldTime: number;
+}
+declare class ClientBoundCombined$1 extends Message<ClientBoundCombined$1> {
+	packets: ClientBoundCombined_CPacket[];
+}
+declare class ClientBoundCombined_CPacket extends Message<ClientBoundCombined_CPacket> {
+	packet: S2CPacket;
+}
+declare class SPacketEnchantItem extends Message<SPacketEnchantItem> {}
+declare class SPacketQueueNext extends Message<SPacketQueueNext> {}
+declare class SPacketUpdateCommandBlock extends Message<SPacketUpdateCommandBlock> {
+	pos: PBBlockPos;
+	command: string | null;
+	commands: string[] | null;
+	repeat: boolean | null;
+}
+declare const CPACKET_MAP: {
+		CPacketAnimation: typeof CPacketAnimation$1;
+		CPacketBlockAction: typeof CPacketBlockAction$1;
+		CPacketBlockUpdate: typeof CPacketBlockUpdate$1;
+		CPacketChangeServers: typeof CPacketChangeServers$1;
+		CPacketChunkData: typeof CPacketChunkData$1;
+		CPacketCloseWindow: typeof CPacketCloseWindow$1;
+		CPacketConfirmTransaction: typeof CPacketConfirmTransaction$1;
+		CPacketDestroyEntities: typeof CPacketDestroyEntities$1;
+		CPacketDisconnect: typeof CPacketDisconnect$1;
+		CPacketEntityAction: typeof CPacketEntityAction$1;
+		CPacketEntityEquipment: typeof CPacketEntityEquipment$1;
+		CPacketEntityMetadata: typeof CPacketEntityMetadata$1;
+		CPacketEntityPositionAndRotation: typeof CPacketEntityPositionAndRotation$1;
+		CPacketEntityRelativePositionAndRotation: typeof CPacketEntityRelativePositionAndRotation$1;
+		CPacketEntityStatus: typeof CPacketEntityStatus$1;
+		CPacketEntityVelocity: typeof CPacketEntityVelocity$1;
+		CPacketExplosion: typeof CPacketExplosion$1;
+		CPacketJoinGame: typeof CPacketJoinGame$1;
+		CPacketLeaderboard: typeof CPacketLeaderboard$1;
+		CPacketLocalStorage: typeof CPacketLocalStorage$1;
+		CPacketMessage: typeof CPacketMessage$1;
+		CPacketOpenWindow: typeof CPacketOpenWindow$1;
+		CPacketParticles: typeof CPacketParticles$1;
+		CPacketPlayerList: typeof CPacketPlayerList$1;
+		CPacketPlayerPosition: typeof CPacketPlayerPosition$1;
+		CPacketPlayerPosLook: typeof CPacketPlayerPosLook$1;
+		CPacketPlayerReconciliation: typeof CPacketPlayerReconciliation$1;
+		CPacketPong: typeof CPacketPong$1;
+		CPacketRespawn: typeof CPacketRespawn$1;
+		CPacketScoreboard: typeof CPacketScoreboard$1;
+		CPacketServerInfo: typeof CPacketServerInfo$1;
+		CPacketSetSlot: typeof CPacketSetSlot$1;
+		CPacketSignEditorOpen: typeof CPacketSignEditorOpen$1;
+		CPacketSoundEffect: typeof CPacketSoundEffect$1;
+		CPacketSpawnEntity: typeof CPacketSpawnEntity$1;
+		CPacketSpawnPlayer: typeof CPacketSpawnPlayer$1;
+		CPacketTabComplete: typeof CPacketTabComplete$1;
+		CPacketTitle: typeof CPacketTitle$1;
+		CPacketUpdate: typeof CPacketUpdate$1;
+		CPacketUpdateHealth: typeof CPacketUpdateHealth$1;
+		CPacketUpdateLeaderboard: typeof CPacketUpdateLeaderboard$1;
+		CPacketUpdateScoreboard: typeof CPacketUpdateScoreboard$1;
+		CPacketUpdateSign: typeof CPacketUpdateSign$1;
+		CPacketUpdateStatus: typeof CPacketUpdateStatus$1;
+		CPacketWindowItems: typeof CPacketWindowItems$1;
+		CPacketWindowProperty: typeof CPacketWindowProperty$1;
+		CPacketUseBed: typeof CPacketUseBed$1;
+		CPacketQueueNext: typeof CPacketQueueNext$1;
+		CPacketSpawnExperienceOrb: typeof CPacketSpawnExperienceOrb$1;
+		CPacketSetExperience: typeof CPacketSetExperience$1;
+		CPacketOpenShop: typeof CPacketOpenShop$1;
+		CPacketShopProperties: typeof CPacketShopProperties$1;
+		CPacketEntityProperties: typeof CPacketEntityProperties$1;
+		CPacketEntityEffect: typeof CPacketEntityEffect$1;
+		CPacketRemoveEntityEffect: typeof CPacketRemoveEntityEffect$1;
+		CPacketUpdateCommandBlock: typeof CPacketUpdateCommandBlock$1;
+		CPacketEntityAttach: typeof CPacketEntityAttach$1;
+		CPacketServerMetadata: typeof CPacketServerMetadata$1;
+		CPacketTimeUpdate: typeof CPacketTimeUpdate$1;
+		ClientBoundCombined: typeof ClientBoundCombined$1;
+	},
+	SPACKET_MAP: {
+		SPacketAdminAction: typeof SPacketAdminAction;
+		SPacketAnalytics: typeof SPacketAnalytics;
+		SPacketClickWindow: typeof SPacketClickWindow;
+		SPacketCloseWindow: typeof SPacketCloseWindow;
+		SPacketConfirmTransaction: typeof SPacketConfirmTransaction;
+		SPacketEnchantItem: typeof SPacketEnchantItem;
+		SPacketEntityAction: typeof SPacketEntityAction;
+		SPacketHeldItemChange: typeof SPacketHeldItemChange;
+		SPacketLoginStart: typeof SPacketLoginStart;
+		SPacketMessage: typeof SPacketMessage;
+		SPacketOpenShop: typeof SPacketOpenShop;
+		SPacketPing: typeof SPacketPing;
+		SPacketPlayerAbilities: typeof SPacketPlayerAbilities;
+		SPacketPlayerAction: typeof SPacketPlayerAction;
+		SPacketPlayerPosLook: typeof SPacketPlayerPosLook;
+		SPacketRespawn: typeof SPacketRespawn;
+		SPacketTabComplete: typeof SPacketTabComplete$1;
+		SPacketUpdateSign: typeof SPacketUpdateSign;
+		SPacketUseEntity: typeof SPacketUseEntity;
+		SPacketUpdateCommandBlock: typeof SPacketUpdateCommandBlock;
+		SPacketQueueNext: typeof SPacketQueueNext;
+		SPacketPlayerInput: typeof SPacketPlayerInput;
+		SPacketBreakBlock: typeof SPacketBreakBlock;
+		SPacketClick: typeof SPacketClick;
+		SPacketCraftItem: typeof SPacketCraftItem;
+		SPacketPlaceBlock: typeof SPacketPlaceBlock;
+		SPacketRequestChunk: typeof SPacketRequestChunk;
+		SPacketUpdateInventory: typeof SPacketUpdateInventory;
+		SPacketUseItem: typeof SPacketUseItem;
+	},
+	NAME_TO_ID: {
+		[k: string]: number;
+	},
+	ID_TO_PACKET: {
+		[id: number]: AnyPacket;
+	},
+	ID_TO_NAME: {
+		[id: number]: string;
+	};
+//#endregion
+//#region src/entities/EntityPlayer.d.ts
+declare interface IInterface {
+	getGuiID(): string;
+}
+declare class EntityPlayer$1 extends EntityLivingBase$1 {
+	socketId: string | null;
+	mode: GameMode;
+	inventory: InventoryPlayer;
+	inventoryEnderChest: InventoryEnderChest;
+	abilities: Abilities;
+	inventoryContainer: ContainerPlayer;
+	openContainer: Container;
+	punching: boolean;
+	flySpeed: number;
+	speedInAir: number;
+	name: string;
+	operator: boolean;
+	effects: EffectsManager | null;
+	foodStats: FoodStats;
+	team: Team$1 | undefined;
+	actualName: string;
+	experienceLevel: number;
+	lastXPSound: number;
+	experienceTotal: number;
+	experience: number;
+	xpSeed: number;
+	itemInUse: ItemStack$1 | null;
+	itemInUseCount: number;
+	type: string;
+	identifier: string;
+	sleeping: boolean;
+	sleepTimer: number;
+	playerLocation: BlockPos$1 | null;
+	spawnChunk: BlockPos$1 | null;
+	spawnForced: boolean;
+	home: unknown | undefined;
+	xpCooldown: number;
+	profile: GameProfile;
+	kills: number;
+	deaths: number;
+	inventoryManager: unknown;
+	fireTick: number;
+	constructor(profile: Profile, world: World$1);
+	isAdmin(): boolean;
+	getItemInUse(): ItemStack$1;
+	getItemInUseCount(): number;
+	isUsingItem(): boolean;
+	getItemInUseDuration(): number;
+	stopUsingItem(): void;
+	clearItemInUse(): void;
+	isBlocking(): boolean;
+	getHorizontalDirection(): EnumFacing$1;
+	getEyeHeight(): number;
+	canPlayerEdit(_?: unknown, __?: unknown, ___?: unknown): boolean;
+	getActiveItemStack(): ItemStack$1;
+	getInventoryEnderChest(): InventoryEnderChest;
+	getEquipmentInSlot(h: unknown): unknown;
+	onDeath(attackingPlayer: EntityPlayer$1): void;
+	isSprinting(): boolean;
+	/** **IMPORTANT**: USE DUMPS */
+	attack(e: EntityLivingBase$1): void;
+	hasInferniumArmor(): boolean;
+	onCriticalHit(entity: EntityLivingBase$1): void;
+	getJumpMovementFactor(): number;
+	onPlayerUpdate(): void;
+	checkCollisionWithEntities(): void;
+	applyInput(input: SPacketPlayerInput, _unused?: boolean): void; // SPacketPlayerInput
+	addStat(h: unknown, p: unknown): void;
+	addMovementStat(h: unknown, p: unknown, g: unknown): void;
+	updateItemInUse(): void;
+	/**
+	 * gets the experience points of this entity
+	 * @param _unused unused, this is called with `attackingPlayer` by EntityLivingBase#onDeath
+	 */
+	getExperiencePoints(_unused?: EntityPlayer$1): number;
+	addExperience(xp: number): void;
+	setExperience(h: unknown, p: unknown): void;
+	xpBarCap(): number;
+	removeExperienceLevel(h: unknown): void;
+	addExperienceLevel(h: unknown): void;
+	update(): void;
+	setCurrentItemOrArmor(h: unknown, p: unknown): void;
+	preparePlayerToSpawn(): void;
+	setGamemode(gameMode: GameMode): boolean;
+	displayGUIChest(chest: BlockChest): void;
+	displayGui(h: IInterface): void;
+	openEditSign(sign: TileEntitySign): void;
+	closeScreen(): void;
+	openEditCommandBlock(h: CommandBlockLogic): void;
+	dropItemForPlayer(h: unknown, p?: boolean): unknown;
+	dropItem(h: unknown, p: unknown, g: unknown, y?: boolean): unknown;
+	joinEntityItemWithWorld(e: Entity$1): void; // Entity
+	canHarvestBlock(h: Block$1): boolean;
+	getToolDigEfficiency(h: unknown): unknown;
+	addExhaustion(h: unknown): void;
+	getFoodStats(): FoodStats;
+	canEat(h: unknown): boolean;
+	shouldHeal(): boolean;
+	setItemInUse(h: unknown, p: unknown): void;
+	isInBed(): boolean;
+	static getBedSpawnLocation(
+		h: unknown,
+		p: unknown,
+		g: unknown,
+	): Promise<Vector3$2>;
+	updateItemUse(h: unknown, p: unknown): void;
+	destroyCurrentEquippedItem(): void;
+	onItemUseFinish(): void;
+	handleStatusUpdate(h: unknown): void;
+	setAbsorptionAmount(h: unknown): void;
+	sendMessage(h: unknown, p: unknown): void;
+	isPlayerSleeping(): boolean;
+	isPlayerFullyAsleep(): boolean;
+	getSleepTimer(): number;
+	getBedLocation(): Vector3$2;
+	isSpawnForced(): boolean;
+	setSpawnPoint(h: unknown, p: unknown): void;
+	wakeUpPlayer(h: unknown, p: unknown, g: unknown): void;
+	trySleep(h: unknown): 0 | 4 | 3 | 2 | 5;
+	isSpectator(): boolean;
+	getCurrentEquippedItem(): ItemStack$1 | null;
+	interactFirst(h: unknown): boolean;
+	interactWith(h: unknown): boolean;
+	onTeamChanged(): void;
+}
+//#endregion
+//#region src/entities/EntityLivingBase.d.ts
+declare class EntityLivingBase$1 extends Entity$1 {
+	activePotionsMap: Map<number, PotionEffect>;
+	potionsNeedUpdate: boolean;
+	absorptionAmount: number;
+	health: number;
+	maxHealth: number;
+	attributeMap: AttributeMap;
+	hurtTime: number;
+	maxHurtTime: number;
+	deathTime: number;
+	revengeTimer: number;
+	lastDamage: number;
+	hurtResistantTime: number;
+	maxHurtResistantTime: number;
+	attackedAtYaw: number;
+	attackingPlayer: EntityPlayer$1 | null; // EntityPlayer
+	recentlyHit: number;
+	combatTracker: CombatTracker;
+	landMovementFactor: number;
+	jumpMovementFactor: number;
+	limbSwingAmount: number;
+	prevLimbSwingAmount: number;
+	limbSwing: number;
+	jumping: boolean;
+	constructor(world: World$1);
+	onKillCommand(): void;
+	applyEntityAttributes(): void;
+	getEntityAttribute(h: unknown): unknown;
+	getAttributeMap(): AttributeMap;
+	getCombatTracker(): unknown;
+	lastDamager(): unknown;
+	getHeldItem(): ItemStack$1 | null;
+	onEntityUpdate(): void;
+	isChild(): boolean;
+	isPlayer(): boolean;
+	onDeathUpdate(): void;
+	setOxygen(oxygen: number): void;
+	getOxygen(): number;
+	decreaseOxygenSupply(h: number): number;
+	canBreatheUnderwater(): boolean;
+	collideWithNearbyEntities(): void;
+	canBePushed(): boolean;
+	getAITarget(): unknown;
+	getRevengeTimer(): number;
+	setRevengeTarget(h: unknown): void;
+	getLastAttacker(): unknown;
+	getLastAttackerTime(): number;
+	setLastAttacker(h: unknown): void;
+	getAge(): number;
+	collideWithEntity(e: Entity$1): void;
+	setJumping(h: boolean): void;
+	jump(): void;
+	onItemPickup(h: unknown, p: unknown): void;
+	canEntityBeSeen(e: Entity$1): boolean;
+	isServerWorld(): boolean;
+	isMovementBlocked(): boolean;
+	updateEntityActionState(): void;
+	renderBrokenItemStack(h: unknown): void;
+	update(): void;
+	dismountEntity(_: unknown): void;
+	setPositionAndRotation2(
+		x: number,
+		y: number,
+		z: number,
+		yaw: number,
+		pitch: number,
+		S: unknown,
+	): void;
+	onLivingUpdate(): void;
+	moveEntityWithHeading(strafe: number, forward: number): void;
+	getAIMoveSpeed(): number;
+	setAIMoveSpeed(speed: number): void;
+	attackEntityAsMob(h: unknown): boolean;
+	getEquipmentInSlot(h: unknown): void;
+	getTotalArmorValue(): number;
+	damageArmor(h: unknown): void;
+	applyArmorCalculations(h: unknown, p: unknown): unknown;
+	applyPotionDamageCalculations(h: unknown, p: unknown): unknown;
+	damageEntity(h: Entity$1, p: unknown): void;
+	getAbsorptionAmount(): number;
+	setAbsorptionAmount(h: number): void;
+	knockback(
+		_unused_1: unknown,
+		_unused_2: unknown,
+		xM: number,
+		yM: number,
+	): void;
+	getCreatureAttribute(): EnumCreatureAttribute;
+	setBeenAttacked(): void;
+	hasInferniumArmor(): boolean;
+	getSoundPitch(): number;
+	getMaxHealth(): number;
+	getHealth(): number;
+	setHealth(health: number): void;
+	getFallSoundString(
+		h: unknown,
+	): "game.player.hurt.fall.big" | "game.player.hurt.fall.small";
+	getHurtSound(): string;
+	getDeathSound(): string;
+	addRandomDrop(): void;
+	dropFewItems(h: unknown, p: unknown): void;
+	canDropLoot(): boolean;
+	getInventory(): Inventory$1;
+	getSoundVolume(): number;
+	kill(): void;
+	handleStatusUpdate(h: unknown): void;
+	updatePotionEffects(): void;
+	updatePotionMetadata(): void;
+	resetPotionEffectMetadata(): void;
+	clearActivePotions(): void;
+	getActivePotionEffects(): PotionEffect[];
+	isPotionActive(pot: Potion): boolean; // Potion
+	getActivePotionEffect(h: unknown): unknown;
+	addPotionEffect(h: unknown): void;
+	isPotionApplicable(h: unknown): boolean;
+	isEntityUndead(): boolean;
+	removePotionEffectClient(h: unknown): void;
+	removePotionEffect(h: unknown): void;
+	onNewPotionEffect(h: unknown): void;
+	onChangedPotionEffect(h: unknown, p: unknown): void;
+	onFinishedPotionEffect(h: unknown): void;
+	heal(add: number): void;
+	getEyePositionVector(): Vector3$2;
+	sendEnterCombat(): void;
+	sendEndCombat(): void;
+}
+//#endregion
+//#region src/chat/Chat.d.ts
+declare interface ChatData {
+	text?: string;
+	id?: string;
+	color?: string;
+	discard?: boolean;
+	toast?: boolean;
+	timer?: number;
+}
+declare interface ChatLog extends ChatData {
+	/** @default Date.now() */
+	t: number;
+	/** @default 0 */
+	timer: number;
+}
+declare class Chat {
+	log: ChatLog[];
+	inputHistory: string[];
+	inputHistoryIndex: number;
+	autoCompleteRequested: boolean;
+	autoComplete: {
+		active: boolean;
+		index: number;
+		list: string[];
+	};
+	inputValue: string;
+	showInput: boolean;
+	isInputCommandMode: boolean;
+	setAutoCompleteDefault(): void;
+	/** `idk` is only passed to `ClientSideCommands.tryExecuteClientSide` */
+	submit(idk: unknown): void;
+	getHistory(direction: "up" | "down"): void;
+	setInputValue(value: string): void;
+	openInput(commandMode: boolean): void;
+	closeInput(): void;
+	filterUsernames(data: ChatData): ChatData;
+	addChat(data: ChatData): void;
+	clear(): void;
+	requestTabComplete(updateMoveBackwards: boolean): void;
+	autoCompleteReceived(packet: CPacketTabComplete$1): void;
+	updateInputWithAutoComplete(moveBackwards: boolean): void;
+	static trimLastWord(input: string): string;
+}
+//#endregion
+//#region src/world/rayTraceResult.d.ts
+declare enum TypeOfHit {
+	MISS = 0,
+	BLOCK = 1,
+	ENTITY = 2,
+}
+declare class RayTraceResult {
+	typeOfHit: TypeOfHit;
+	hitVec: Vector3 | null;
+	block: BlockPos | null;
+	side: EnumFacing | null;
+	entity: Entity | null;
+	constructor(
+		typeOfHit: TypeOfHit,
+		hitVec: Vector3 | null,
+		block: BlockPos | null,
+		side: EnumFacing | null,
+		entity: Entity | null,
+	);
+}
+//#endregion
+//#region src/controller/Controller.d.ts
+declare class PlayerControllerMP {
+	lastSentSlot: number;
+	isHittingBlock: boolean;
+	/** IMPORTANT: USE DUMPS */
+	syncItem(): void;
+	/** just returns {@link PlayerControllerMP.isHittingBlock isHittingBlock} */
+	func_181040_m(): this["isHittingBlock"];
+	sendEnchantPacket(windowId: string, button: number): void;
+	leftClick(): void;
+	rightClick(): void;
+}
+declare class PlayerController {
+	prevBlock?: Vector3$2;
+	lastBreakSoundPlay: number;
+	/** this being an object with only one entry is literally just a waste of RAM :sob: */
+	key: {
+		/** set to Date.now() on click in some places,
+		 * and then to `0` in {@link PlayerController#leftClick} if `release` is true
+		 */
+		leftClick: number;
+	};
+	rightClick: boolean;
+	objectMouseOver: RayTraceResult;
+	rightClickDelayTimer: number;
+	currBreakingLocation: BlockPos$1 | null;
+	reset(): void;
+	getBlockReachDistance(): 5 | 4.5;
+	/**
+	 * Called when you left click the mouse.
+	 * If `release` (`u`) is truthy, it will set {@link PlayerController.key}.leftClick to `0`
+	 */
+	leftClick(release?: boolean): void;
+	/**
+	 * Calls {@link PlayerController.pickBlock} if `Game.isActive()` OR if `assumeActive` is truthy.
+	 * @param assumeActive assume the game is active
+	 */
+	middleClick(assumeActive?: boolean): void;
+	rightClickMouse(): void;
+	onPlayerRightClick(
+		e: EntityPlayer$1,
+		world: World$1,
+		item: ItemStack$1,
+		pos: Vector3$2 | BlockPos$1,
+		placeSide: EnumFacing$1,
+		hitVec: Vector3$2,
+	): boolean; // TODO: item or item stack?
+	sendUseItem(
+		plr: EntityLivingBase$1,
+		world: World$1,
+		item: ItemStack$1,
+	): boolean;
+	/**
+	 * @param windowID the ID of the window to click in
+	 * @param slotID the slot to put the item in
+	 * @param button the mouse button that was clicked (i.e. 0 for left, 1 for right, and the slot number if using swap mode)
+	 * @param mode the click mode, it is recommended to use enum unless you need custom modes (i.e. for abusing bugs).
+	 * @param player
+	 */
+	windowClick(
+		windowID: number,
+		slotID: number,
+		button: number,
+		mode: SlotActionType | number,
+		player: EntityPlayer$1,
+	): ItemStack$1;
+	/** @param entity the entity that was using the item */
+	onStoppedUsingItem(entity: EntityPlayer$1): void;
+	select(): void;
+	punch(): boolean | undefined;
+	/**
+	 * - Syncs the item slot using {@link PlayerControllerMP.syncItem}
+	 * - Sends a {@link SPacketUseEntity} packet with `action` = `1`, `id` = `e.id`,
+	 * and the `hitVec` is from the objectMouseOver hitVec.
+	 * - calls {@link EntityPlayer.attack player.attack} on the entity.
+	 * @param e the entity to attack.
+	 */
+	attackEntity(e: Entity$1): void;
+	interactWithEntitySendPacket(
+		_unusedPlayer: unknown,
+		entity: Entity$1,
+	): boolean;
+	/**
+	 * Tries to find an item slot for the pick block function.
+	 * - It first tries to find a slot with an item that is equal to this stack.
+	 * - If none of the hotbar slots match, then it just finds an empty hotbar slot to put it in.
+	 * - If none are empty, it returns the current item slot.
+	 */
+	findHotbarSlotForPickBlock(stack: PBItemStack): number;
+	getTargetedBlockCoords(): BlockPos$1;
+	getTargetedBlockState(): BlockState$1;
+	getScreenLookVector(): Vector3$2;
+	updateMouseOver(): void;
+	pickBlock(): void;
+	/**
+	 * Mines the block selected from {@link PlayerController.objectMouseOver objectMouseOver} if LMB is down.
+	 * @param instantMine if the block selected should be instantly mined.
+	 */
+	mine(instantMine?: boolean): void;
+	/**
+	 * Drops the item in hand if:
+	 * - The {@link EntityPlayer.getHealth player's health} is > 0
+	 * - An {@link EntityPlayer.getActiveItemStack item} is selected (not falsy)
+	 * - And the {@link EntityPlayer.getActiveItemStack item} {@link ItemStack.stackSize stack size} is `> 0`
+	 *   (not `<= 0`)
+	 *
+	 * Then, it drops the item by sending a `SPacketPlayerAction` packet with
+	 * `action` = `all ? PBAction.DROP_ALL_ITEMS else PBAction.DROP_ITEM`,
+	 * `facing` = `EnumFacing.DOWN`, and then `position` = `BlockPos.ORIGIN.toProto()`
+	 * @param [all=false] drop the entire stack?
+	 */
+	dropItem(all: boolean = false): void;
+	/**
+	 * Updates the right click delay timer.
+	 */
+	update(): void;
+	/**
+	 * - Updates {@link PlayerController.objectMouseOver objectMouseOver}
+	 * - {@link PlayerController.select Updates the selection box}
+	 * - {@link PlayerController.mine Mines} a block if selected and the left mouse button is down
+	 */
+	render(): void;
+}
+//#endregion
+//#region src/network/serverInfo.d.ts
+declare class ServerInfo {
+	serverId: string;
+	serverVersion: string;
+	serverName: string;
+	serverCategory: string;
+	worldType: string;
+	/** @default PermissionLevel.NONE */
+	permissionLevel: PermissionLevel;
+	/** @default AccessControl.NONE */
+	accessControl: AccessControl;
+	/** @default Cheats.DISABLED */
+	cheats: Cheats;
+	/** @default null */
+	inviteCode: string | null;
+	/** @default false */
+	pvpEnabled: boolean;
+	/** @default true */
+	commandBlocksEnabled: boolean;
+	/** @default true */
+	doDaylightCycle: boolean;
+	startTime: number;
+	/** @default [] */
+	playerPermissionEntries: PlayerPermissionEntry[];
+	/** @default {} */
+	metadata: object;
+	handlePacket(pkt: CPacketServerInfo$1): void;
+	handleMetadataUpdate(u: CPacketServerMetadata$1): void;
+}
+//#endregion
+//#region src/game/gameScene.d.ts
+declare class GameScene$1 {
+	game: Game;
+	readonly camera = new PerspectiveCamera(
+		85,
+		window.innerWidth / window.innerHeight,
+		0.01,
+		1e7,
+	);
+	readonly scene = new Scene();
+	readonly axesHelper = new AxesHelper(0.01);
+	readonly entityMeshes = new Group();
+	readonly chunkMeshes = new Group();
+	readonly ambientMeshes = new Group();
+	readonly leaderboardMeshes = new Group();
+	readonly sun = new Sun(this);
+	readonly stars = new Stars(this, this.sun);
+	readonly sky = new Sky(this, this.sun);
+	readonly fog = new Fog(this);
+	readonly clouds = new Clouds(this);
+	tileEntityRenderer: TileEntityRenderer;
+	effectRenderer: EffectRenderer;
+	constructor(game: Game);
+	updateCameraZoom(): void;
+	update(): void;
+	clear(): void;
+}
+//#endregion
+//#region src/game/game.d.ts
+declare enum GameState {
+	TITLE_SCREEN = 0,
+	CONNECTING = 1,
+	CONNECTING_ATTEMPT = 2,
+	CONNECTION_ERROR = 3,
+	AUTHENTICATING = 4,
+	LOADING_CHUNKS = 5,
+	PLAY = 6,
+}
+interface GameInfo {
+	selectedSlot: number;
+	showSignEditor: Vector3$2 | null;
+	showDeathScreen?: boolean;
+}
+declare class ResourceMonitor {
+	instantFPS: number;
+	filteredFPS: number;
+	/** note: this is always 0 */
+	instantPing: number;
+	filteredPing: number;
+	static fpsGraphUpdate: unknown | null;
+	static memoryGraphUpdate: unknown | null;
+	static tickTimeGraphUpdate: unknown | null;
+}
+declare class Game {
+	player: ClientEntityPlayer;
+	controller: PlayerController;
+	gameScene: GameScene$1;
+	world: ClientWorld;
+	playerList: PlayerList;
+	unleash;
+	cubicBezier: CubicBezier;
+	chunkRenderManager: ChunkRenderManager;
+	chunkManager: ClientChunkManager;
+	prevTime: number;
+	lastFixedUpdate: number;
+	renderLoopErrored: boolean;
+	chat: Chat;
+	resourceMonitor: ResourceMonitor;
+	info: GameInfo;
+	adIntervalId: number | null;
+	connectionAttempts: number;
+	_state: GameState;
+	party: PartyClient;
+	scoreboardLines: string[];
+	scoreboardTitle: string;
+	delta: number;
+	serverInfo: ServerInfo;
+	constructor();
+	static get isCrazyGames(): boolean;
+	static get isDiscordActivity(): boolean;
+	static get isPoki(): boolean;
+	get state(): this["_state"];
+	set state(value: GameState);
+	inGame(): boolean;
+	gameLoopStarted(): boolean;
+	/**
+	 * @param f1 does being in f1 mode count as activity?
+	 */
+	static isActive(f1?: boolean): boolean;
+	static isChatting(): Game["chat"]["showInput"];
+	static hasMenuOpen(): boolean;
+	init(): Promise<void>;
+	fixedUpdateTS(): void;
+	update(): void;
+	fixedUpdate(): void;
+	requestQueue(): void;
+	/**
+	 * Queues for a mini game.
+	 * @param miniGameID the ID of the mini game to queue
+	 * @param mgConfig the config of the mini game
+	 */
+	queue(miniGameID: string, mgConfig: object): Promise<void>;
+	connectWithCode(code: string): void;
+	tryUpdateClient(serverID: string): void;
+	connect(
+		idOrCustomURL: string,
+		useCustomURL?: boolean,
+		noAd?: boolean,
+	): Promise<void>;
+	disconnect(reason: string): void;
+	onSocketDisconnect(reason: string | null): void;
+	static isFullscreen(): boolean;
+	static enterFullscreen(): void;
+	unfocus(): void;
+	resume(): void;
+	pause(): void;
+	loadPlanet(
+		id: number,
+		accessControl: string,
+		callback: (justStarted: boolean) => void,
+	): void;
+}
+//#endregion
+//#region src/game/hud.d.ts
+interface AnimationKeyframe {
+	duration: number;
+	position: Vector3;
+	rotation: Quaternion;
+}
+declare class AnimationLerp {
+	private totalDuration;
+	private keyframes;
+	private target;
+	private cumulativeTimes;
+	constructor(keyframes: AnimationKeyframe[], target: Object3D);
+	update(deltaTime: number): void;
+}
+declare class Hud3D extends Group {
+	item: Group;
+	fireGroup: Group;
+	suffocationGroup: Mesh$1;
+	lastSuffocationBlock: Block$1 | null;
+	mesh: Mesh$1;
+	tesr: Mesh$1;
+	rightArm: Mesh$1;
+	leftArm: Mesh$1;
+	lastPunch: number;
+	rightArmPunch: AnimationLerp;
+	itemPunch: AnimationLerp;
+	eat: AnimationLerp;
+	sword: AnimationLerp;
+	swordVariation: number;
+	shovel: AnimationLerp;
+	axe: AnimationLerp;
+	cancelAnimation: boolean;
+	currentActiveItem: ItemStack | null;
+	prevCharge: number;
+	swingLength: {
+		value: number;
+	};
+	constructor();
+	getSpriteMesh(spriteName: string): Mesh$1;
+	/**
+	 * @param name the name of the sprite (i.e. `fire_0`)
+	 * @param mesh the mesh
+	 * @param [idx=0] index. `Math.floor(Date.now() / 25 % 32)` for the fire animation
+	 */
+	updateSpriteUV(name: string, mesh: Mesh$1, idx?: number): void;
+	initFireMesh(): void;
+	initSuffocationMesh(): void;
+	updateFireGraphics(): void;
+	updateSuffocationGraphics(): void;
+	swingArm(): void;
+	updateArmAnimation(): void;
+	/** it's only `true` when `ClientEntityPlayer`#`init` is called. otherwise it's not passed. */
+	update(clientEntityPlayerInit?: boolean): void;
+}
+declare class Font {
+	isFont: true;
+	type: "Font";
+	constructor(public data: unknown);
+	generateShapes(u, h = 100): unknown[];
+}
+declare class FontLoader extends Loader<Font> {
+	load(
+		url: string,
+		callback: (font: Font) => void,
+		onProgress: (event: ProgressEvent<EventTarget>) => void,
+		onError: (err: unknown) => void,
+	): void;
+	parse(data): Font;
+}
+declare class TextureManager {
+	loadTextures(): Promise<void>;
+	loadSpritesheet(): Promise<void>;
+	loader: TextureLoader;
+	fontLoader: FontLoader;
+	miniblox_font: Font;
+	old_miniblox_font: Font;
+	atlas;
+	materialWorld;
+	materialTransparentWorld;
+	material;
+	materialEnchanted;
+	materialTransparent;
+	entityMaterials: object;
+	entityUVSize: object;
+	spritesheetPixels;
+	particles: object;
+	glintTexture: Texture;
+	skinManager: SkinManager;
+	/** **IMPORTANT**: USE DUMPS */
+	gltfManager: GLTFManager;
+}
+//#endregion
+//#region src/game/options.d.ts
+// Options and settings extracted from Impact
+// biome-ignore lint/complexity/noStaticOnlyClass: they're typings :sob:
+declare class Options {
+	static streamerMode: {
+		value: boolean;
+	};
+	static renderDistance: {
+		value: number;
+	};
+	static fov: {
+		value: number;
+	};
+	static sensitivity: {
+		value: number;
+	};
+	static invertMouse: {
+		value: boolean;
+	};
+	static showFPS: {
+		value: boolean;
+	};
+	static showCoordinates: {
+		value: boolean;
+	};
+	static showBiome: {
+		value: boolean;
+	};
+	static showPing: {
+		value: boolean;
+	};
+	static showServerIP: {
+		value: boolean;
+	};
+	static chatScale: {
+		value: number;
+	};
+	static chatOpacity: {
+		value: number;
+	};
+	static chatWidth: {
+		value: number;
+	};
+	static chatHeightFocused: {
+		value: number;
+	};
+	static chatHeightUnfocused: {
+		value: number;
+	};
+	static mipmapLevels: {
+		value: number;
+	};
+	static anisotropicFiltering: {
+		value: number;
+	};
+	static viewBobbing: {
+		value: boolean;
+	};
+	static guiScale: {
+		value: number;
+	};
+	static attackIndicator: {
+		value: number;
+	};
+	static enableVsync: {
+		value: boolean;
+	};
+	static entityShadows: {
+		value: boolean;
+	};
+	static mainHand: {
+		value: string;
+	};
+	static autoJump: {
+		value: boolean;
+	};
+	static reset(): void;
+	static resetVideo(): void;
+	static resetControls(): void;
+}
+declare const Options$1: typeof Options;
+//#endregion
+//#region src/player/PlayerMovement.d.ts
+declare class PlayerMovement extends EntityPlayer$1 {
+	flyToggleTimer: number;
+	sprintToggleTimer: number;
+	sprintingTicksLeft: number;
+	currentInput: SPacketPlayerInput | null; // SPacketPlayerInput
+	inputSequenceNumber: number;
+	pendingInputs: SPacketPlayerInput[]; // SPacketPlayerInput[]
+	serverDistance: number;
+	/** **IMPORTANT**: USE DUMPS */
+	moveStrafe: number;
+	/** **IMPORTANT**: USE DUMPS */
+	moveForward: number;
+	jumping: boolean;
+	constructor();
+	reset(): void;
+	updatePlayerMoveState(): void;
+	reconcileServerPosition(packet: CPacketPlayerReconciliation$1): void; // CPacketPlayerReconciliation
+	checkHeadInBlock(): void;
+	getFovModifier(): number;
+	fixedUpdate(): void;
+}
+//#endregion
+//#region src/player/ClientEntityPlayer.d.ts
+declare enum Perspective {
+	FIRST_PERSON,
+	THIRD_PERSON,
+	THIRD_PERSON_FRONT,
+}
+declare class ClientEntityPlayer extends PlayerMovement {
+	perspective: Perspective;
+	deltaFov: number;
+	selectBox: Box3Helper;
+	headInBlock: Block$1 | null;
+	lastHeadInBlock: Block$1 | null;
+	biome: string;
+	lastReportedPos: Vector3$2;
+	/** **IMPORTANT**: USE DUMPS */
+	lastReportedYaw: number;
+	lastReportedPitch: number;
+	serverSneakState: boolean;
+	serverSprintState: boolean;
+	serverPunchState: boolean;
+	serverBlockState: boolean;
+	serverFlyState: boolean;
+	serverMoveStrafe: number;
+	serverMoveForward: number;
+	lastItemUseTime: number;
+	showDeathScreen: boolean;
+	currentTile: BlockPos$1; //? is it a BlockPos
+	prevInventory: Inventory$1;
+	prevDefencePoints: number;
+	game: Game;
+	positionUpdateTicks: number;
+	lastjump: number;
+	constructor();
+	init(socketId: string, p: Profile): void;
+	checkInventoryChange(h?: boolean): void;
+	resetPositionToBB(h?: boolean): void;
+	addSelectBox(): void;
+	respawn(packet?: CPacketRespawn$1): void;
+	sendRespawnPacket(): void;
+	renderCameraFOV(): void;
+	renderCamera(dt: number): void;
+	toggleCameraPerspective(): void;
+	updatePlayerMesh(): void;
+	sendPositionAndRotation(): void;
+	sendActions(): void;
+	sendAbilities(): void;
+	onUpdateWalkingPlayer(): void;
+	getMoveDirection(h: number): Vector3$2;
+	updateClient(dt: number): void;
+	updateSoundOrientation(): void;
+	resetInventory(): void;
+	onEnchantmentCritical(e: Entity$1): void; // Entity
+	setXPStats(xp: number, total: number, level: number): void;
+	openShop(): void;
+	getClientModel(): CommandBlockLogic;
+}
+//#endregion
+//#region src/player/ClientEntityPlayerOther.d.ts
+declare class ClientEntityPlayerOther extends EntityPlayer$1 {
+	otherPlayerMPPosRotationIncrements: number;
+	otherPlayerPos: Vector3$2;
+	otherPlayerYaw: number;
+	otherPlayerPitch: number;
+	isItemInUse: boolean;
+}
+//#endregion
+//#region src/world/blockpos.d.ts
+declare class BlockPos$1 {
+	toProto(): PBBlockPos;
+	static readonly ORIGIN: BlockPos$1;
+	x: number;
+	y: number;
+	z: number;
+	constructor(x: number, y: number, z: number);
+	getX(): number;
+	getY(): number;
+	getZ(): number;
+	static fromVector(vec: Vector3$2): BlockPos$1;
+	static fromJSON(json: { x: number; y: number; z: number }): BlockPos$1;
+	static fromProto(proto: PBBlockPos): BlockPos$1;
+	static fromString(str: string): BlockPos$1;
+	toVec3(): Vector3$2;
+	toArray(): [this["x"], this["y"], this["z"]];
+	static fromArray(u: [number, number, number]): BlockPos$1;
+	static fromEntity(u: Entity$1): BlockPos$1;
+	toAABB(): Box3$1;
+	set(x: number, y: number, z: number): void;
+	add(x: number, y: number, z: number): BlockPos$1;
+	subtract(x: number, y: number, z: number): BlockPos$1; // Utility methods for block iteration
+	static getAllInBoxMutable(min: BlockPos$1, max: BlockPos$1): BlockPos$1[];
+	up(n: number = 1): BlockPos$1;
+	down(n: number = 1): BlockPos$1;
+	north(n: number = 1): BlockPos$1;
+	south(n: number = 1): BlockPos$1;
+	west(n: number = 1): BlockPos$1;
+	east(n: number = 1): BlockPos$1;
+	offset(facing: EnumFacing$1, n: number = 1): BlockPos$1;
+}
+//#endregion
+//#region src/world/chunk.d.ts
+declare class Chunk {
+	xPosition: number;
+	zPosition: number;
+	isChunkLoaded: boolean;
+	isDummyChunk: boolean;
+	cells: Cell[];
+	blockBiomeArray: number[];
+	/** can't find any uses of this, assuming a boolean. */
+	updateSkylightColumns: boolean;
+	/**
+	 * index with `z << 4 | x` (z is the Z position and X is the x position)
+	 */
+	heightMap: number[];
+	chunkTileEntityMap: BlockPosMap;
+	entityLists: Entity[][];
+	isModified: boolean;
+	heightMapMinimum: number;
+	hasEntities: boolean;
+	lastSaveTime: number;
+	culled: boolean;
+	culledCells: Cell[];
+	world: World;
+	constructor(world: World, xPosition: number, zPosition: number);
+	getHeight(pos: BlockPos): number;
+	getHeightValue(x: number, z: number): number;
+	getTopFilledSegment(): number;
+	generateHeightMap(): void;
+	getBlock(x: number, y: number, z: number): Block$1;
+	getBlockState(pos: BlockPos): BlockState;
+	setBlockState(pos: BlockPos, blockStateId: number): boolean;
+	setChunkModified(): void;
+	createNewTileEntity(pos: BlockPos): TileEntity;
+	addTileEntity(tileEntity: TileEntity): void;
+	removeTileEntity(tileEntity: TileEntity): void;
+	getTileEntity(tileEntity: TileEntity, bl?: boolean): TileEntity;
+	onChunkLoad(): void;
+	onChunkUnload(): void;
+	getEntitiesWithinAABBForEntity(
+		excludedID: number | null,
+		box: Box3,
+		arr: Entity[],
+		idk: null,
+	): void;
+	getEntitiesOfTypeWithinAABB(
+		eType: string | null,
+		box: Box3,
+		arr: Entity[],
+	): void;
+	isEmpty(): boolean;
+	getHeightMap(): number[];
+	setHeightMap(heightMap: number[]): void;
+	getTileEntityMap(): this["chunkTileEntityMap"];
+	getEntityLists(): this["entityLists"];
+	setHasEntities(hasEntities: boolean): void;
+	setLastSaveTime(lastSaveTime: number): void;
+	addEntity(box: Box3): void;
+	removeEntity(entity: Entity): void;
+	removeEntityAtIndex(entity: Entity, idx: number): void;
+	canSeeSky(fromPos: BlockPos): boolean;
+	updateCulledState(pos: BlockPos): void;
+	cullChunk(): Promise<void>;
+	toProto(dimension: number): Promise<CPacketChunkData>;
+	static fromProto(world: World, packet: CPacketChunkData): Chunk;
+	/** @param cellX gets used in for (let i = cellX; i < y; i += 16) and then this.cells gets indexed by i >> 4 inside of it */
+	getAreLevelsEmpty(cellX: number, y: number): boolean;
+}
+declare class EmptyChunk$1 extends Chunk {
+	isDummyChunk: boolean;
+	constructor(world: World, x: number, z: number);
+	getHeightValue(_x: number, _z: number): number;
+	setBlockState(_x: number, _z: number): boolean;
+	getBlock(x: number, y: number, z: number): Block$1;
+	addEntity(entity: Entity): void;
+	removeEntity(entity: Entity): void;
+	removeEntityAtIndex(entity: Entity, idx: number): void;
+	canSeeSky(pos: BlockPos): boolean;
+	addTileEntity(tileEntity: TileEntity): void;
+	removeTileEntity(tileEntity: TileEntity): void;
+	onChunkLoad(): void;
+	onChunkUnload(): void;
+	getEntitiesWithinAABBForEntity(
+		excludedID: number | null,
+		box: Box3,
+		arr: Entity[],
+		idk: null,
+	): void;
+	isEmpty(): boolean;
+}
+//#endregion
+//#region src/world/chunkProvider.d.ts
+/** copied from https://github.com/Marcelektro/MCP-919/blob/main/src/minecraft/net/minecraft/world/chunk/IChunkProvider.java */
+interface IChunkProvider {
+	/**
+	 * Will return back a chunk, if it doesn't exist and it's not a MP client it will generates all the blocks for the
+	 * specified chunk from the map seed and chunk seed
+	 */
+	provideChunk(x: number, z: number): Chunk;
+	saveChunks(): Promise<void>;
+	/** returns null on client */
+	getPossibleCreatures(
+		creatureType: EnumCreatureType,
+		pos: BlockPos$1,
+	): SpawnListEntry[] | null;
+	getLoadedChunkCount(): number;
+	unloadChunk(x: number, z: number): void;
+	unloadAllChunks(): void;
+}
+declare class ChunkProviderClient$1 implements IChunkProvider {
+	posToChunk: ChunkPosMap;
+	dummyChunk: EmptyChunk;
+	world: World;
+	constructor(world: World);
+	isLoaded(x: number, z: number): boolean;
+	getLoadedChunkCount(): number;
+	getLoadedChunkSet(): ChunkPosSet;
+	loadChunk(x: number, z: number, packet: CPacketChunkData): Promise<Chunk>;
+	unloadChunk(x: number, z: number): void;
+	unloadAllChunks(): void;
+	provideChunk(x: number, z: number): Chunk;
+	saveChunks(): Promise<void>;
+	getPossibleCreatures(_a: unknown, _b: unknown): null;
+}
+//#endregion
+//#region src/world/explosion.d.ts
+declare class Explosion$1 {
+	isFlaming: boolean;
+	isSmoking: boolean;
+	/** not used anywhere, I assume it's left over from minecraft code. */
+	explosionRNG: undefined;
+	worldObj: World;
+	explosionX: number;
+	explosionY: number;
+	explosionZ: number;
+	exploder: Entity;
+	explosionSize: number;
+	affectedBlockPositions: BlockPos[];
+	playerKnockbackMap: Map<Entity, Vector3$2>;
+	constructor(
+		world: World,
+		exploder: Entity,
+		x: number,
+		y: number,
+		z: number,
+		explosionSize: number,
+		flaming: boolean,
+		smoking: boolean,
+		affectedBlockPositions?: BlockPos[],
+	);
+	doExplosionA(): void;
+	doExplosionB(bl: boolean): void;
+	getPlayerKnockbackMap(): Map<Entity, Vector3$2>;
+	getExplosivePlacedBy(): Entity | null;
+	/**
+	 * Clears `affectedBlockPositions` by setting its length field to `0`.
+	 * Prime example #67 of Miniblox being skidded from MCP
+	 */
+	func_180342_d(): void;
+	getAffectedBlockPositions(): BlockPos[];
+}
+//#endregion
+//#region src/world/materials.d.ts
+// Material types for blocks
+declare class Material {
+	readonly air: boolean;
+	isSolid(): boolean;
+	isLiquid(): boolean;
+	blocksMovement(): boolean;
+	getCanBurn(): boolean;
+	isReplaceable(): boolean;
+	isOpaque(): boolean;
+	isToolNotRequired(): boolean;
+	getMobilityFlag(): number;
+}
+// Global Materials registry
+declare const Materials: {
+	readonly air: Material;
+	readonly grass: Material;
+	readonly ground: Material;
+	readonly wood: Material;
+	readonly rock: Material;
+	readonly iron: Material;
+	readonly anvil: Material;
+	readonly water: Material;
+	readonly lava: Material;
+	readonly leaves: Material;
+	readonly plants: Material;
+	readonly vine: Material;
+	readonly sponge: Material;
+	readonly cloth: Material;
+	readonly fire: Material;
+	readonly sand: Material;
+	readonly circuits: Material;
+	readonly carpet: Material;
+	readonly glass: Material;
+	readonly redstoneLight: Material;
+	readonly tnt: Material;
+	readonly coral: Material;
+	readonly ice: Material;
+	readonly packedIce: Material;
+	readonly snow: Material;
+	readonly craftedSnow: Material;
+	readonly cactus: Material;
+	readonly clay: Material;
+	readonly gourd: Material;
+	readonly dragonEgg: Material;
+	readonly portal: Material;
+	readonly cake: Material;
+	readonly web: Material;
+	readonly piston: Material;
+	readonly barrier: Material;
+	readonly structureVoid: Material;
+};
+//#endregion
+//#region src/world/world.d.ts
+declare class BlockState$1 {
+	getBlock(): Block$1;
+	getMaterial(): Material;
+}
+declare class World$1 {
+	static mutableblockpos: BlockPos$1;
+	static pos1: BlockPos$1;
+	static pos2: BlockPos$1;
+	players: Map<number, EntityPlayer$1>;
+	totalTime: number;
+	worldTime: number;
+	tick: number;
+	serverInterface: ServerInterface;
+	loadedEntityList: Entity$1[];
+	unloadedEntityList: Map<number, Entity$1>;
+	loadedTileEntitiesMap: BlockPosMap;
+	tileEntitiesToBeRemoved: unknown[];
+	chunkProvider: IChunkProvider;
+	ambientTickCountdown: number;
+	scheduledUpdatesAreImmediate: boolean;
+	leaderboards: Map<string, CPacketLeaderboard$1>;
+	enchantmentHelper: EnchantmentHelper;
+	difficulty: EnumDifficulty;
+	/** absolutely references this, it only gets initialized. probably some thing for the server? */
+	simulationChunkSet: Set<unknown>;
+	teamMap: Map<string, Team>;
+	/** IMPORTANT: USE DUMPS */
+	entities: Map<number, Entity$1>;
+	dimensionId: number;
+	constructor(dimension: number);
+	get isClient(): boolean;
+	get isServer(): boolean;
+	getActualHeight(): 256 | 128;
+	getVisibleChunks(): void;
+	getVisibleChunkCount(): void;
+	getTeams(): Team[];
+	addTeam(name: string, displayName: string): void;
+	removeTeam(id: string): void;
+	emptyTeam(id: string): void;
+	joinTeam(id: string, ...members: EntityPlayer$1[]): void;
+	leaveTeam(id: string, ...members: EntityPlayer$1[]): void;
+	modifyTeam(id: string, which: string, value: string): void;
+	getMobLimit(): number;
+	getActiveChunkCount(): number;
+	getActiveChunks(): void;
+	updateAllPlayersSleepingFlag(): void;
+	isBlockLoaded(bp: BlockPos$1, idk?: boolean): boolean;
+	isChunkLoaded(x: number, z: number, idk: boolean): boolean;
+	isAreaLoaded(start: Vector3$2, end: Vector3$2, p?: boolean): boolean;
+	extendedLevelsInChunkCache(): boolean;
+	isAreaLoadedCoord(
+		sX: number,
+		sY: number,
+		sZ: number,
+		eX: number,
+		eY: number,
+		eZ: number,
+		clB: boolean,
+	): boolean;
+	getChunk(pos: BlockPos$1): Chunk;
+	getChunkByID(x: number, z: number): Chunk;
+	getBlock(pos: BlockPos$1): Block$1;
+	getBlockState(pos: BlockPos$1): BlockState$1;
+	setAir(pos: BlockPos$1, h?: number): void;
+	setAirXYZ(x: number, y: number, z: number): void;
+	isAir(pos: BlockPos$1): boolean;
+	areaPassesCheck(
+		min: BlockPos$1,
+		max: BlockPos$1,
+		checkFn: (b: Block$1) => boolean,
+	): boolean;
+	setBlockState(pos: BlockPos$1, state: BlockState$1, p?: number): boolean;
+	setBlockRaw(pos: BlockPos$1, state: BlockState$1): void;
+	notifyBlockOfStateChange(pos: ChunkPos, idk: unknown): void;
+	notifyNeighborsOfStateChange(pos: ChunkPos, idk: unknown): void;
+	notifyNeighborsOfStateExcept(
+		u: ChunkPos,
+		idk: unknown,
+		facing: EnumFacing,
+	): void;
+	playSoundAtEntity(
+		entity: Entity$1,
+		name: string,
+		volume?: number,
+		pitch?: number,
+	): void;
+	playSoundAtPosition(
+		pos: BlockPos$1,
+		volume: number | undefined,
+		pitch: number | undefined,
+		name: string,
+	): void;
+	playSound(pos: BlockPos$1, volume?: number, pitch?: number): void;
+	playSoundAtPositionClientSidePredicted(
+		name: string,
+		vol: number | undefined,
+		pitch: number | undefined,
+		pos: BlockPos$1,
+		plr: EntityPlayer$1,
+	): void;
+	playPlaceSoundAtPositionClientSidePredicted(
+		block: Block$1,
+		pos: Vector3$2,
+		plr: EntityPlayer$1,
+	): void;
+	spawnEntityInWorld(e: Entity$1): boolean;
+	setEntityState(_a: unknown, _b: unknown): void;
+	getEntityTracker(): void;
+	loadEntities(entities: Entity$1[]): void;
+	onEntityAdded(entity: Entity$1): void;
+	markChunkDirty(pos: BlockPos$1): void;
+	addItem(_a: unknown, _b: unknown): null;
+	getEntityItem(u: Item, pos: Vector3$2, yOffset: number): EntityItem;
+	getServer(): void;
+	getConfigurationManager(): void;
+	resetUpdateEntityTick(): void;
+	getTopSolidOrLiquidBlock(pos: BlockPos$1): BlockPos$1;
+	canBlockBePlaced(
+		block: Block$1,
+		pos: BlockPos$1,
+		bl: boolean,
+		_unused: unknown,
+	): boolean;
+	checkNoEntityCollision(box: Box3, _unused: unknown): boolean;
+	emitToAllNearExcept(
+		_a: unknown,
+		_b: unknown,
+		_c: unknown,
+		_d: unknown,
+		_e: unknown,
+		_f: unknown,
+		_g: unknown,
+	): void;
+	playSoundToNearExcept(
+		player: EntityPlayer$1,
+		pos: BlockPos$1,
+		vol: number,
+		pitch: number,
+		name: string,
+	): void;
+	getCollidingBoundingBoxes(entity: Entity$1, box: Box3): Box3[];
+	isAnyLiquid(box: Box3): boolean;
+	isFlammableWithin(box: Box3): boolean;
+	handleMaterialAcceleration(box: Box3, _a: unknown, e: Entity$1): boolean;
+	getEntitiesWithinAABBExcludingEntity(
+		excludedID: number,
+		box: Box3,
+	): Entity$1[];
+	getEntitiesInAABBexcluding(
+		excludedID: number | null,
+		box: Box3,
+		idk?: null,
+	): Entity$1[];
+	getDifficulty(): EnumDifficulty;
+	setDifficulty(difficulty: EnumDifficulty): void;
+	updatePlayerInventory(_a: unknown): void;
+	onEntityRemoved(e: Entity$1): void;
+	removeEntity(e: Entity$1): void;
+	updateEntities(): void;
+	isValid(v: Vector3$2): boolean;
+	getTileEntity(pos: BlockPos$1): TileEntity | null;
+	addTileEntity(u: TileEntity): void;
+	addTileEntities(entities: TileEntity[]): void;
+	removeTileEntity(pos: BlockPos$1): void;
+	markTileEntityForRemoval(tileEntity: TileEntity): void;
+	unloadEntities(entities: Entity$1[]): void;
+	addBlockEvent(
+		pos: BlockPos$1,
+		idk: unknown,
+		idk2: unknown,
+		idk3: unknown,
+	): void;
+	reconcileBlock(_a: unknown, _b: unknown): void;
+	forceBlockUpdateTick(block: Block$1, pos: BlockPos$1): void;
+	getRenderDistanceChunks(): void;
+	setActivePlayerChunksAndCheckLight(): void;
+	static doesBlockHaveSolidTopSurface(world: World$1, pos: BlockPos$1): boolean;
+	isBlockNormalCube(pos: BlockPos$1, idk: boolean): boolean;
+	getLightBrightness(_a: unknown): 15 | -15;
+	isBlockIndirectlyGettingPowered(facing: EnumFacing): number;
+	isSidePowered(pos: BlockPos$1, idk: unknown): boolean;
+	getRedstonePower(pos: BlockPos$1, idk: unknown): number;
+	getStrongPowerWithDirection(pos: BlockPos$1, dir: EnumFacing): number;
+	isBlockPowered(u: BlockPos$1): boolean;
+	getStrongPower(pos: BlockPos$1, bl?: boolean): number;
+	scheduleUpdate(_a: unknown, _b: unknown, _c: unknown): void;
+	updateBlockTick(_a: unknown, _b: unknown, _c: unknown, _d: unknown): void;
+	getEntitiesWithinAABB(
+		eType: string | null,
+		box: Box3,
+		_?: unknown,
+	): Entity$1[];
+	findNearestEntityWithinAABB(
+		eType: string,
+		box: Box3,
+		from_: Entity$1,
+	): Entity$1 | null;
+	isBlockTickPending(_a: unknown, _b: unknown): boolean;
+	updateComparatorOutputLevel(pos: BlockPos$1, idk: unknown): void;
+	spawnParticle(
+		particleType: EnumParticleTypes,
+		xO: number,
+		yO: number,
+		zO: number,
+		idk1: unknown,
+		idk2: unknown,
+		idk3: unknown,
+		...v: unknown[]
+	): void;
+	getClosestPlayerToEntity(
+		entity: Entity$1,
+		max: number,
+	): EntityPlayer$1 | null;
+	getClosestPlayer(
+		x: number,
+		y: number,
+		z: number,
+		max: number,
+	): EntityPlayer$1 | null;
+	isAnyPlayerWithinRangeAt(
+		x: number,
+		y: number,
+		z: number,
+		maxDist: number,
+	): boolean;
+	getSpawnPoint(): BlockPos$1;
+	countEntities(creatureClass: unknown): number;
+	getChunkProvider(): ChunkProvider;
+	getSpawnListEntryForTypeAt(idk: unknown, idk2: unknown): unknown;
+	/**
+	 * @param idk1 passed to chunkProvider.getPossibleCreatures
+	 * @param idk if (creature.entityClass == idk.entityClass)
+	 */
+	canCreatureTypeSpawnHere(
+		idk1: unknown,
+		idk: {
+			entityClass: unknown;
+		},
+		idk2: unknown,
+	): boolean;
+	playersIterator(): MapIterator<EntityPlayer$1>;
+	getPlayerCount(): number;
+	getPlayerById(id: number): EntityPlayer$1;
+	getAllPlayerNames(): string[];
+	getEntityCount(): number;
+	getLivingEntityCount(): number;
+	getLiveBlock(pos: BlockPos$1): LiveBlock;
+	sendMessageToAllPlayers(_a: unknown, _b: unknown): void;
+	sendAnnouncementToAllPlayers(..._a: unknown[]): void;
+	getBlockDensity(idk: unknown, box: Box3): number;
+	createExplosion(
+		entity: Entity$1,
+		x: number,
+		y: number,
+		z: number,
+		explosionSize: number,
+		smoking: boolean,
+	): Explosion;
+	newExplosion(
+		exploder: Entity$1,
+		x: number,
+		y: number,
+		z: number,
+		explosionSize: number,
+		flaming: boolean,
+		smoking: boolean,
+	): Explosion;
+	isAABBInMaterial(box: Box3, material: Material): boolean;
+	updateEntity(entity: Entity$1, h?: boolean): void;
+	handleEvent(_a: unknown): void;
+	isDaytime(): boolean;
+	canSeeSky(pos: BlockPos$1): boolean;
+	ensureSpawnPoint(): void;
+	checkBlockCollision(box: Box3): boolean;
+	isSpawnChunk(x: number, y: number): boolean;
+	getLightFromNeighbors(_a: unknown): number;
+	getCommandRegistry(): null;
+	getMobGriefing(): boolean;
+	removePlayerEntityDangerously(entity: Entity$1): void;
+}
+declare class ClientWorld extends World$1 {
+	private game: Game;
+	private scene: GameScene$1;
+	entityMesh: Map;
+	leaderboardToMesh: Map;
+	private entitySpawnQueue: Entity$1[];
+	/** another relic, but this time I can't find it in MCP-919? */
+	chunkRenderBlockUpdateListener: undefined;
+	chunkProvider: ChunkProviderClient;
+	constructor(game: Game, scene: GameScene$1, dimension: number);
+	get isClient(): boolean;
+	get isServer(): boolean;
+	addPlayer(plr: EntityPlayer$1): void;
+	addTileEntity(tile: TileEntity): void;
+	removeTileEntity(pos: BlockPos$1): void;
+	setBlockState(
+		pos: BlockPos$1,
+		state: BlockState$1,
+		flags?: number,
+		preRender?: boolean,
+	): boolean;
+	playSoundAtEntity(
+		entity: Entity$1,
+		name: string,
+		volume?: number,
+		pitch?: number,
+	): void;
+	playSoundAtPosition(
+		name: string,
+		pos: BlockPos$1,
+		volume?: number,
+		pitch?: number,
+	): void;
+	playSound(name: string, volume?: number, pitch?: number): void;
+	displayBarrierParticles(x: number, y: number, z: number): void;
+	spawnParticle(
+		particle: EnumParticleTypes,
+		xOff: number,
+		yOff: number,
+		zOff: number,
+		idk1: unknown,
+		idk2: unknown,
+		idk3: unknown,
+		pos: Vector3$2,
+		...v: unknown[]
+	): void;
+	getEntitiesWithinAABB(eType: string | null, box: Box3): Entity$1[];
+	update(): void;
+	spawnEntityInWorld(h: Entity$1): boolean;
+	onEntityAdded(entity: Entity$1): void;
+	removeEntity(entity: Entity$1): void;
+	onEntityRemoved(entity: Entity$1): void;
+	removeEntityFromWorld(entity: Entity$1): Entity$1;
+	removeAllEntities(): void;
+	isBlockLoaded(bp: BlockPos$1): boolean;
+	handleBlockUpdate(bpJSON: CPacketBlockUpdate): void;
+	getRenderDistanceChunks(): number;
+	clear(): void;
+}
+//#endregion
+//#region src/blocks/Block.d.ts
+declare class Block$1 {
+	name?: string;
+	material: Material;
+	slipperiness: number;
+	blockHardness: number;
+	blockResistance: number;
+	enableStats: boolean;
+	needsRandomTick: boolean;
+	isBlockContainer: boolean;
+	lightOpacity: number;
+	lightValue: number;
+	useNeighborBrightness: boolean;
+	blockParticleGravity: number;
+	getBoundingBox(): Box3$1;
+	isFullBlock(): boolean;
+	isOpaqueCube(): boolean;
+	isPassable(world: World$1, pos: BlockPos$1): boolean;
+	getCollisionBoundingBox(world: World$1, pos: BlockPos$1): Box3$1 | null;
+	isCollidable(): boolean;
+	canCollideCheck(state: BlockState$1, hitIfLiquid: boolean): boolean;
+	getMaterial(): Material;
+	getBlockHardness(world: World$1, pos: BlockPos$1): number;
+	setBlockUnbreakable(): this;
+	getBlockBoundsMinX(): number;
+	getBlockBoundsMaxX(): number;
+	getBlockBoundsMinY(): number;
+	getBlockBoundsMaxY(): number;
+	getBlockBoundsMinZ(): number;
+	getBlockBoundsMaxZ(): number;
+	setLightOpacity(opacity: number): this;
+	setLightLevel(level: number): this;
+	setResistance(resistance: number): this;
+	setHardness(hardness: number): this;
+	setStepSound(sound: SoundType): this;
+	setBlockBounds(
+		minX: number,
+		minY: number,
+		minZ: number,
+		maxX: number,
+		maxY: number,
+		maxZ: number,
+	): void;
+}
+declare class BlockChest extends Block$1 {
+	// Chest block
+	isTrapped?: boolean;
+}
+interface BlockAir extends Block$1 {}
+interface BlockStone extends Block$1 {}
+interface BlockDefault extends Block$1 {}
+interface BlockGrass extends Block$1 {}
+interface BlockDirt extends Block$1 {}
+interface BlockPodzol extends Block$1 {}
+interface BlockPlanks extends Block$1 {}
+interface BlockSapling extends Block$1 {}
+interface BlockLiquidWater extends Block$1 {}
+interface BlockLiquidLava extends Block$1 {}
+interface BlockFalling extends Block$1 {}
+interface BlockGravel extends Block$1 {}
+interface BlockOre extends Block$1 {}
+interface BlockLog extends Block$1 {}
+interface BlockStrippedLog extends Block$1 {}
+interface BlockStrippedWood extends Block$1 {}
+interface BlockWood extends Block$1 {}
+interface BlockLeaves extends Block$1 {}
+interface BlockGlass extends Block$1 {}
+interface BlockRedstoneBlock extends Block$1 {}
+interface BlockMarble extends Block$1 {}
+interface BlockMarble$1 extends Block$1 {}
+interface BlockSandStone extends Block$1 {}
+interface BlockBookshelf extends Block$1 {}
+interface BlockWorkbench extends Block$1 {}
+interface BlockTnt extends Block$1 {}
+interface BlockCake extends Block$1 {}
+interface BlockWeb extends Block$1 {}
+interface BlockFurnace extends Block$1 {}
+interface BlockShrub extends Block$1 {}
+interface BlockWool extends Block$1 {}
+interface BlockMushroom extends Block$1 {}
+interface BlockIce extends Block$1 {}
+interface BlockPackedIce extends Block$1 {}
+interface BlockSnowBlock extends Block$1 {}
+interface BlockJukebox extends Block$1 {}
+interface BlockPumpkin extends Block$1 {}
+interface BlockCarvedPumpkin extends Block$1 {}
+interface BlockHellstone extends Block$1 {}
+interface BlockSoulSand extends Block$1 {}
+interface BlockGlowstone extends Block$1 {}
+interface BlockMelon extends Block$1 {}
+interface BlockFire extends Block$1 {}
+interface BlockSlime extends Block$1 {}
+interface BlockRotatedPillar extends Block$1 {}
+interface BlockHardenedClay extends Block$1 {}
+interface BlockConcrete extends Block$1 {}
+interface BlockHugeMushroom extends Block$1 {}
+interface BlockHalfStoneSlab extends Block$1 {}
+interface BlockHalfWoodSlab extends Block$1 {}
+interface BlockHalfStoneSlab$1 extends Block$1 {}
+interface BlockHalfBrickSlab extends Block$1 {}
+interface BlockHalfSandstoneSlab extends Block$1 {}
+interface BlockStairs extends Block$1 {}
+interface BlockCactus extends Block$1 {}
+interface BlockLadder extends Block$1 {}
+interface BlockVine extends Block$1 {}
+interface BlockCommandBlock extends Block$1 {}
+interface BlockDoor extends Block$1 {}
+interface BlockCarpet extends Block$1 {}
+interface BlockMuck extends Block$1 {}
+interface BlockSnow extends Block$1 {}
+interface BlockEnchantmentTable extends Block$1 {}
+interface BlockEnderChest extends Block$1 {}
+interface BlockStandingSign extends Block$1 {}
+interface BlockWallSign extends Block$1 {}
+interface BlockPistonBase extends Block$1 {}
+interface BlockPistonExtension extends Block$1 {}
+interface BlockPistonMoving extends Block$1 {}
+interface BlockBarrier extends Block$1 {}
+interface BlockFarmland extends Block$1 {}
+interface BlockCrops extends Block$1 {}
+interface BlockCarrot extends Block$1 {}
+interface BlockPotato extends Block$1 {}
+interface BlockHellFungus extends Block$1 {}
+interface BlockRedstoneWire extends Block$1 {}
+interface BlockLever extends Block$1 {}
+interface BlockButtonStone extends Block$1 {}
+interface BlockButtonWood extends Block$1 {}
+interface BlockTorch extends Block$1 {}
+interface BlockWallTorch extends Block$1 {}
+interface BlockRedstoneTorch extends Block$1 {}
+interface BlockRedstoneWallTorch extends Block$1 {}
+interface BlockRedstoneRepeater extends Block$1 {}
+interface BlockRedstoneComparator extends Block$1 {}
+interface BlockRedstoneLight extends Block$1 {}
+interface BlockPressurePlate extends Block$1 {}
+interface BlockPressurePlateWeighted extends Block$1 {}
+interface BlockFence extends Block$1 {}
+interface BlockFenceGate extends Block$1 {}
+interface BlockWall extends Block$1 {}
+interface BlockPane extends Block$1 {}
+interface BlockStem extends Block$1 {}
+interface BlockCauldron extends Block$1 {}
+interface BlockTrapDoor extends Block$1 {}
+interface BlockLilyPad extends Block$1 {}
+interface BlockDragonEgg extends Block$1 {}
+interface BlockAnvil extends Block$1 {}
+interface BlockDispenser extends Block$1 {}
+interface BlockBed extends Block$1 {}
+interface BlockReed extends Block$1 {}
+interface BlockHellPortal extends Block$1 {}
+interface BlockCloud extends Block$1 {} // this actually exposed in the window object like a few other objects (i.e. window.Buffer).
+// see:
+/*
+```ts
+let Blocks = te; // useless alias. using rollup for bundling and then doing this????
+Items.init();
+furnaceRecipes.registerRecipes();
+globalThis.Blocks = Blocks;
+//        ^^^^^^^^^^^^^^^^
+```
+*/
+type AllBlocks = {
+	readonly idToBlock: Map<number, Block$1>;
+	readonly idToBlockState: Map<number, BlockState$1>;
+	readonly blockStateToId: Map<BlockState$1, number>;
+	readonly nameToBlock: Map<string, Block$1>;
+	readonly air: BlockAir;
+	readonly stone: BlockStone;
+	readonly granite: BlockDefault;
+	readonly polished_granite: BlockDefault;
+	readonly diorite: BlockDefault;
+	readonly polished_diorite: BlockDefault;
+	readonly andesite: BlockDefault;
+	readonly polished_andesite: BlockDefault;
+	readonly grass_block: BlockGrass;
+	readonly dirt: BlockDirt;
+	readonly coarse_dirt: BlockDirt;
+	readonly podzol: BlockPodzol;
+	readonly cobblestone: BlockDefault;
+	readonly oak_planks: BlockPlanks;
+	readonly spruce_planks: BlockPlanks;
+	readonly birch_planks: BlockPlanks;
+	readonly jungle_planks: BlockPlanks;
+	readonly acacia_planks: BlockPlanks;
+	readonly dark_oak_planks: BlockPlanks;
+	readonly oak_sapling: BlockSapling;
+	readonly spruce_sapling: BlockSapling;
+	readonly birch_sapling: BlockSapling;
+	readonly jungle_sapling: BlockSapling;
+	readonly acacia_sapling: BlockSapling;
+	readonly dark_oak_sapling: BlockSapling;
+	readonly bedrock: BlockDefault;
+	readonly water: BlockLiquidWater;
+	readonly lava: BlockLiquidLava;
+	readonly sand: BlockFalling;
+	readonly red_sand: BlockFalling;
+	readonly gravel: BlockGravel;
+	readonly gold_ore: BlockOre;
+	readonly iron_ore: BlockOre;
+	readonly coal_ore: BlockOre;
+	readonly diamond_ore: BlockOre;
+	readonly emerald_ore: BlockOre;
+	readonly lapis_ore: BlockOre;
+	readonly redstone_ore: BlockOre;
+	readonly hell_marble_ore: BlockOre;
+	readonly infernium_ore: BlockOre;
+	readonly oak_log: BlockLog;
+	readonly spruce_log: BlockLog;
+	readonly birch_log: BlockLog;
+	readonly jungle_log: BlockLog;
+	readonly acacia_log: BlockLog;
+	readonly dark_oak_log: BlockLog;
+	readonly stripped_oak_log: BlockStrippedLog;
+	readonly stripped_spruce_log: BlockStrippedLog;
+	readonly stripped_birch_log: BlockStrippedLog;
+	readonly stripped_jungle_log: BlockStrippedLog;
+	readonly stripped_acacia_log: BlockStrippedLog;
+	readonly stripped_dark_oak_log: BlockStrippedLog;
+	readonly stripped_oak_wood: BlockStrippedWood;
+	readonly stripped_spruce_wood: BlockStrippedWood;
+	readonly stripped_birch_wood: BlockStrippedWood;
+	readonly stripped_jungle_wood: BlockStrippedWood;
+	readonly stripped_acacia_wood: BlockStrippedWood;
+	readonly stripped_dark_oak_wood: BlockStrippedWood;
+	readonly oak_wood: BlockWood;
+	readonly spruce_wood: BlockWood;
+	readonly birch_wood: BlockWood;
+	readonly jungle_wood: BlockWood;
+	readonly acacia_wood: BlockWood;
+	readonly dark_oak_wood: BlockWood;
+	readonly oak_leaves: BlockLeaves;
+	readonly spruce_leaves: BlockLeaves;
+	readonly birch_leaves: BlockLeaves;
+	readonly jungle_leaves: BlockLeaves;
+	readonly acacia_leaves: BlockLeaves;
+	readonly dark_oak_leaves: BlockLeaves;
+	readonly sponge: BlockDefault;
+	readonly glass: BlockGlass;
+	readonly white_stained_glass: BlockGlass;
+	readonly orange_stained_glass: BlockGlass;
+	readonly magenta_stained_glass: BlockGlass;
+	readonly light_blue_stained_glass: BlockGlass;
+	readonly yellow_stained_glass: BlockGlass;
+	readonly lime_stained_glass: BlockGlass;
+	readonly pink_stained_glass: BlockGlass;
+	readonly gray_stained_glass: BlockGlass;
+	readonly light_gray_stained_glass: BlockGlass;
+	readonly cyan_stained_glass: BlockGlass;
+	readonly purple_stained_glass: BlockGlass;
+	readonly blue_stained_glass: BlockGlass;
+	readonly brown_stained_glass: BlockGlass;
+	readonly green_stained_glass: BlockGlass;
+	readonly red_stained_glass: BlockGlass;
+	readonly black_stained_glass: BlockGlass;
+	readonly coal_block: BlockDefault;
+	readonly iron_block: BlockDefault;
+	readonly gold_block: BlockDefault;
+	readonly diamond_block: BlockDefault;
+	readonly emerald_block: BlockDefault;
+	readonly infernium_block: BlockDefault;
+	readonly lapis_block: BlockDefault;
+	readonly redstone_block: BlockRedstoneBlock;
+	readonly marble_block: BlockMarble;
+	readonly marble_pillar: BlockDefault;
+	readonly chiseled_marble_block: BlockMarble$1;
+	readonly sandstone: BlockSandStone;
+	readonly chiseled_sandstone: BlockSandStone;
+	readonly smooth_sandstone: BlockSandStone;
+	readonly cut_sandstone: BlockSandStone;
+	readonly red_sandstone: BlockSandStone;
+	readonly chiseled_red_sandstone: BlockSandStone;
+	readonly smooth_red_sandstone: BlockSandStone;
+	readonly note_block: BlockDefault;
+	readonly bookshelf: BlockBookshelf;
+	readonly workbench: BlockWorkbench;
+	readonly bricks: BlockDefault;
+	readonly tnt: BlockTnt;
+	readonly mossy_cobblestone: BlockDefault;
+	readonly obsidian: BlockDefault;
+	readonly cake: BlockCake;
+	readonly cobweb: BlockWeb;
+	readonly furnace: BlockFurnace;
+	readonly grass: BlockShrub;
+	readonly dead_bush: BlockShrub;
+	readonly fern: BlockShrub;
+	readonly white_wool: BlockWool;
+	readonly orange_wool: BlockWool;
+	readonly magenta_wool: BlockWool;
+	readonly light_blue_wool: BlockWool;
+	readonly yellow_wool: BlockWool;
+	readonly lime_wool: BlockWool;
+	readonly pink_wool: BlockWool;
+	readonly gray_wool: BlockWool;
+	readonly light_gray_wool: BlockWool;
+	readonly cyan_wool: BlockWool;
+	readonly purple_wool: BlockWool;
+	readonly blue_wool: BlockWool;
+	readonly brown_wool: BlockWool;
+	readonly green_wool: BlockWool;
+	readonly red_wool: BlockWool;
+	readonly black_wool: BlockWool;
+	readonly poppy: BlockShrub;
+	readonly dandelion: BlockShrub;
+	readonly blue_orchid: BlockShrub;
+	readonly allium: BlockShrub;
+	readonly azure_bluet: BlockShrub;
+	readonly red_tulip: BlockShrub;
+	readonly orange_tulip: BlockShrub;
+	readonly white_tulip: BlockShrub;
+	readonly pink_tulip: BlockShrub;
+	readonly oxeye_daisy: BlockShrub;
+	readonly red_mushroom: BlockMushroom;
+	readonly brown_mushroom: BlockMushroom;
+	readonly ice: BlockIce;
+	readonly packed_ice: BlockPackedIce;
+	readonly snow_block: BlockSnowBlock;
+	readonly clay: BlockDefault;
+	readonly jukebox: BlockJukebox;
+	readonly pumpkin: BlockPumpkin;
+	readonly carved_pumpkin: BlockCarvedPumpkin;
+	readonly jack_o_lantern: BlockDefault;
+	readonly hellstone: BlockHellstone;
+	readonly soul_sand: BlockSoulSand;
+	readonly glowstone: BlockGlowstone;
+	readonly melon: BlockMelon;
+	readonly fire: BlockFire;
+	readonly slime_block: BlockSlime;
+	readonly hay_block: BlockRotatedPillar;
+	readonly terracotta: BlockHardenedClay;
+	readonly white_terracotta: BlockHardenedClay;
+	readonly orange_terracotta: BlockHardenedClay;
+	readonly magenta_terracotta: BlockHardenedClay;
+	readonly light_blue_terracotta: BlockHardenedClay;
+	readonly yellow_terracotta: BlockHardenedClay;
+	readonly lime_terracotta: BlockHardenedClay;
+	readonly pink_terracotta: BlockHardenedClay;
+	readonly gray_terracotta: BlockHardenedClay;
+	readonly light_gray_terracotta: BlockHardenedClay;
+	readonly cyan_terracotta: BlockHardenedClay;
+	readonly purple_terracotta: BlockHardenedClay;
+	readonly blue_terracotta: BlockHardenedClay;
+	readonly brown_terracotta: BlockHardenedClay;
+	readonly green_terracotta: BlockHardenedClay;
+	readonly red_terracotta: BlockHardenedClay;
+	readonly black_terracotta: BlockHardenedClay;
+	readonly white_concrete: BlockConcrete;
+	readonly orange_concrete: BlockConcrete;
+	readonly magenta_concrete: BlockConcrete;
+	readonly light_blue_concrete: BlockConcrete;
+	readonly yellow_concrete: BlockConcrete;
+	readonly lime_concrete: BlockConcrete;
+	readonly pink_concrete: BlockConcrete;
+	readonly gray_concrete: BlockConcrete;
+	readonly light_gray_concrete: BlockConcrete;
+	readonly cyan_concrete: BlockConcrete;
+	readonly purple_concrete: BlockConcrete;
+	readonly blue_concrete: BlockConcrete;
+	readonly brown_concrete: BlockConcrete;
+	readonly green_concrete: BlockConcrete;
+	readonly red_concrete: BlockConcrete;
+	readonly black_concrete: BlockConcrete;
+	readonly stone_bricks: BlockDefault;
+	readonly smooth_stone: BlockDefault;
+	readonly mossy_stone_bricks: BlockDefault;
+	readonly cracked_stone_bricks: BlockDefault;
+	readonly chiseled_stone_bricks: BlockDefault;
+	readonly brown_mushroom_block: BlockHugeMushroom;
+	readonly red_mushroom_block: BlockHugeMushroom;
+	readonly stem_mushroom_block: BlockHugeMushroom;
+	readonly hell_bricks: BlockDefault;
+	readonly aquastone: BlockDefault;
+	readonly aquastone_bricks: BlockDefault;
+	readonly dark_aquastone: BlockDefault;
+	readonly end_stone: BlockDefault;
+	readonly end_stone_bricks: BlockDefault;
+	readonly stone_slab: BlockHalfStoneSlab;
+	readonly stone_brick_slab: BlockHalfStoneSlab;
+	readonly smooth_stone_slab: BlockHalfStoneSlab;
+	readonly marble_slab: BlockHalfStoneSlab;
+	readonly oak_slab: BlockHalfWoodSlab;
+	readonly spruce_slab: BlockHalfWoodSlab;
+	readonly birch_slab: BlockHalfWoodSlab;
+	readonly jungle_slab: BlockHalfWoodSlab;
+	readonly acacia_slab: BlockHalfWoodSlab;
+	readonly dark_oak_slab: BlockHalfWoodSlab;
+	readonly cobblestone_slab: BlockHalfStoneSlab$1;
+	readonly brick_slab: BlockHalfBrickSlab;
+	readonly sandstone_slab: BlockHalfSandstoneSlab;
+	readonly red_sandstone_slab: BlockHalfSandstoneSlab;
+	readonly granite_slab: BlockHalfStoneSlab;
+	readonly diorite_slab: BlockHalfStoneSlab;
+	readonly andesite_slab: BlockHalfStoneSlab;
+	readonly oak_stairs: BlockStairs;
+	readonly spruce_stairs: BlockStairs;
+	readonly birch_stairs: BlockStairs;
+	readonly jungle_stairs: BlockStairs;
+	readonly acacia_stairs: BlockStairs;
+	readonly dark_oak_stairs: BlockStairs;
+	readonly stone_stairs: BlockStairs;
+	readonly cobblestone_stairs: BlockStairs;
+	readonly brick_stairs: BlockStairs;
+	readonly stone_brick_stairs: BlockStairs;
+	readonly hell_brick_stairs: BlockStairs;
+	readonly sandstone_stairs: BlockStairs;
+	readonly smooth_sandstone_stairs: BlockStairs;
+	readonly red_sandstone_stairs: BlockStairs;
+	readonly smooth_red_sandstone_stairs: BlockStairs;
+	readonly marble_stairs: BlockStairs;
+	readonly smooth_marble_stairs: BlockStairs;
+	readonly andesite_stairs: BlockStairs;
+	readonly diorite_stairs: BlockStairs;
+	readonly granite_stairs: BlockStairs;
+	readonly polished_andesite_stairs: BlockStairs;
+	readonly polished_diorite_stairs: BlockStairs;
+	readonly polished_granite_stairs: BlockStairs;
+	readonly end_stone_brick_stairs: BlockStairs;
+	readonly aquastone_stairs: BlockStairs;
+	readonly aquastone_brick_stairs: BlockStairs;
+	readonly dark_aquastone_stairs: BlockStairs;
+	readonly mossy_cobblestone_stairs: BlockStairs;
+	readonly mossy_stone_brick_stairs: BlockStairs;
+	readonly cactus: BlockCactus;
+	readonly ladder: BlockLadder;
+	readonly iron_ladder: BlockLadder;
+	readonly vine: BlockVine;
+	readonly sea_lantern: BlockDefault;
+	readonly command_block: BlockCommandBlock;
+	readonly oak_door: BlockDoor;
+	readonly spruce_door: BlockDoor;
+	readonly birch_door: BlockDoor;
+	readonly jungle_door: BlockDoor;
+	readonly acacia_door: BlockDoor;
+	readonly dark_oak_door: BlockDoor;
+	readonly iron_door: BlockDoor;
+	readonly white_carpet: BlockCarpet;
+	readonly orange_carpet: BlockCarpet;
+	readonly magenta_carpet: BlockCarpet;
+	readonly light_blue_carpet: BlockCarpet;
+	readonly yellow_carpet: BlockCarpet;
+	readonly lime_carpet: BlockCarpet;
+	readonly pink_carpet: BlockCarpet;
+	readonly gray_carpet: BlockCarpet;
+	readonly light_gray_carpet: BlockCarpet;
+	readonly cyan_carpet: BlockCarpet;
+	readonly purple_carpet: BlockCarpet;
+	readonly blue_carpet: BlockCarpet;
+	readonly brown_carpet: BlockCarpet;
+	readonly green_carpet: BlockCarpet;
+	readonly red_carpet: BlockCarpet;
+	readonly black_carpet: BlockCarpet;
+	readonly muck: BlockMuck;
+	readonly snow: BlockSnow;
+	readonly enchanting_table: BlockEnchantmentTable;
+	readonly chest: BlockChest;
+	readonly ender_chest: BlockEnderChest;
+	readonly acacia_sign: BlockStandingSign;
+	readonly birch_sign: BlockStandingSign;
+	readonly dark_oak_sign: BlockStandingSign;
+	readonly jungle_sign: BlockStandingSign;
+	readonly oak_sign: BlockStandingSign;
+	readonly spruce_sign: BlockStandingSign;
+	readonly acacia_wall_sign: BlockWallSign;
+	readonly birch_wall_sign: BlockWallSign;
+	readonly dark_oak_wall_sign: BlockWallSign;
+	readonly jungle_wall_sign: BlockWallSign;
+	readonly oak_wall_sign: BlockWallSign;
+	readonly spruce_wall_sign: BlockWallSign;
+	readonly sticky_piston: BlockPistonBase;
+	readonly piston: BlockPistonBase;
+	readonly piston_head: BlockPistonExtension;
+	readonly moving_piston: BlockPistonMoving;
+	readonly barrier: BlockBarrier;
+	readonly farmland: BlockFarmland;
+	readonly wheat: BlockCrops;
+	readonly carrots: BlockCarrot;
+	readonly potatoes: BlockPotato;
+	readonly hell_fungus: BlockHellFungus;
+	readonly redstone_wire: BlockRedstoneWire;
+	readonly lever: BlockLever;
+	readonly stone_button: BlockButtonStone;
+	readonly oak_button: BlockButtonWood;
+	readonly spruce_button: BlockButtonWood;
+	readonly birch_button: BlockButtonWood;
+	readonly jungle_button: BlockButtonWood;
+	readonly acacia_button: BlockButtonWood;
+	readonly dark_oak_button: BlockButtonWood;
+	readonly torch: BlockTorch;
+	readonly wall_torch: BlockWallTorch;
+	readonly redstone_torch: BlockRedstoneTorch;
+	readonly redstone_wall_torch: BlockRedstoneWallTorch;
+	readonly repeater: BlockRedstoneRepeater;
+	readonly comparator: BlockRedstoneComparator;
+	readonly redstone_lamp: BlockRedstoneLight;
+	readonly stone_pressure_plate: BlockPressurePlate;
+	readonly oak_pressure_plate: BlockPressurePlate;
+	readonly spruce_pressure_plate: BlockPressurePlate;
+	readonly birch_pressure_plate: BlockPressurePlate;
+	readonly jungle_pressure_plate: BlockPressurePlate;
+	readonly acacia_pressure_plate: BlockPressurePlate;
+	readonly dark_oak_pressure_plate: BlockPressurePlate;
+	readonly light_weighted_pressure_plate: BlockPressurePlateWeighted;
+	readonly heavy_weighted_pressure_plate: BlockPressurePlateWeighted;
+	readonly oak_fence: BlockFence;
+	readonly spruce_fence: BlockFence;
+	readonly birch_fence: BlockFence;
+	readonly jungle_fence: BlockFence;
+	readonly acacia_fence: BlockFence;
+	readonly dark_oak_fence: BlockFence;
+	readonly hell_brick_fence: BlockFence;
+	readonly oak_fence_gate: BlockFenceGate;
+	readonly spruce_fence_gate: BlockFenceGate;
+	readonly birch_fence_gate: BlockFenceGate;
+	readonly jungle_fence_gate: BlockFenceGate;
+	readonly acacia_fence_gate: BlockFenceGate;
+	readonly dark_oak_fence_gate: BlockFenceGate;
+	readonly andesite_wall: BlockWall;
+	readonly blackstone_wall: BlockWall;
+	readonly brick_wall: BlockWall;
+	readonly cobblestone_wall: BlockWall;
+	readonly diorite_wall: BlockWall;
+	readonly end_stone_brick_wall: BlockWall;
+	readonly granite_wall: BlockWall;
+	readonly mossy_cobblestone_wall: BlockWall;
+	readonly mossy_stone_brick_wall: BlockWall;
+	readonly hell_brick_wall: BlockWall;
+	readonly red_hell_brick_wall: BlockWall;
+	readonly sandstone_wall: BlockWall;
+	readonly stone_brick_wall: BlockWall;
+	readonly red_sandstone_wall: BlockWall;
+	readonly aquastone_wall: BlockWall;
+	readonly iron_bars: BlockPane;
+	readonly glass_pane: BlockPane;
+	readonly white_stained_glass_pane: BlockPane;
+	readonly orange_stained_glass_pane: BlockPane;
+	readonly magenta_stained_glass_pane: BlockPane;
+	readonly light_blue_stained_glass_pane: BlockPane;
+	readonly yellow_stained_glass_pane: BlockPane;
+	readonly lime_stained_glass_pane: BlockPane;
+	readonly pink_stained_glass_pane: BlockPane;
+	readonly gray_stained_glass_pane: BlockPane;
+	readonly light_gray_stained_glass_pane: BlockPane;
+	readonly cyan_stained_glass_pane: BlockPane;
+	readonly purple_stained_glass_pane: BlockPane;
+	readonly blue_stained_glass_pane: BlockPane;
+	readonly brown_stained_glass_pane: BlockPane;
+	readonly green_stained_glass_pane: BlockPane;
+	readonly red_stained_glass_pane: BlockPane;
+	readonly black_stained_glass_pane: BlockPane;
+	readonly pumpkin_stem: BlockStem;
+	readonly melon_stem: BlockStem;
+	readonly cauldron: BlockCauldron;
+	readonly water_cauldron: BlockCauldron;
+	readonly oak_trapdoor: BlockTrapDoor;
+	readonly spruce_trapdoor: BlockTrapDoor;
+	readonly birch_trapdoor: BlockTrapDoor;
+	readonly jungle_trapdoor: BlockTrapDoor;
+	readonly acacia_trapdoor: BlockTrapDoor;
+	readonly dark_oak_trapdoor: BlockTrapDoor;
+	readonly iron_trapdoor: BlockTrapDoor;
+	readonly lily_pad: BlockLilyPad;
+	readonly dragon_egg: BlockDragonEgg;
+	readonly anvil: BlockAnvil;
+	readonly dispenser: BlockDispenser;
+	readonly white_bed: BlockBed;
+	readonly orange_bed: BlockBed;
+	readonly magenta_bed: BlockBed;
+	readonly light_blue_bed: BlockBed;
+	readonly yellow_bed: BlockBed;
+	readonly lime_bed: BlockBed;
+	readonly pink_bed: BlockBed;
+	readonly gray_bed: BlockBed;
+	readonly light_gray_bed: BlockBed;
+	readonly cyan_bed: BlockBed;
+	readonly purple_bed: BlockBed;
+	readonly blue_bed: BlockBed;
+	readonly brown_bed: BlockBed;
+	readonly green_bed: BlockBed;
+	readonly red_bed: BlockBed;
+	readonly black_bed: BlockBed;
+	readonly reeds: BlockReed;
+	readonly bone_block: BlockRotatedPillar;
+	readonly hell_portal: BlockHellPortal;
+	readonly cloud_block: BlockCloud;
+	readonly [key: string]: Block$1;
+};
+//#endregion
+//#region src/network/clientSocket.d.ts
+declare interface EventMap {
+	disconnect: string;
+	CPacketAnimation: CPacketAnimation;
+	CPacketBlockAction: CPacketBlockAction;
+	CPacketBlockUpdate: CPacketBlockUpdate;
+	CPacketChangeServers: CPacketChangeServers;
+	CPacketChunkData: CPacketChunkData;
+	CPacketCloseWindow: CPacketCloseWindow;
+	CPacketConfirmTransaction: CPacketConfirmTransaction;
+	CPacketDestroyEntities: CPacketDestroyEntities;
+	CPacketDisconnect: CPacketDisconnect;
+	CPacketEntityAction: CPacketEntityAction;
+	CPacketEntityEquipment: CPacketEntityEquipment;
+	CPacketEntityMetadata: CPacketEntityMetadata;
+	CPacketEntityPositionAndRotation: CPacketEntityPositionAndRotation;
+	CPacketEntityRelativePositionAndRotation: CPacketEntityRelativePositionAndRotation;
+	CPacketEntityStatus: CPacketEntityStatus;
+	CPacketEntityVelocity: CPacketEntityVelocity;
+	CPacketExplosion: CPacketExplosion;
+	CPacketJoinGame: CPacketJoinGame;
+	CPacketLeaderboard: CPacketLeaderboard;
+	CPacketLocalStorage: CPacketLocalStorage;
+	CPacketMessage: CPacketMessage;
+	CPacketOpenWindow: CPacketOpenWindow;
+	CPacketParticles: CPacketParticles;
+	CPacketPlayerList: CPacketPlayerList;
+	CPacketPlayerPosition: CPacketPlayerPosition;
+	CPacketPlayerPosLook: CPacketPlayerPosLook;
+	CPacketPlayerReconciliation: CPacketPlayerReconciliation;
+	CPacketPong: CPacketPong;
+	CPacketRespawn: CPacketRespawn;
+	CPacketScoreboard: CPacketScoreboard;
+	CPacketServerInfo: CPacketServerInfo;
+	CPacketSetSlot: CPacketSetSlot;
+	CPacketSignEditorOpen: CPacketSignEditorOpen;
+	CPacketSoundEffect: CPacketSoundEffect;
+	CPacketSpawnEntity: CPacketSpawnEntity;
+	CPacketSpawnPlayer: CPacketSpawnPlayer;
+	CPacketTabComplete: CPacketTabComplete;
+	CPacketTitle: CPacketTitle;
+	CPacketUpdate: CPacketUpdate;
+	CPacketUpdateHealth: CPacketUpdateHealth;
+	CPacketUpdateLeaderboard: CPacketUpdateLeaderboard;
+	CPacketUpdateScoreboard: CPacketUpdateScoreboard;
+	CPacketUpdateSign: CPacketUpdateSign;
+	CPacketUpdateStatus: CPacketUpdateStatus;
+	CPacketWindowItems: CPacketWindowItems;
+	CPacketWindowProperty: CPacketWindowProperty;
+	CPacketUseBed: CPacketUseBed;
+	CPacketQueueNext: CPacketQueueNext;
+	CPacketSpawnExperienceOrb: CPacketSpawnExperienceOrb;
+	CPacketSetExperience: CPacketSetExperience;
+	CPacketOpenShop: CPacketOpenShop;
+	CPacketShopProperties: CPacketShopProperties;
+	CPacketEntityProperties: CPacketEntityProperties;
+	CPacketEntityEffect: CPacketEntityEffect;
+	CPacketRemoveEntityEffect: CPacketRemoveEntityEffect;
+	CPacketUpdateCommandBlock: CPacketUpdateCommandBlock;
+	CPacketEntityAttach: CPacketEntityAttach;
+	CPacketServerMetadata: CPacketServerMetadata;
+	CPacketTimeUpdate: CPacketTimeUpdate;
+	ClientBoundCombined: ClientBoundCombined; // biome-ignore lint/suspicious/noConfusingVoidType: used as a parameter + I'm bored
+	connect: void;
+}
+type thing<T> = T extends void ? () => void : (data: T) => void; // biome-ignore lint/complexity/noStaticOnlyClass: this is Miniblox's code, not mine.
+declare class ClientSocket {
+	static socket: Socket;
+	static disconnectMessage?: string;
+	/**
+	 * @param url server URI/URL
+	 * @param path defaults to `/socket.io`
+	 */
+	static setUrl(url: string, path?: string): void;
+	static connect(): void;
+	static disconnect(message: string): void;
+	static once<T>(name: T, callback: thing<EventMap[T]>): void;
+	static on<T>(name: T, callback: (data: thing<EventMap[T]>) => void): void;
+	static sendPacket(packet: C2SPacket): void;
+}
+//#endregion
+//#region src/utils/Utils.d.ts
+declare function keyPressed(key: string): boolean;
+declare function canCraftItem(
+	inventory: InventoryPlayer,
+	recipe: Recipe,
+): boolean;
+declare function craftItem(
+	inventory: InventoryPlayer,
+	recipe: Recipe,
+	shiftDown: boolean,
+): void;
+type ItemID = number;
+interface Result {
+	count: number;
+	id: ItemID;
+}
+type Shape = ItemID[][];
+type OptionalShape = (ItemID | undefined)[][];
+interface WithResult {
+	result: Result;
+}
+interface WithIngredients extends WithResult {
+	ingredients: ItemID[];
+}
+interface WithShape extends WithResult {
+	inShape: Shape;
+}
+interface WithOptionalShape extends WithResult {
+	inShape: OptionalShape;
+}
+interface WithOptionalShapeAndIngredients extends WithResult {
+	inShape?: Shape;
+	ingredients?: ItemID[];
+}
+type Recipe =
+	| WithIngredients
+	| WithShape
+	| WithOptionalShape
+	| WithOptionalShapeAndIngredients;
+// Recipe registry
+declare type RecipeRegistry = Record<number, Recipe[]>;
+interface Level {
+	owner: RankLevel;
+	admin: RankLevel;
+	goat: RankLevel;
+	janitor: RankLevel;
+	mod: RankLevel;
+	helper: RankLevel;
+	youtube: RankLevel;
+	builder: RankLevel;
+	og: RankLevel;
+	immortal: RankLevel;
+	legend: RankLevel;
+	pro: RankLevel;
+	[rank: string]: RankLevel;
+}
+interface RankLevel {
+	/** CSS Color string */
+	color: string;
+	permLevel: number;
+	rankLevel: number;
+}
+// Rank system
+declare const RANK: {
+	LEVEL: Level;
+};
+// Ray tracing
+declare function rayTraceBlocks(
+	start: Vector3$2,
+	end: Vector3$2,
+	stopOnLiquid: boolean,
+	ignoreBlockWithoutBoundingBox: boolean,
+	returnLastUncollidableBlock: boolean,
+	world: World$1,
+): RayTraceResult | null;
+// Block collision utilities
+declare function calculateXOffset(
+	self: Box3$1,
+	other: Box3$1,
+	offset: number,
+): number;
+declare function calculateYOffset(
+	self: Box3$1,
+	other: Box3$1,
+	offset: number,
+): number;
+declare function calculateZOffset(
+	self: Box3$1,
+	other: Box3$1,
+	offset: number,
+): number;
+
+//#endregion
+export {
+	Abilities,
+	AllBlocks,
+	AnimationKeyframe,
+	AnimationLerp,
+	AnyPacket$1 as AnyPacket,
+	AttributeMap,
+	Axis,
+	AxisDirection,
+	BanPlayer,
+	Block$1 as Block,
+	BlockChest,
+	BlockPos$1 as BlockPos,
+	BlockState$1 as BlockState,
+	C2SPacket,
+	Chat,
+	ChatData,
+	ChatLog,
+	Chunk,
+	ChunkProviderClient$1 as ChunkProviderClient,
+	ClientBoundCombined_CPacket,
+	ClientBoundCombined$1 as ClientBoundCombined,
+	ClientEntityPlayer,
+	ClientEntityPlayerOther,
+	ClientSocket,
+	ClientWorld,
+	CombatTracker,
+	CommandBlockLogic,
+	Container,
+	ContainerPlayer,
+	CPACKET_MAP,
+	CPacketAnimation$1 as CPacketAnimation,
+	CPacketBlockAction$1 as CPacketBlockAction,
+	CPacketBlockUpdate$1 as CPacketBlockUpdate,
+	CPacketChangeServers$1 as CPacketChangeServers,
+	CPacketChunkData$1 as CPacketChunkData,
+	CPacketCloseWindow$1 as CPacketCloseWindow,
+	CPacketConfirmTransaction$1 as CPacketConfirmTransaction,
+	CPacketDestroyEntities$1 as CPacketDestroyEntities,
+	CPacketDisconnect$1 as CPacketDisconnect,
+	CPacketEntityAction$1 as CPacketEntityAction,
+	CPacketEntityAttach$1 as CPacketEntityAttach,
+	CPacketEntityEffect$1 as CPacketEntityEffect,
+	CPacketEntityEquipment$1 as CPacketEntityEquipment,
+	CPacketEntityMetadata$1 as CPacketEntityMetadata,
+	CPacketEntityPositionAndRotation$1 as CPacketEntityPositionAndRotation,
+	CPacketEntityProperties$1 as CPacketEntityProperties,
+	CPacketEntityRelativePositionAndRotation$1 as CPacketEntityRelativePositionAndRotation,
+	CPacketEntityStatus$1 as CPacketEntityStatus,
+	CPacketEntityVelocity$1 as CPacketEntityVelocity,
+	CPacketExplosion$1 as CPacketExplosion,
+	CPacketJoinGame$1 as CPacketJoinGame,
+	CPacketLeaderboard$1 as CPacketLeaderboard,
+	CPacketLocalStorage_Action,
+	CPacketLocalStorage$1 as CPacketLocalStorage,
+	CPacketMessage$1 as CPacketMessage,
+	CPacketOpenShop$1 as CPacketOpenShop,
+	CPacketOpenWindow$1 as CPacketOpenWindow,
+	CPacketParticles$1 as CPacketParticles,
+	CPacketPlayerList$1 as CPacketPlayerList,
+	CPacketPlayerPosition$1 as CPacketPlayerPosition,
+	CPacketPlayerPosLook$1 as CPacketPlayerPosLook,
+	CPacketPlayerReconciliation$1 as CPacketPlayerReconciliation,
+	CPacketPong$1 as CPacketPong,
+	CPacketQueueNext$1 as CPacketQueueNext,
+	CPacketRemoveEntityEffect$1 as CPacketRemoveEntityEffect,
+	CPacketRespawn$1 as CPacketRespawn,
+	CPacketScoreboard$1 as CPacketScoreboard,
+	CPacketServerInfo$1 as CPacketServerInfo,
+	CPacketServerMetadata$1 as CPacketServerMetadata,
+	CPacketSetExperience$1 as CPacketSetExperience,
+	CPacketSetSlot$1 as CPacketSetSlot,
+	CPacketShopProperties$1 as CPacketShopProperties,
+	CPacketShopProperty,
+	CPacketSignEditorOpen$1 as CPacketSignEditorOpen,
+	CPacketSoundEffect$1 as CPacketSoundEffect,
+	CPacketSpawnEntity$1 as CPacketSpawnEntity,
+	CPacketSpawnExperienceOrb$1 as CPacketSpawnExperienceOrb,
+	CPacketSpawnPlayer$1 as CPacketSpawnPlayer,
+	CPacketTabComplete$1 as CPacketTabComplete,
+	CPacketTimeUpdate$1 as CPacketTimeUpdate,
+	CPacketTitle$1 as CPacketTitle,
+	CPacketUpdate$1 as CPacketUpdate,
+	CPacketUpdateCommandBlock$1 as CPacketUpdateCommandBlock,
+	CPacketUpdateHealth$1 as CPacketUpdateHealth,
+	CPacketUpdateLeaderboard$1 as CPacketUpdateLeaderboard,
+	CPacketUpdateScoreboard$1 as CPacketUpdateScoreboard,
+	CPacketUpdateSign$1 as CPacketUpdateSign,
+	CPacketUpdateStatus$1 as CPacketUpdateStatus,
+	CPacketUseBed$1 as CPacketUseBed,
+	CPacketWindowItems$1 as CPacketWindowItems,
+	CPacketWindowProperty$1 as CPacketWindowProperty,
+	calculateXOffset,
+	calculateYOffset,
+	calculateZOffset,
+	canCraftItem,
+	craftItem,
+	DamageSource,
+	DataWatcher,
+	DemotePlayer,
+	EffectRenderer$1 as EffectRenderer,
+	EffectsManager,
+	EmptyChunk$1 as EmptyChunk,
+	Enchantment,
+	EnchantmentData,
+	EnchantmentProtection,
+	Enchantments,
+	Entity$1 as Entity,
+	EntityArrow,
+	EntityFX,
+	EntityItem$1 as EntityItem,
+	EntityLivingBase$1 as EntityLivingBase,
+	EntityName,
+	EntityPlayer$1 as EntityPlayer,
+	EnumCreatureAttribute,
+	EnumDifficulty,
+	EnumEnchantmentType,
+	EnumFacing$1 as EnumFacing,
+	EnumParticleTypes$1 as EnumParticleTypes,
+	Equipment,
+	Equipment_Slot$1 as Equipment_Slot,
+	EventMap,
+	Explosion$1 as Explosion,
+	Font,
+	FontLoader,
+	FoodStats,
+	Game,
+	GameInfo,
+	GameMode,
+	GameProfile,
+	GameScene$1 as GameScene,
+	GameState,
+	Hud3D,
+	IChunkProvider,
+	ICrafting,
+	ID_TO_NAME,
+	ID_TO_PACKET,
+	IInterface,
+	Inventory$1 as Inventory,
+	InventoryBasic,
+	InventoryEnderChest,
+	InventoryPlayer,
+	Item$1 as Item,
+	ItemAppleGold,
+	ItemArmor,
+	ItemBlock,
+	ItemBow,
+	ItemFood,
+	ItemID,
+	ItemPickaxe,
+	ItemStack$1 as ItemStack,
+	ItemSword,
+	Items,
+	ItemTool,
+	KickPlayer,
+	keyPressed,
+	Level,
+	Material,
+	Materials,
+	Message,
+	NAME_TO_ID,
+	OptionalShape,
+	Options,
+	Options$1,
+	PBBlockPos,
+	PBCell,
+	PBCosmetics,
+	PBFloatVector3,
+	PBItemStack,
+	PBModifier,
+	PBSnapshot,
+	PBTileEntity,
+	PBVector3,
+	PBWatchableObject,
+	Perspective,
+	Plane,
+	PlayerController,
+	PlayerControllerMP,
+	PlayerData,
+	PlayerMovement,
+	PlayerPermissionEntry,
+	Potion,
+	PotionEffect,
+	Potions,
+	Profile,
+	PromotePlayer,
+	RANK,
+	RankLevel,
+	RayTraceResult,
+	Recipe,
+	RecipeRegistry,
+	RenderEntity,
+	RenderLivingEntity,
+	RenderPlayer,
+	ResourceMonitor,
+	Result,
+	rayTraceBlocks,
+	S2CPacket,
+	ScoreboardContent,
+	ServerInfo,
+	Shape,
+	Slot,
+	SlotActionType,
+	SPACKET_MAP,
+	SPacketAdminAction,
+	SPacketAnalytics,
+	SPacketBreakBlock,
+	SPacketClick,
+	SPacketClickWindow,
+	SPacketCloseWindow,
+	SPacketConfirmTransaction,
+	SPacketCraftItem,
+	SPacketEnchantItem,
+	SPacketEntityAction,
+	SPacketHeldItemChange,
+	SPacketLoginStart,
+	SPacketMessage,
+	SPacketOpenShop,
+	SPacketPing,
+	SPacketPlaceBlock,
+	SPacketPlayerAbilities,
+	SPacketPlayerAction,
+	SPacketPlayerInput,
+	SPacketPlayerPosLook,
+	SPacketQueueNext,
+	SPacketRequestChunk,
+	SPacketRespawn,
+	SPacketRespawn$1,
+	SPacketTabComplete$1,
+	SPacketUpdateCommandBlock,
+	SPacketUpdateInventory,
+	SPacketUpdateSign,
+	SPacketUseEntity,
+	SPacketUseItem,
+	StopServer,
+	Team$1 as Team,
+	TextureManager,
+	TileEntitySign,
+	TypeOfHit,
+	UnbanPlayer,
+	UpdateAccessControl,
+	UpdateCheats,
+	UpdatePvP,
+	Vector3$1 as Vector3,
+	WithIngredients,
+	WithOptionalShape,
+	WithOptionalShapeAndIngredients,
+	WithResult,
+	WithShape,
+	World$1 as World,
+};