bloxd-types 0.1.0

package/types/@bloxd/index.d.ts

@@ -0,0 +1,4003 @@
+export interface GameApi {
+		/** The ID of the player running the code.
+		 *
+		 * Lobby code usually has nobody running it, so this is null.
+		 */
+		myId: string | null
+		/** The position of the code block or press to code board */
+		thisPos: [number, number, number]
+		/** The owner of the current custom lobby */
+		lobbyOwnerId: string | null
+		/**
+ * Get position of a player / entity.
+ * @param entityId
+ */
+getPosition(entityId: EntityId): Pos
+/**
+ * Set position of a player / entity.
+ * @param entityId
+ * @param x Can also be an array, in which case y and z shouldn't be passed
+ * @param y
+ * @param z
+ */
+setPosition(entityId: EntityId, x: number | number[], y?: number, z?: number): void
+/**
+ * Get the scale of a lifeform.
+ * @param lifeformId
+ */
+getLifeformScale(lifeformId: LifeformId): number
+/**
+ * Set the visual + physical scale of a lifeform. A scale of 1 is the default size,
+ *
+ * @param lifeformId
+ * @param scale Must be a finite positive number.
+ */
+setLifeformScale(lifeformId: LifeformId, scale: number): void
+/**
+ * Get all the player ids.
+ */
+getPlayerIds(): PlayerId[]
+/**
+ * Whether a player is currently in the game
+ *
+ * @param playerId
+ */
+playerIsInGame(playerId: PlayerId): boolean
+/**
+ * @param playerId
+ * @returns
+ */
+playerIsLoggedIn(playerId: PlayerId): boolean
+/**
+ * Returns the party that the player was in when they joined the game. The returned object contains the playerDbIds, as well
+ * as the playerIds if available, of the party leader and members.
+ *
+ * @param playerId
+ * @returns
+ */
+getPlayerPartyWhenJoined(playerId: PlayerId): PNull<{ partyCode: string; playerDbIds: PlayerDbId[] }>
+/**
+ * Get the number of players in the room
+ */
+getNumPlayers(): number
+/**
+ * Get the co-ordinates of the blocks the player is standing on as a list. For example, if the center of the player is at 0,0,0
+ * this function will return [[0, -1, 0], [-1, -1, 0], [0, -1, -1], [-1, -1, -1]]
+ * If the player is just standing on one block, the function would return e.g. [[0, 0, 0]]
+ * If the player is middair then returns an empty list [].
+ *
+ * @param playerId
+ */
+getBlockCoordinatesPlayerStandingOn(playerId: PlayerId): number[][]
+/**
+ * Get the types of block the player is standing on
+ * For example, if a player is standing on 4 dirt blocks, this will return ["Dirt", "Dirt", "Dirt", "Dirt"]
+ * @param playerId
+ */
+getBlockTypesPlayerStandingOn(playerId: PlayerId): any[]
+/**
+ * Get the up to 12 unit co-ordinates the lifeform is located within
+ * (A lifeform is modelled as having four corners and can be in up to 3 blocks vertically)
+ *
+ * @param lifeformId
+ * @returns List of x, y, z positions e.g. [[-1, 0, 0], [-1, 1, 0], [-1, 2, 0]]
+ */
+getUnitCoordinatesLifeformWithin(lifeformId: LifeformId): number[][]
+/**
+ * Show the shop tutorial for a player. Will not be shown if they have ever seen the shop tutorial in your game before.
+ * @param playerId
+ */
+showShopTutorial(playerId: PlayerId): void
+/**
+ * Get the current shield of an entity.
+ * @param entityId
+ */
+getShieldAmount(entityId: EntityId): number
+/**
+ * Set the current shield of a lifeform.
+ *
+ * @param lifeformId
+ * @param newShieldAmount
+ */
+setShieldAmount(lifeformId: LifeformId, newShieldAmount: number): void
+/**
+ * Get the current health of an entity.
+ * @param entityId
+ */
+getHealth(entityId: PlayerId): number
+/**
+ * @param lifeformId
+ * @param changeAmount Must be an integer. A positive amount will increase the entity's health. A negative amount will decrease the entity's shield first, then their health.
+ * @param whoDidDamage Optional - If damage done by another player
+ * @param broadcastLifeformHurt
+ *
+ * @return Whether the entity was killed
+ */
+applyHealthChange(lifeformId: LifeformId, changeAmount: number, whoDidDamage?: LifeformId | { lifeformId: LifeformId; withItem: string }, broadcastLifeformHurt?: boolean): boolean
+/**
+ * Set the current health of an entity.
+ * If you want to set their health to more than their current max health, the optional increaseMaxHealthIfNeeded must be true.
+ *
+ * @param entityId
+ * @param newHealth Can be null to make the player not have health
+ * @param whoDidDamage Optional
+ * @param increaseMaxHealthIfNeeded Optional
+ *
+ * @return Whether this change in health killed the player
+ */
+setHealth(entityId: EntityId, newHealth: PNull<number>, whoDidDamage?: LifeformId | { lifeformId: LifeformId; withItem: string }, increaseMaxHealthIfNeeded?: boolean): boolean
+/**
+ * Make it as if hittingEId hit hitEId
+ *
+ * @param hittingEId
+ * @param hitEId
+ * @param dirFacing
+ * @param bodyPartHit
+ * @param overrides
+ * @returns whether the attack damaged the lifeform
+ */
+applyMeleeHit(hittingEId: LifeformId, hitEId: LifeformId, dirFacing: number[], bodyPartHit?: PNull<LifeformBodyPart>, overrides?: { damage?: PNull<number>; heldItemName?: PNull<string>; horizontalKbMultiplier?: number; verticalKbMultiplier?: number; }): boolean
+/**
+ * Apply damage to a lifeform.
+ * eId is the player initiating the damage, hitEId is the lifeform being hit.
+ *
+ * It is recommended to self-inflict damage when the game code wants to apply damage to a lifeform.
+ *
+ * @param eId
+ * @param hitEId
+ * @param attemptedDmgAmt
+ * @param withItem
+ * @param bodyPartHit
+ * @param attackDir
+ * @param showCritParticles
+ * @param reduceVerticalKbVelocity
+ * @param horizontalKbMultiplier
+ * @param verticalKbMultiplier
+ * @param broadcastEntityHurt
+ * @param attackCooldownSettings
+ * @param hittingSoundOverride
+ * @param ignoreOtherEntitySettingCanAttack
+ * @param isTrueDamage
+ * @param damagerDbId
+ *
+ * @returns whether the attack damaged the lifeform
+ */
+attemptApplyDamage({
+		eId,
+		hitEId,
+		attemptedDmgAmt,
+		withItem,
+		bodyPartHit,
+		attackDir,
+		showCritParticles,
+		reduceVerticalKbVelocity,
+		horizontalKbMultiplier,
+		verticalKbMultiplier,
+		broadcastEntityHurt,
+		attackCooldownSettings,
+		hittingSoundOverride,
+		ignoreOtherEntitySettingCanAttack,
+		isTrueDamage,
+		damagerDbId,
+	}: PlayerAttemptDamageOtherPlayerOpts): boolean
+/**
+ * Create enchantment attributes for an item at a given enchantment level. Same behaviour as if that level of enchant was selected for the item in an enchanting table.
+ * @param itemName
+ * @param enchantmentLevel
+ */
+createEnchantmentAttributesForItem(itemName: ItemName, enchantmentLevel: number): EnchantmentAttributes
+/**
+ * Force respawn a player
+ * @param playerId
+ * @param respawnPos
+ */
+forceRespawn(playerId: PlayerId, respawnPos?: number[]): void
+/**
+ * Kill a lifeform.
+ * @param lifeformId
+ * @param whoKilled Optional
+ */
+killLifeform(lifeformId: LifeformId, whoKilled?: LifeformId | { lifeformId: LifeformId; withItem: string }): void
+/**
+ * Gets the player's current killstreak
+ *
+ * @param playerId
+ * @returns
+ */
+getCurrentKillstreak(playerId: PlayerId): number
+/**
+ * Clears the player's current killstreak
+ *
+ * @param playerId
+ */
+clearKillstreak(playerId: PlayerId): void
+/**
+ * Whether a lifeform is alive or dead (or on the respawn screen, in a player's case).
+ *
+ * @param lifeformId
+ * @returns
+ */
+isAlive(lifeformId: LifeformId): boolean
+/**
+ * Send a message to everyone
+ *
+ * @param message The text contained within the message. Can use \`Custom Text Styling\`.
+ * @param style An optional style argument. Can contain values for fontWeight and color of the message.
+ *          style is ignored if message uses custom text styling (i.e. is not a string).
+ */
+broadcastMessage(message: string | CustomTextStyling, style?: { fontWeight?: number | string; color?: string; colour?: string }): void
+/**
+ * Send a message to a specific player
+ *
+ * @param playerId Id of the player
+ * @param message The text contained within the message. Can use \`Custom Text Styling\`.
+ * @param style An optional style argument. Can contain values for fontWeight and color of the message.
+ *              style is ignored if message uses custom text styling (i.e. is not a string).
+ */
+sendMessage(playerId: PlayerId, message: string | CustomTextStyling, style?: { fontWeight?: number | string; color?: string }): void
+/**
+ * Send a flying middle message to a specific player
+ *
+ * @param playerId Id of the player
+ * @param message The text contained within the message. Can be either a string or use \`Custom Text Styling\`.
+ * @param distanceFromAction The distance from the action that has caused this message to be displayed,
+ *                           this value will be used to determine how the message flies across the screen.
+ * @param lifetimeMs How long the message will be visible in milliseconds. Defaults to 1000ms.
+ */
+sendFlyingMiddleMessage(playerId: PlayerId, message: string | CustomTextStyling, distanceFromAction: number, lifetimeMs?: number): void
+/**
+ * Modify a client option at runtime and send to the client if it changed
+ *
+ * @param playerId
+ * @param option The name of the option
+ * @param value The new value of the option
+ */
+setClientOption<PassedOption extends ClientOption>(playerId: PlayerId, option: PassedOption, value: ClientOptions[PassedOption]): void
+/**
+ * Returns the current value of a client option
+ *
+ * @param playerId
+ * @param option
+ */
+getClientOption<PassedOption extends ClientOption>(playerId: PlayerId, option: PassedOption): ClientOptions[PassedOption]
+/**
+ * Create a new shop item under the given category.
+ * Will create a new category if it does not exist.
+ * If the shop item already exists then it will be replaced.
+ * If any per-player overrides exist under the same categoryKey and itemKey then they will be deleted.
+ *
+ * @param categoryKey - The key of the category to create the item in
+ * @param itemKey - The unique key for the item
+ * @param item - The shop item to create (will be mutated)
+ */
+createShopItem(categoryKey: ShopCategoryKey, itemKey: ShopItemKey, item: ShopItem): void
+/**
+ * Update selected properties of an existing shop item.
+ * For example, { canBuy: true } to allow players to purchase the item.
+ * Throws an error if the item does not exist.
+ *
+ * @param categoryKey - The key of the category containing the item
+ * @param itemKey - The unique key for the item
+ * @param changes - Partial shop item properties to update
+ */
+updateShopItem(categoryKey: ShopCategoryKey, itemKey: ShopItemKey, changes: Partial<ShopItem>): void
+/**
+ * Delete an existing shop item.
+ * Throws an error if the item does not exist.
+ * Will also delete all per-player overrides for the shop item.
+ *
+ * @param categoryKey - The key of the category containing the item
+ * @param itemKey - The unique key for the item
+ */
+deleteShopItem(categoryKey: ShopCategoryKey, itemKey: ShopItemKey): void
+/**
+ * Set properties of a shop category.
+ *
+ * @param categoryKey - The key of the category to configure
+ * @param config - Category configuration properties
+ */
+configureShopCategory(categoryKey: ShopCategoryKey, config: ShopCategoryConfig): void
+/**
+ * Create a new shop item for a specific player.
+ * Will create a new category if it does not exist.
+ * Will replace any overrides this player already has for the same item.
+ *
+ * @param playerId - The player to create the item for
+ * @param categoryKey - The key of the category to create the item in
+ * @param itemKey - The unique key for the item
+ * @param item - The shop item to create (will be mutated)
+ */
+createShopItemForPlayer(playerId: PlayerId, categoryKey: ShopCategoryKey, itemKey: ShopItemKey, item: ShopItem): void
+/**
+ * Update selected properties of an existing shop item for a specific player.
+ * For example, { canBuy: true } to allow this player to purchase the item.
+ * Throws an error if the item does not exist.
+ *
+ * @param playerId - The player to update the item for
+ * @param categoryKey - The key of the category containing the item
+ * @param itemKey - The unique key for the item
+ * @param changes - Partial shop item properties to update
+ */
+updateShopItemForPlayer(playerId: PlayerId, categoryKey: ShopCategoryKey, itemKey: ShopItemKey, changes: Partial<ShopItem>): void
+/**
+ * Delete a specific player's overrides for a shop item.
+ * Like other methods, it doesn't matter whether the overrides were created
+ * using createShopItemForPlayer or by using updateShopItemForPlayer instead.
+ * This method does nothing if the overrides don't exist or are defined internally by the engine.
+ *
+ * @param playerId - The player to reset the item for
+ * @param categoryKey - The key of the category containing the item
+ * @param itemKey - The unique key for the item
+ */
+resetShopItemForPlayer(playerId: PlayerId, categoryKey: ShopCategoryKey, itemKey: ShopItemKey): void
+/**
+ * Configure a shop category for a specific player.
+ *
+ * @param playerId - The player to configure the category for
+ * @param categoryKey - The key of the category to configure
+ * @param config - Category configuration properties
+ */
+configureShopCategoryForPlayer(playerId: PlayerId, categoryKey: ShopCategoryKey, config: ShopCategoryConfig): void
+/**
+ * Modify client options at runtime
+ *
+ * @param playerId
+ * @param optionsObj An object which contains key value pairs of new settings. E.g {canChange: true, speedMultiplier: false}
+ */
+setClientOptions(playerId: PlayerId, optionsObj: Partial<ClientOptions>): void
+/**
+ * Sets a client option to its default value. This will be the value stored in your game's defaultClientOptions, otherwise Bloxd's default.
+ *
+ * @param playerId
+ * @param option
+ */
+setClientOptionToDefault(playerId: PlayerId, option: ClientOption): void
+/**
+ * Set every player's other-entity setting to a specific value for a particular player.
+ * includeNewJoiners=true means that new players joining the game will also have this other player setting applied.
+ *
+ * @param targetedPlayerId
+ * @param settingName
+ * @param settingValue
+ * @param includeNewJoiners
+ */
+setTargetedPlayerSettingForEveryone<Setting extends OtherEntitySetting>(targetedPlayerId: PlayerId, settingName: Setting, settingValue: OtherEntitySettings[Setting], includeNewJoiners?: boolean): void
+/**
+ * Set a player's other-entity setting for every lifeform in the game.
+ * includeNewJoiners=true means that the player will have the setting applied to new joiners.
+ *
+ * @param playerId
+ * @param settingName
+ * @param settingValue
+ * @param includeNewJoiners
+ */
+setEveryoneSettingForPlayer<Setting extends OtherEntitySetting>(playerId: PlayerId, settingName: Setting, settingValue: OtherEntitySettings[Setting], includeNewJoiners?: boolean): void
+/**
+ * Set a player's other-entity setting for a specific entity.
+ *
+ * @param relevantPlayerId
+ * @param targetedEntityId
+ * @param settingName
+ * @param settingValue
+ */
+setOtherEntitySetting<Setting extends OtherEntitySetting>(relevantPlayerId: PlayerId, targetedEntityId: EntityId, settingName: Setting, settingValue: OtherEntitySettings[Setting]): void
+/**
+ * Set many of a player's other-entity settings for a specific entity.
+ *
+ * @param relevantPlayerId
+ * @param targetedEntityId
+ * @param settingsObject
+ */
+setOtherEntitySettings(relevantPlayerId: PlayerId, targetedEntityId: EntityId, settingsObject: Partial<OtherEntitySettings>): void
+/**
+ * Get the value of a player's other-entity setting for a specific entity.
+ *
+ * @param relevantPlayerId
+ * @param targetedEntityId
+ * @param settingName
+ */
+getOtherEntitySetting<Setting extends OtherEntitySetting>(relevantPlayerId: PlayerId, targetedEntityId: EntityId, settingName: Setting): OtherEntitySettings[Setting]
+/**
+ * Reset a player's other-entity setting for a specific entity to the game's default value.
+ *
+ * @param relevantPlayerId
+ * @param targetedEntityId
+ * @param settingName
+ */
+setOtherEntitySettingToDefault<Setting extends OtherEntitySetting>(relevantPlayerId: PlayerId, targetedEntityId: EntityId, settingName: Setting): void
+/**
+ * Play particle effect on all clients, or only on some clients if clientPredictedBy is specified
+ * @param opts
+ * @param clientPredictedBy Play only on clients where client with playerId clientPredictedBy
+ *                          is not invisible, transparent, or themselves
+ */
+playParticleEffect(opts: TempParticleSystemOpts | ParticlePresetOpts, clientPredictedBy?: PlayerId): void
+/**
+ * Animates the given entity. Pass \`null\` for \`animationSchema\` to stop the entity's current animation (the
+ * \`initialTimeFraction\` and \`animationSpeed\` arguments are ignored in that case).
+ * @param entityId
+ * @param animationSchema
+ * @param initialTimeFraction
+ * @param animationSpeed
+ */
+animateEntity(entityId: EntityId, animationSchema: AnimationSchema | BlockbenchAnimationSchema | null, initialTimeFraction?: number, animationSpeed?: number): void
+/**
+ * Get the in game name of an entity.
+ * @param entityId
+ */
+getEntityName(entityId: EntityId): string
+/**
+ * Given the name of a player, get their id
+ * @param playerName
+ */
+getPlayerId(playerName: string): PNull<PlayerId>
+/**
+ * Given a player, get their permanent identifier that doesn't change when leaving and re-entering
+ *
+ * @param playerId
+ */
+getPlayerDbId(playerId: PlayerId): PlayerDbId
+/**
+ * Returns null if player not in lobby
+ *
+ * @param dbId
+ */
+getPlayerIdFromDbId(dbId: PlayerDbId): PNull<PlayerId>
+/**
+ * Gets the persistent database ID for the given mob.
+ * This can be useful for reasoning about mobs that have been loaded from the database, such as owned mobs.
+ *
+ * @param mobId - The ID of the mob from spawnMob
+ * @returns The persistent database ID for the mob, or null if the mob is not persistent
+ */
+getMobDbId(mobId: MobId): PNull<MobDbId>
+
+kickPlayer(playerId: PlayerId, reason: string): void
+/**
+ * Check if the block at a specific position is in a loaded chunk.
+ * @param x
+ * @param y
+ * @param z
+ * @return boolean
+ */
+isBlockInLoadedChunk(x: number, y: number, z: number): boolean
+/**
+ * Get the name of a block.
+ * @param x could be an array [x, y, z]. If so, the other params shouldn't be passed.
+ * @param y
+ * @param z
+ * @return blockName - any block name, including 'Air'
+ */
+getBlock(x: number | number[], y?: number, z?: number): BlockName
+/**
+ * Used to get the block id at a specific position.
+ * Intended only for use in hot code paths - default to getBlock for most use cases
+ *
+ * @param x
+ * @param y
+ * @param z
+ */
+getBlockId(x: number, y: number, z: number): BlockId
+/**
+ * Set a block. Valid names are any block name, including 'Air'
+ *
+ * This function is optimised for setting broad swathes of blocks. For example, if you have a 50x50x50 area you need to turn to air, it will run performantly if you call this in double nested loops.
+ *
+ * IF you're only changing a few blocks, you want this to be super snappy for players, AND you're calling this outside of your _tick function, you can use api.setOptimisations(false).
+ *
+ * If you want the optimisations for large quantities of blocks later on, then call api.setOptimisations(true) when you're done.
+ *
+ *
+ *
+ * @param x Can be an array
+ * @param y Should be blockname if first param is array
+ * @param z
+ * @param blockName
+ */
+setBlock(x: number | number[], y: number | BlockName, z?: number, blockName?: BlockName): void
+/**
+ * Initiate a block change "by the world".
+ * This ends up calling the onWorldChangeBlock and only makes the change if not prevented by game/plugins.
+ * initiatorDbId is null if the change was initiated by the game code.
+ *
+ * @param initiatorDbId
+ * @param x
+ * @param y
+ * @param z
+ * @param blockName
+ * @param extraInfo
+ *
+ * @returns "preventChange" if the change was prevented, "preventDrop" if the change was allowed but without dropping any items, and undefined if the change was allowed with an item drop
+ */
+attemptWorldChangeBlock(initiatorDbId: PNull<PlayerDbId>, x: number, y: number, z: number, blockName: BlockName, extraInfo?: WorldBlockChangedInfo): "preventChange" | "preventDrop" | void
+/**
+ * Returns whether a block is solid or not.
+ * E.g. Grass block is solid, while water, ladder and water are not.
+ * Will be true if the block is unloaded.
+ *
+ * @param x
+ * @param y
+ * @param z
+ */
+getBlockSolidity(x: number | number[], y?: number, z?: number): boolean
+/**
+ * Helper function that sets all blocks in a rectangle to a specific block.
+ *
+ * @param pos1 array [x, y, z]
+ * @param pos2 array [x, y, z]
+ * @param blockName
+ */
+setBlockRect(pos1: number[], pos2: number[], blockName: BlockName): void
+/**
+ * Create walls by providing two opposite corners of the cuboid
+ *
+ *
+ * @param pos1 array [x, y, z]
+ * @param pos2 array [x, y, z]
+ * @param blockName
+ * @param hasFloor
+ * @param hasCeiling
+ */
+setBlockWalls(pos1: number[], pos2: number[], blockName: BlockName, hasFloor?: boolean, hasCeiling?: boolean): void
+/**
+ * Copies chunk from one position to another.
+ * A good use case for this is storing 'template' chunks that can be continuously copied to a new position.
+ * In order to reset an area to the template, e.g. resetting a session-based game.
+ *
+ * NOTE: Does nothing if the source chunk is not loaded.
+ *
+ * @param fromPos - A block coordinate within the chunk to copy from.
+ * @param toPos - A block coordinate within the chunk to copy to.
+ */
+copyChunk(fromPos: number[], toPos: number[]): void
+/**
+ * Use this to get a chunk ndarray you can edit and set in resetChunk.
+ *
+ * Only use chunk helpers if you REALLY need the performance (i.e. you are iterating over tens of thousands of blocks)
+ * ReturnedObject.blockData is a 32x32x32 ndarray of air.
+ * (see https://www.npmjs.com/package/ndarray)
+ * Each block id is a 16-bit number
+ */
+getEmptyChunk(): GameChunk
+/**
+ * Splits the block name by '|'. If no meta info, metaInfo is ''
+ *
+ * @param blockName
+ */
+getMetaInfo(blockName: BlockName | null | undefined): ItemMetaInfo
+/**
+ * Get the numeric id of a block used in the ndarrays returned from getChunk
+ * I.e. chunk.blockData.set(x, y, z, api.blockNameToBlockId("Dirt"))
+ * or chunk.blockData.get(x, y, z) === api.blockNameToBlockId("Dirt")
+ *
+ * @param blockName
+ * @param allowInvalidBlock Don't throw an error if the block name is invalid.
+ * Defaults false. If true and name is invalid, returns null.
+ * @returns
+ */
+blockNameToBlockId(blockName: BlockName, allowInvalidBlock?: boolean): PNull<number>
+/**
+ * Goes from block id to block name. The reverse of blockNameToBlockId
+ *
+ * @param blockId
+ */
+blockIdToBlockName(blockId: BlockId): BlockName
+/**
+ * Get the unique id of the chunk containing pos in the current map
+ *
+ * @param pos
+ */
+blockCoordToChunkId(pos: number[]): string
+/**
+ * Get the co-ordinates of the block in the chunk with the lowest x, y, and z co-ordinates
+ *
+ * @param chunkId
+ */
+chunkIdToBotLeftCoord(chunkId: string): [number, number, number]
+/**
+ * @deprecated - prefer using other UI elements
+ * (this UI element hasn't been properly thought through in combination with other elements like killfeed, uirequests, etc)
+ *
+ * Send a player an icon in the top right corner
+ *
+ * @param playerId
+ * @param icon Can be any icon from font-awesome.
+ * @param text The text to send.
+ * @param opts Can include keys duration, width, height, color, iconSizeMult.
+ *
+ * Default opts: {
+ *  duration: 8, // seconds
+ *  width: 400px,
+ *  height: 100px,
+ *  color: 'rgb(102, 102, 102)', // must be rgb in this format (hex not supported),
+ *  iconSizeMult: 5,
+ *  textAndIconColor: "white", // can be any colour supported by css (e.g. hex, rgb),
+ *  fontSize: '17px',
+ * }
+ */
+sendTopRightHelper(playerId: PlayerId, icon: string, text: string, opts: { duration?: number; width?: number; height?: number; color?: string; iconSizeMult?: number; textAndIconColor?: string; fontSize?: string; }): void
+/**
+ * Whether the player is on a mobile device or a computer.
+ * @param playerId
+ */
+isMobile(playerId: PlayerId): boolean
+/**
+ * Get the amount of a given currency a player has.
+ * @param playerId
+ * @param currencyId
+ * @returns The amount of the currency, or null if the currency is not defined.
+ */
+getCurrencyAmount(playerId: PlayerId, currencyId: string): PNull<number>
+/**
+ * Create a dropped item.
+ * @param x
+ * @param y
+ * @param z
+ * @param itemName Name of the item. Any item name, including blocks and 'Air'
+ * @param amount The amount of the item in the drop. Defaults to 1 when omitted. Use 0 for a collect-only trigger that does not add to inventory (fires onPlayerPickedUpItem with itemAmount 0).
+ * @param mergeItems Whether to merge the item into a nearby item of same type, if one exists. Defaults to false.
+ * @param attributes Attributes of the item being dropped
+ * @param timeTillDespawn Time till the item automatically despawns in milliseconds. Defaults to 5 mins, max of 1 hour.
+ * @param dropperId Who dropped the item.
+ * @param options Additional options, such as doPhysics and size.
+ * @returns the id you can pass to setCantPickUpItem, or null if the item drop limit was reached
+ */
+createItemDrop(x: number, y: number, z: number, itemName: ItemName, amount?: PNull<number>, mergeItems?: boolean, attributes?: ItemAttributes, timeTillDespawn?: number, dropperId?: PNull<LifeformId>, options?: ItemDropOptions): PNull<EntityId>
+/**
+ * Prevent a player from picking up an item. itemId returned by createItemDrop
+ *
+ * @param playerId
+ * @param itemId
+ */
+setCantPickUpItem(playerId: PlayerId, itemId: EntityId): void
+/**
+ * Reset a player's ability to pick up an item. itemId returned by createItemDrop
+ *
+ * @param playerId
+ * @param itemId
+ */
+resetCanPickUpItem(playerId: PlayerId, itemId: EntityId): void
+/**
+ * Delete an item drop by item drop entity ID
+ *
+ * @param itemId
+ */
+deleteItemDrop(itemId: EntityId): void
+/**
+ * Create an invisible audio entity at a world position that loops a sound to
+ * nearby players (e.g. a jukebox or fireplace).
+ *
+ * Audio entities count against the same budget as physics-less mesh entities; returns null
+ * if that budget is exhausted.
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param soundName The sound to loop.
+ * @param volume
+ * @param options {refDistance: number, maxHearDist: number, rate: number}
+ * refDistance: higher means the sound decreases less in volume with distance. Defaults to 3. Hitting is 4. Guns are 10
+ * maxHearDist: sound is not played if player is further than this. Defaults to 30
+ * rate: The speed of playback. Also affects pitch. 0.5-4. Lower playback = lower pitch. Good for varying the sound.
+ * E.g. item pickup sound has a random rate between 1 and 1.5.
+ * @returns the audio entity ID, or null if the entity budget is exhausted
+ */
+attemptCreateAudioEntity(x: number, y: number, z: number, soundName: string, volume?: number, options?: { refDistance?: number; maxHearDist?: number; rate?: number; }): PNull<EntityId>
+/**
+ * Update an audio entity's config (sound, volume, falloff, rate). Only the provided fields
+ * change.
+ *
+ * @param eId
+ * @param opts Any subset of soundName, volume, refDistance, maxHearDist, rate.
+ */
+updateAudioEntity(eId: EntityId, opts: Partial<AudioEntityOpts>): void
+/**
+ * Delete an audio entity by its entity ID (returned by attemptCreateAudioEntity).
+ *
+ * @param eId
+ */
+deleteAudioEntity(eId: EntityId): void
+/**
+ * Returns all items overlapping with the given player
+ *
+ * @param playerId
+ * @returns the overlapping item entity IDs
+ */
+getItemIDsOverlappingWithPlayer(playerId: PlayerId): EntityId[]
+/**
+ * Get the metadata about a block or item before stats have been modified by any client options
+ * (i.e. its entry in the initial metadata object)
+ *
+ * @param itemName
+ */
+getInitialItemMetadata(itemName: string): Partial<BlockMetadataItem & NonBlockMetadataItem>
+/**
+ * Get stat info about a block or item
+ * Either based on a client option for a player: (e.g. \`DirtTtb\`)
+ * or its entry in the initial metadata object if no client option is set.
+ *
+ * If null is passed for lifeformId, this is simply its entry in blockMetadata etc.
+ *
+ *
+ * @param lifeformId
+ * @param itemName
+ * @param stat
+ */
+getItemStat<K extends keyof AnyMetadataItem>(lifeformId: PNull<LifeformId>, itemName: ItemName, stat: K): AnyMetadataItem[K]
+/**
+ * Set a stat attribute for a block or item
+ *
+ * NOTE: Only a subset of stats are customisable this way.
+ *
+ * @param playerId
+ * @param itemName
+ * @param stat
+ * @param value
+ */
+setItemStat<K extends CustomItemStat>(playerId: PlayerId, itemName: ItemName, stat: K, value: AnyMetadataItem[K]): void
+/**
+ * Set the direction the player is looking.
+ *
+ * @param playerId
+ * @param direction a vector of the direction to look, format [x, y, z]
+ */
+setCameraDirection(playerId: PlayerId, direction: number[]): void
+/**
+ * Shake a player's camera.
+ *
+ * @param playerId
+ * @param intensity Shake "power" (0..1); the client clamps the accumulated power to 1.
+ * @param durationMs How long the shake lasts, in milliseconds.
+ */
+shakePlayerCamera(playerId: PlayerId, intensity: number, durationMs?: number): void
+/**
+ * Set a player's opacity
+ * A simple helper that calls setTargetedPlayerSettingForEveryone
+ *
+ * @param playerId
+ * @param opacity
+ */
+setPlayerOpacity(playerId: PlayerId, opacity: number): void
+/**
+ * Set the level of viewable opacity by one player on another player
+ * A simple helper that calls setOtherEntitySetting
+ *
+ * @param playerIdWhoViewsOpacityPlayer The player who sees that with opacity
+ * @param playerIdOfOpacityPlayer The player/player model who is given opacity
+ * @param opacity
+ */
+setPlayerOpacityForOnePlayer(playerIdWhoViewsOpacityPlayer: PlayerId, playerIdOfOpacityPlayer: PlayerId, opacity: number): void
+/**
+ * Obtain Date.now() value saved at start of current game tick
+ */
+now(): number
+/**
+ * Check your game (and, optionally, a entity) is still valid and executing.
+ * Useful if you're using async functions and await within your game.
+ * If you use await/async or promises and do not check this, your game could have closed and then the rest of your
+ * async code executes.
+ *
+ * @param entityId
+ */
+checkValid(entityId?: PNull<EntityId>): boolean
+/**
+ * Let a player change a block at a specific co-ordinate. Useful when client option canChange is false.
+ * Overrides blockRect and blockType settings, so also useful when you have disallowed changing of a block type with setCantChangeBlockType.
+ * Using this on 1000s of blocks will cause lag - if that is needed, find a way to use setCanChangeBlockType.
+ *
+ * @param playerId
+ * @param x
+ * @param y
+ * @param z
+ */
+setCanChangeBlock(playerId: PlayerId, x: number, y: number, z: number): void
+/**
+ * Prevents a player from changing a block at a specific co-ordinate. Useful when client option canChange is true.
+ * Overrides blockRect and blockType settings, so also useful when you have allowed changing of a block type with setCantChangeBlockType.
+ * Using this on 1000s of blocks will cause lag - if that is needed, find a way to use setCantChangeBlockType.
+ *
+ * @param playerId
+ * @param x
+ * @param y
+ * @param z
+ */
+setCantChangeBlock(playerId: PlayerId, x: number, y: number, z: number): void
+/**
+ * Remove any previous can/cant change block settings for a player at a specific co-ordinate
+ *
+ * @param playerId
+ * @param x
+ * @param y
+ * @param z
+ */
+resetCanChangeBlock(playerId: PlayerId, x: number, y: number, z: number): void
+/**
+ * Lets a player Change a block type. Valid names are any block name, including 'Air'
+ * Less priority than cant change block pos/can change block rect
+ *
+ * @param playerId
+ * @param blockName
+ */
+setCanChangeBlockType(playerId: PlayerId, blockName: BlockName): void
+/**
+ * Stops a player from changing a block type. Valid names are any block name, including 'Air'
+ * Less priority than can change block pos/can change block rect
+ *
+ * @param playerId
+ * @param blockName
+ */
+setCantChangeBlockType(playerId: PlayerId, blockName: BlockName): void
+/**
+ * Remove any previous can/cant change block type settings for a player
+ *
+ * @param playerId
+ * @param blockName
+ */
+resetCanChangeBlockType(playerId: PlayerId, blockName: BlockName): void
+/**
+ * Make it so a player can Change blocks within two points. Coordinates are inclusive. E.g. if [0, 0, 0] is pos1
+ * and [1, 1, 1] is pos2 then the 8 blocks contained within low and high will be able to be broken.
+ * Overrides setCantChangeBlockType
+ *
+ *
+ * @param playerId
+ * @param pos1 Arg as [x, y, z]
+ * @param pos2 Arg as [x, y, z]
+ */
+setCanChangeBlockRect(playerId: PlayerId, pos1: number[], pos2: number[]): void
+/**
+ * Make it so a player cant Change blocks within two points. Coordinates are inclusive. E.g. if [0, 0, 0] is pos1
+ * and [1, 1, 1] is pos2 then the 8 blocks contained within pos1 and pos2 won't be able to be broken.
+ * Overrides setCanChangeBlockType
+ *
+ *
+ * @param playerId
+ * @param pos1 Arg as [x, y, z]
+ * @param pos2 Arg as [x, y, z]
+ */
+setCantChangeBlockRect(playerId: PlayerId, pos1: number[], pos2: number[]): void
+/**
+ * Remove any previous can/cant change block rect settings for a player
+ *
+ * @param playerId
+ * @param pos1
+ * @param pos2
+ */
+resetCanChangeBlockRect(playerId: PlayerId, pos1: number[], pos2: number[]): void
+/**
+ * Allow a player to walk through a type of block. For blocks that are normally solid and not seethrough, the player will experience slight visual glitches while inside the block.
+ *
+ *
+ * @param playerId
+ * @param blockName
+ * @param disable If you've enabled a player to walk through a block and want to make the block solid for them again, pass this with true. Otherwise you only need to pass playerId and blockName
+ */
+setWalkThroughType(playerId: PlayerId, blockName: BlockName, disable?: boolean): void
+/**
+ * Allow a player to walk through (or not walk through) voxels that are located within a given rectangle.
+ * For blocks that are normally solid and not seethrough, the player will experience slight visual glitches while inside the block.
+ *
+ * You could set both pos1 and pos2 to [0, 0, 0] to make only 0, 0, 0 walkthrough, for example.
+ *
+ * @param playerId
+ * @param pos1 The one corner of the cuboid. Format [x, y, z]
+ * @param pos2 The top right corner of the cuboid. Format [x, y, z]
+ * @param updateType The type of update. Whether to make a rect solid, or able to be walked through.
+ * Pass DEFAULT_WALK_THROUGH with a previously passed rect to disable any walkthrough setting for that rect.
+ *
+ */
+setWalkThroughRect(playerId: PlayerId, pos1: number[], pos2: number[], updateType: WalkThroughType): void
+/**
+ * Give a player an item and a certain amount of that item.
+ * Returns the amount of item added to the users inventory.
+ *
+ * @param playerId
+ * @param itemName
+ * @param itemAmount
+ * @param attributes An optional object for certain types of item. For guns this can contain the shotsLeft field which is the amount of ammo the gun currently has.
+ */
+giveItem(playerId: PlayerId, itemName: ItemName, itemAmount?: number, attributes?: ItemAttributes): number
+/**
+ * Whether the player has space in their inventory to get new blocks
+ * @param playerId
+ */
+inventoryIsFull(playerId: PlayerId): boolean
+/**
+ * Put an item in a specific index. Default hotbar is indexes 0-9
+ *
+ * @param playerId
+ * @param itemSlotIndex 0-indexed
+ * @param itemName Can be 'Air', in which case itemAmount will be ignored and the slot will be cleared.
+ * @param itemAmount -1 for infinity. Should not be set, or null, for items that are not stackable.
+ * @param attributes An optional object for certain types of item. For guns this can contain the shotsLeft field which is the amount of ammo the gun currently has.
+ * @param tellClient whether to tell client about it - results in desync between client and server if client doesnt locally perform the same action
+ */
+setItemSlot(playerId: PlayerId, itemSlotIndex: number, itemName: ItemName, itemAmount?: PNull<number>, attributes?: ItemAttributes, tellClient?: boolean): void
+/**
+ * Remove an amount of item from a player's inventory
+ *
+ * @param playerId
+ * @param itemName
+ * @param amount
+ */
+removeItemName(playerId: PlayerId, itemName: ItemName, amount: number): void
+/**
+ * Get the item at a specific index
+ * Returns null if there is no item at that index
+ * If there is an item, return an object of the format { name: string; amount: PNull<number>; attributes: ItemAttributes; }
+ *
+ * @param playerId
+ * @param itemSlotIndex
+ */
+getItemSlot(playerId: PlayerId, itemSlotIndex: number): PNull<InvenItem>
+/**
+ * Finds the index of a particular item in a player's inventory.
+ *
+ * @param playerId
+ * @param itemName
+ * @return The index of the item in the player's inventory, or null if the item is not found.
+ */
+findItem(playerId: PlayerId, itemName: ItemName): PNull<number>
+/**
+ * Whether a player has an item
+ *
+ * @param playerId
+ * @param itemName
+ * @returns bool
+ */
+hasItem(playerId: PlayerId, itemName: ItemName): boolean
+/**
+ * The amount of an itemName a player has.
+ * Returns 0 if the player has none, and a negative number if infinite.
+ *
+ * @param playerId
+ * @param itemName
+ * @returns number
+ */
+getInventoryItemAmount(playerId: PlayerId, itemName: ItemName): number
+/**
+ * Clear the players inventory
+ *
+ * @param playerId
+ */
+clearInventory(playerId: PlayerId): void
+/**
+ * Force the player to have the ith inventory slot selected. E.g. newI 0 makes the player have the 0th inventory slot selected
+ *
+ * @param playerId
+ * @param newI integer from 0-9
+ */
+setSelectedInventorySlotI(playerId: PlayerId, newI: number): void
+/**
+ * Get a player's currently selected inventory slot
+ * @param playerId
+ * @returns
+ */
+getSelectedInventorySlotI(playerId: PlayerId): number
+/**
+ * Get the currently held item of a player
+ * Returns null if no item is being held
+ * If an item is held, return an object of the format {name: itemName, amount: amountOfItem}
+ *
+ * @param playerId
+ */
+getHeldItem(playerId: PlayerId): PNull<InvenItem>
+/**
+ * Get the amount of free slots in a player's inventory.
+ *
+ * @param playerId
+ * @returns number
+ */
+getInventoryFreeSlotCount(playerId: PlayerId): number
+/**
+ * Checks if a player is able to open a chest at a given location,
+ * as per the rules laid out by the "onPlayerAttemptOpenChest" game callback.
+ * Returns true if the player can open the chest, false if they cannot, and void if the chest does not exist.
+ *
+ * @param playerId
+ * @param chestX
+ * @param chestY
+ * @param chestZ
+ */
+canOpenStandardChest(playerId: PlayerId, chestX: number, chestY: number, chestZ: number): PNull<boolean>
+/**
+ * Open a chest for a player.
+ * If there is no chest, or the player cannot open it, do nothing.
+ * WARNING: This may call "onPlayerAttemptOpenChest" to determine if the player has permission to open it. Using this function inside that callback risks infinite recursion.
+ *
+ * @param playerId
+ * @param x
+ * @param y
+ * @param z
+ */
+openChestForPlayer(playerId: PlayerId, x: number, y: number, z: number): void
+/**
+ * Close a chest for a player.
+ * If the player does not have a chest open, do nothing.
+ *
+ * @param playerId
+ */
+closeChestForPlayer(playerId: PlayerId): void
+/**
+ * Read a player's current crafting recipe set, keyed by output item name. Includes any
+ * per-player overrides set via \`editItemCraftingRecipes\` / \`removeItemCraftingRecipes\`.
+ *
+ * @param playerId
+ */
+getCraftingRecipesForPlayer(playerId: PlayerId): Record<string, RecipesForItem>
+/**
+ * Give a standard chest an item and a certain amount of that item.
+ * Returns the amount of item added to the chest.
+ *
+ * @param chestPos
+ * @param itemName
+ * @param itemAmount
+ * @param playerId The player who is interacting with the chest.
+ * @param attributes An optional object for certain types of item. For guns this can contain the shotsLeft field which is the amount of ammo the gun currently has.
+ */
+giveStandardChestItem(chestPos: number[], itemName: ItemName, itemAmount?: number, playerId?: PlayerId, attributes?: ItemAttributes): number
+/**
+ * Remove an amount of item from a standardChest inventory
+ *
+ * @param chestPos
+ * @param itemName
+ * @param amount
+ * @param playerId The player who is interacting with the chest.
+ */
+removeItemNameFromStandardChest(chestPos: number[], itemName: ItemName, amount: number, playerId?: PlayerId): void
+/**
+ * Get the amount of free slots in a standard chest
+ * Returns null for non-chests
+ *
+ * @param chestPos
+ * @returns number
+ */
+getStandardChestFreeSlotCount(chestPos: number[]): PNull<number>
+/**
+ * The amount of an itemName a standard chest has.
+ * Returns 0 if the standard chest has none, and a negative number if infinite.
+ *
+ * @param chestPos
+ * @param itemName
+ * @returns number
+ */
+getStandardChestItemAmount(chestPos: number[], itemName: ItemName): number
+/**
+ * Get the item at a chest slot. Null if empty otherwise format {name: itemName, amount: amountOfItem}
+ *
+ * @param chestPos
+ * @param idx
+ */
+getStandardChestItemSlot(chestPos: number[], idx: number): PNull<InvenItem>
+/**
+ * Get all the items from a standard chest in order. Use this instead of repetitive calls to getStandardChestItemSlot
+ *
+ * @param chestPos
+ */
+getStandardChestItems(chestPos: number[]): PNull<InvenItem>[]
+/**
+ * @param chestPos
+ * @param idx 0-indexed
+ * @param itemName Can be 'Air', in which case itemAmount will be ignored and the slot will be cleared.
+ * @param itemAmount -1 for infinity. Should not be set, or null, for items that are not stackable.
+ * @param playerId The player who is interacting with the chest.
+ * @param attributes An optional object for certain types of item. For guns this can contain the shotsLeft field which is the amount of ammo the gun currently has.
+ */
+setStandardChestItemSlot(chestPos: number[], idx: number, itemName: ItemName, itemAmount?: number, playerId?: PlayerId, attributes?: ItemAttributes): void
+/**
+ * Find the index of a particular item in a standard chest
+ * @param chestPos
+ * @param itemName
+ */
+findStandardChestItem(chestPos: number[], itemName: ItemName): PNull<number>
+/**
+ * Get the item in a player's moonstone chest slot. Null if empty
+ *
+ * Moonstone chests are a type of chest where a player accesses the same contents no matter the location of the moonstone chest
+ *
+ * @param playerId
+ * @param idx
+ */
+getMoonstoneChestItemSlot(playerId: PlayerId, idx: number): PNull<InvenItem>
+/**
+ * Get all the items from a moonstone chest in order. Use this instead of repetitive calls to getMoonstoneChestItemSlot
+ *
+ * Moonstone chests are a type of chest where a player accesses the same contents no matter the location of the moonstone chest
+ *
+ * @param playerId
+ */
+getMoonstoneChestItems(playerId: PlayerId): PNull<InvenItem>[]
+/**
+ * Moonstone chests are a type of chest where a player accesses the same contents no matter the location of the moonstone chest
+ *
+ * @param playerId
+ * @param idx 0-indexed
+ * @param itemName Can be 'Air', in which case itemAmount will be ignored and the slot will be cleared.
+ * @param itemAmount -1 for infinity. Should not be set, or null, for items that are not stackable.
+ * @param metadata An optional object for certain types of item. For guns this can contain the shotsLeft field which is the amount of ammo the gun currently has.
+ */
+setMoonstoneChestItemSlot(playerId: PlayerId, idx: number, itemName: ItemName, itemAmount?: number, metadata?: ItemAttributes): void
+/**
+ * Store data about a block in a performant manner. Data is cleared when block changes.
+ * E.g. chest
+ * Works well with blocks marked tickable (e.g. wheat)
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param data
+ */
+setBlockData(x: number, y: number, z: number, data: object): void
+/**
+ * Get stored data about a block in a performant manner. Data is cleared when block changes.
+ * E.g. chest
+ * Works well with blocks marked tickable (e.g. wheat)
+ *
+ * @param x
+ * @param y
+ * @param z
+ */
+getBlockData(x: number, y: number, z: number): any
+/**
+ * Get the name of the lobby this game is running in.
+ */
+getLobbyName(): string
+/**
+ * Integer lobby names are public
+ * @returns boolean
+ */
+isPublicLobby(): boolean
+/**
+ * Returns if the current lobby the game is running in is special - e.g. a discord guild or dm, or simply a standard lobby
+ */
+getLobbyType(): LobbyType
+/**
+ * Update the progress bar in the bottom right corner.
+ * Can be queued.
+ *
+ * @param playerId
+ * @param toFraction The fraction of the progress bar you want to be filled up.
+ * @param toDuration The time it takes for the bar to reach the given toFraction in ms.
+ * If this is too low and you queue multiple updates, this toFraction could be skipped. Treat 200ms as a minimum.
+ */
+progressBarUpdate(playerId: PlayerId, toFraction: number, toDuration?: number): void
+/**
+ * This will initiate the MiddleScreenBar, starting at empty and filling up to full over the given duration.
+ * Good to represent cooldowns (eg gun reload) or charged items (eg crossbow)
+ *
+ * @param playerId
+ * @param duration ms over which the MiddleScreenBar fills up
+ * @param chargeExpiresAutomatically Defaults to true. If true, the bar will disappear upon reaching full. If false, the bar will remain at full until hidden with removeMiddleScreenBar
+ * @param horizontalBarRemOffset Offset the bar left or right (in css unit - rem)
+ */
+initiateMiddleScreenBar(playerId: PlayerId, duration: number, chargeExpiresAutomatically?: boolean, horizontalBarRemOffset?: number): void
+/**
+ * If there is any current middle screen bar running, this will hide it
+ *
+ * @param playerId
+ */
+removeMiddleScreenBar(playerId: PlayerId): void
+/**
+ * Show a hitmarker on the player's screen (the X-shaped crosshair flash indicating a successful hit).
+ * Useful for custom weapons or things that need visual hit feedback.
+ *
+ * @param playerId The player to show the hitmarker to
+ * @param isCrit If true, shows an enhanced critical-hit hitmarker with a longer, more dramatic animation
+ * @param directionVector Optional [x, y, z] direction vector. When provided, the hitmarker appears
+ *   at the projected screen position of that direction rather than at the centre of the screen.
+ *   Same flow as mobile melee attacks where the tap point differs from screen centre.
+ */
+sendHitmarker(playerId: PlayerId, isCrit?: boolean, directionVector?: PNull<number[]>): void
+/**
+ * Show a directional arrow indicator on the player's screen pointing toward a world position.
+ * When the position is off-screen the indicator is a rotating chevron at the screen edge.
+ * When the position is on-screen it becomes a small marker dot.
+ *
+ * The arrow persists until explicitly cleared via \`clearDirectionArrow\`.
+ * Calling again with the same \`id\` updates the existing arrow in-place.
+ *
+ * @param playerId The player to show the arrow to
+ * @param id Unique identifier for this arrow (allows multiple concurrent arrows)
+ * @param position [x, y, z] world position the arrow should point toward
+ * @param text Optional label rendered below the indicator. Supports CustomTextStyling for rich text with icons/colours.
+ * @param showDistance If true, displays the distance (in blocks) from the player to the arrow position.
+ * @param style Optional style object (same format as CustomTextStyling's StyledText \`style\`). Controls chevron/marker colour, label typography, and opacity.
+ */
+setDirectionArrow(playerId: PlayerId, id: string, position: number[], text?: PNull<string | CustomTextStyling>, showDistance?: boolean, style?: PNull<TextStyle>): void
+/**
+ * Clear a directional arrow from the player's screen.
+ *
+ * @param playerId The player to clear the arrow for
+ * @param id The arrow identifier to clear. If null, clears all arrows for this player.
+ */
+clearDirectionArrow(playerId: PlayerId, id?: PNull<string>): void
+/**
+ * Edit the crafting recipes for a player.
+ *
+ * @param playerId
+ * @param itemName
+ * @param recipesForItem
+ */
+editItemCraftingRecipes(playerId: PlayerId, itemName: ItemName, recipesForItem: RecipesForItem): void
+/**
+ * Reset the crafting recipes for a given back to its original bloxd state
+ *
+ * @param playerId
+ * @param itemName Resets all crafting recipes for the given player if null, otherwise resets the crafting recipes for the given item.
+ */
+resetItemCraftingRecipes(playerId: PlayerId, itemName: PNull<string>): void
+/**
+ * Removes crafting recipes
+ *
+ * @param playerId
+ * @param itemName Removes all crafting recipes for the given player if null, otherwise removes the crafting recipes for the given item.
+ */
+removeItemCraftingRecipes(playerId: PlayerId, itemName: PNull<string>): void
+/**
+ * Check if a position is within a cubic rectangle
+ *
+ * @param coordsToCheck
+ * @param pos1 position of one corner
+ * @param pos2 position of opposite corner
+ * @param addOneToMax
+ */
+isInsideRect(coordsToCheck: number[], pos1: number[], pos2: number[], addOneToMax?: boolean): boolean
+/**
+ * Get the entities in the rect between [minX, minY, minZ] and [maxX, maxY, maxZ]
+ *
+ * @param minCoords
+ * @param maxCoords
+ * @returns
+ */
+getEntitiesInRect(minCoords: number[], maxCoords: number[]): EntityId[]
+/**
+ * @param entityId
+ */
+getEntityType(entityId: EntityId): EntityType
+/**
+ * Gets the item name of a dropped item
+ *
+ * @param itemEId - The ID of the dropped item from createItemDrop
+ * @returns
+ */
+getItemDropName(itemEId: EntityId): PNull<ItemName>
+/**
+ * Deletes all items dropped in the world
+ */
+deleteAllItems(): void
+/**
+ * Create a mob herd. A mob herd represents a collection of mobs that move together.
+ */
+createMobHerd(): MobHerdId
+/**
+ * Try to spawn a mob into the world at a given position. Returns null on failure.
+ * WARNING: Either the "onPlayerAttemptSpawnMob" or the "onWorldAttemptSpawnMob" game callback will be called
+ * depending on whether "spawnerId" is provided. Calling this function inside those callbacks risks infinite recursion.
+ * @param mobType
+ * @param x
+ * @param y
+ * @param z
+ * @param opts Includes:
+ *  - mobHerdId The ID of this mob's herd. (A mob herd represents a collection of mobs that move together.)
+ *  - spawnerId The ID of the player who tried to spawn this mob.
+ *  - mobDbId A persistent ID for the mob. This can be useful when loading mob data from the database. If the DB ID is already taken, null will be returned.
+ *  - name If set, gives the mob a name that will be displayed as a nametag above their head.
+ *  - playSoundOnSpawn
+ *  - variation
+ *  - physicsOpts { width: number; height: number; collidesEntities: boolean }
+ * @returns null if the mob could not be spawned.
+ * This can happen when there are too many mobs in the world for the current number
+ * of players in the lobby, or if the area is protected e.g. by spawn area protection.
+ */
+attemptSpawnMob<TMobType extends MobType>(mobType: TMobType, x: number, y: number, z: number, opts?: MobSpawnOpts<TMobType>): PNull<MobId>
+/**
+ * Dispose of a mob's state and remove them from the world without triggering "on death" flows.
+ * Always succeeds.
+ * @param mobId
+ */
+despawnMob(mobId: MobId): void
+/**
+ * Returns the current default value for a mob setting.
+ *
+ * @param mobType
+ * @param setting
+ */
+getDefaultMobSetting<TMobType extends MobType, TMobSetting extends MobSetting>(mobType: TMobType, setting: TMobSetting): MobSettings<TMobType>[TMobSetting]
+/**
+ * Set the default value for a mob setting.
+ * @param mobType
+ * @param setting
+ * @param value
+ */
+setDefaultMobSetting<TMobType extends MobType, TMobSetting extends MobSetting>(mobType: TMobType, setting: TMobSetting, value: MobSettings<TMobType>[TMobSetting]): void
+/**
+ * Get the current value of a mob setting for a specific mob.
+ * @param mobId
+ * @param setting
+ * @param returnDefaultIfNotOverridden - If true, return the default setting if not overridden.
+ */
+getMobSetting<TMobSetting extends MobSetting>(mobId: MobId, setting: TMobSetting, returnDefaultIfNotOverridden?: boolean): MobSettings<MobType>[TMobSetting]
+/**
+ * Set the current value of a mob setting for a specific mob.
+ * @param mobId
+ * @param setting
+ * @param value
+ */
+setMobSetting<TMobSetting extends MobSetting>(mobId: MobId, setting: TMobSetting, value: MobSettings<MobType>[TMobSetting]): void
+/**
+ * Get the number of mobs in the world.
+ */
+getNumMobs(): number
+/**
+ * Get the mob IDs of all mobs in the world.
+ */
+getMobIds(): MobId[]
+/**
+ * Gets the current AI state for the given mob.
+ * @param mobId
+ */
+getMobAiState(mobId: MobId): { state: MobAiState; params: MobAiStateParams<MobAiState> }
+/**
+ * Sets the current AI state for the given mob.
+ * Some AI states will require context such as the ID of the lifeform being chased.
+ * @param mobId
+ * @param state
+ * @param params
+ */
+setMobAiState<TState extends MobAiState>(mobId: MobId, state: TState, params: MobAiStateParams<TState>): void
+/**
+ * Clears any aggro the mob has towards the given lifeform.
+ * If the mob is currently chasing or running away from it, this also transitions the mob back to idle.
+ * @param mobId
+ * @param targetLifeformId
+ */
+passifyHostility(mobId: MobId, targetLifeformId: LifeformId): void
+/**
+ * Try to create a throwable entity.
+ * Similar to creating a mesh entity and uses the same rate limiting.
+ * However, this uses the predefined throwables system and physics used by throwable items with the game
+ * Each throwable item has its own behaviour already, including default velocity, damage and gravity multipliers.
+ *
+ * @param throwerEId
+ * @param itemName Must be an Item that is usually throwable in-engine
+ * @param position Starting position
+ * @param direction
+ * @param velocityMult Multiplier for the default velocity of the throwable item
+ * @param damageMult Multiplier for the default damage of the throwable item
+ * @param gravityMult Multiplier for the default gravity of the throwable item
+ * @param attributes item attributes (currently used only for the "Boomerag" item)
+ * @returns null if throwable creation failed, otherwise the entity ID.
+ */
+attemptCreateThrowable(throwerEId: EntityId, itemName: ThrowableItem, position: [number, number, number], direction: [number, number, number], velocityMult?: number, damageMult?: number, gravityMult?: number, attributes?: ItemAttributes): string
+/**
+ * Delete a throwable entity before it automatically removes itself.
+ * @param eId
+ * @returns true if the entity was deleted, false if it was not a throwable entity
+ */
+deleteThrowable(eId: EntityId): boolean
+/**
+ * Try to create a mesh entity. This creates an entity whose mesh position is synced with clients.
+ * Set entity position using setPosition
+ * There is a limit to the number of mesh entities and throwables that can be created, with an even smaller limit for mesh entities with physics.
+ * @param type
+ * @param opts
+ * @param name The default name for the nametag
+ * @param physicsOptions Physics Options
+ * @param initiatorId The entity that initiated the creation of the mesh entity.
+ * @returns null if the entity creation failed, otherwise the entity ID.
+ */
+attemptCreateMeshEntity<MeshType extends MeshEntityType>(type: MeshType, opts: MeshEntityOpts[MeshType], name?: string, physicsOptions?: MeshEntityPhysicsOpts, initiatorId?: EntityId): PNull<EntityId>
+/**
+ * Update a mesh entity. If used on a non-mesh entity, will do nothing.
+ *
+ * @param eId
+ * @param type
+ * @param opts
+ */
+updateMeshEntity<MeshType extends MeshEntityType>(eId: EntityId, type: MeshType, opts: MeshEntityOpts[MeshType]): void
+/**
+ * Delete any non-player entity (mesh entity, mob, audio entity, item drop, throwable, etc.) and dispose of their state.
+ * @param eId
+ * @returns whether the entity's replicated state existed and was deleted
+ */
+deleteEntity(eId: EntityId): boolean
+/**
+ * Delete a mesh entity
+ *
+ * @param eId
+ * @returns whether the api successfully deleted the meshEntity
+ */
+deleteMeshEntity(eId: EntityId): boolean
+/**
+ * Apply an impulse to an entity
+ *
+ * @param eId
+ * @param xImpulse
+ * @param yImpulse
+ * @param zImpulse
+ */
+applyImpulse(eId: EntityId, xImpulse: number, yImpulse: number, zImpulse: number): void
+/**
+ * Get the velocity of an entity
+ * Will return [0, 0, 0] if the entity doesn't have a physics body
+ *
+ * @param eId
+ */
+getVelocity(eId: EntityId): Pos
+/**
+ * Set the velocity of an entity
+ *
+ * @param eId
+ * @param x
+ * @param y
+ * @param z
+ */
+setVelocity(eId: EntityId, x: number, y: number, z: number): void
+/**
+ * @deprecated use setEntityRotation
+ * Set the heading for a server-auth entity.
+ *
+ * @param entityId
+ * @param newHeading
+ */
+setEntityHeading(entityId: EntityId, newHeading: number): void
+/**
+ * @deprecated use getEntityRotation
+ * Get the heading for a server-auth entity.
+ *
+ * @param entityId
+ */
+getEntityHeading(entityId: EntityId): number
+/**
+ * Get the rotation for a server-auth entity.
+ *
+ * @param entityId
+ */
+getEntityRotation(entityId: EntityId): Pos
+/**
+ * Set the rotation for a server-auth entity.
+ *
+ * @param entityId
+ * @param xRotation
+ * @param yRotation
+ * @param zRotation
+ */
+setEntityRotation(entityId: EntityId, xRotation: number, yRotation: number, zRotation: number): void
+/**
+ * Get the amount of an item in an item entity
+ *
+ * @param itemId
+ * @returns number
+ */
+getItemAmount(itemId: EntityId): number
+/**
+ * Set the amount of an item in an item entity
+ *
+ * @param itemId
+ * @param newAmount
+ */
+setItemAmount(itemId: EntityId, newAmount: number): void
+/**
+ * Update the max players and soft max players matchmaking will use
+ *
+ * softMaxPlayers is the number of players that matchmaking will route to using "Quick Play".
+ * Once the softMaxPlayers limit is reached, this lobby can only be joined by requesting the lobby name or joining a friend.
+ *
+ * maxPlayers is the absolute maximum: a lobby will not have more players than this.
+ * Tip: softMaxPlayers should be around 90% of maxPlayers
+ *
+ * WARNING: This change is not immediate, as it takes a while for matchmaking to find out.
+ * Also, this will not kick players out of the lobby if set to a lower value than the current player count.
+ *
+ * @param softMaxPlayers
+ * @param maxPlayers
+ */
+setMaxPlayers(softMaxPlayers: number, maxPlayers: number): void
+/**
+ * Tell a player to disconnect from the current lobby and join a new one.
+ *
+ * To connect to a specific variation, format is \`gamename_variation\`.
+ * For Custom Games, this will be \`classic_playerSchematic|XXXXXXXXXX\` or
+ * \`classic_playerSchematic|XXXXXXXXXX|<varname>\` for a named sub-variation.
+ *
+ * NOTE: Players won't disconnect immediately (they may play an ad before being redirected).
+ *
+ * @param playerId
+ * @param game Defaults to the current game.
+ * @param lobbyName Defaults to "Quick Play"
+ */
+matchmakePlayer(playerId: PlayerId, game?: string, lobbyName?: string): void
+/**
+ * Create and register the UI for the requested quicktime event (QTE) to the screen.
+ * Handle the result via the onPlayerFinishQTE engine callback.
+ *
+ * @param playerId
+ * @param qteParameters - includes type and parameters
+ * @returns an id that can be passed to deleteQTE
+ */
+addQTE<T extends QTEType>(playerId: PlayerId, qteParameters: QTEClientParameters<T>): QTERequestId
+/**
+ * Delete a quicktime event from the screen
+ *
+ * @param playerId
+ * @param id Returned from the addQTE request you want to cancel
+ */
+deleteQTE(playerId: PlayerId, id: QTERequestId): void
+/**
+ * Check whether the player has any qteRequests
+ */
+hasActiveQTE(playerId: PlayerId): boolean
+/**
+ * Delete a request for a player.
+ *
+ * @param playerId
+ * @param id Returned from the addUiRequest call you want to cancel
+ */
+deleteUiRequest(playerId: PlayerId, id: UiRequestId): void
+/**
+ * Show a message over the shop in the same place that a shop item's onBoughtMessage is shown.
+ * Displays for a couple seconds before disappearing
+ * Use case is to show a dynamic message when player buys an item
+ *
+ * @param playerId
+ * @param info
+ */
+sendOverShopInfo(playerId: PlayerId, info: string | CustomTextStyling): void
+/**
+ * Open the shop UI for a player
+ *
+ * @param playerId
+ * @param toggle Whether to close the shop if it's already open. Leave this off when opening from an
+ * interaction: holding the interact button re-fires the alt action every ~50-150ms, so a toggle would
+ * flicker the shop open and closed until release.
+ * @param forceCategoryKey If set, will change the shop to this category
+ * @param onlyIfNonEmpty If true, will only open the shop if the category (or shop, if no category is provided) is non-empty
+ */
+openShop(playerId: PlayerId, toggle?: boolean, forceCategoryKey?: PNull<ShopCategoryKey>, onlyIfNonEmpty?: boolean): void
+/**
+ * Apply an effect to a lifeform.
+ * Can be an inbuilt effect E.g. "Speed" (speed boost), "Damage" (damage boost).
+ * For inbuilt just pass the name of the effect and the functionality is handled in-engine.
+ * For custom effect, you pass customEffectInfo. The icon can be an InGameIconName or a bloxd item name.
+ * The custom effect onEndCb is an optional helper within which you can undo the effect you applied.
+ * Note that onEndCb will not work for press to code boards, code blocks or world code.
+ *
+ * @param lifeformId
+ * @param effectName
+ * @param duration
+ * @param customEffectInfo
+ */
+applyEffect(lifeformId: LifeformId, effectName: string, duration: number | null, customEffectInfo: { icon?: IngameIconName | ItemName; onEndCb?: () => void; displayName?: string | TranslatedText } & Partial<InbuiltEffectInfo>): void
+/**
+ * Check if a lifeform has an effect.
+ *
+ * @param lifeformId
+ * @param name
+ * @param atOrAboveLevel Checks whether the effect is at or above the given level
+ */
+hasEffect(lifeformId: LifeformId, name: string, atOrAboveLevel?: number): boolean
+/**
+ * Get the level of an effect on a lifeform, or 0 if they don't have it.
+ *
+ * @param lifeformId
+ * @param name
+ */
+getEffectLevel(lifeformId: LifeformId, name: string): number
+/**
+ * Get all the effects currently applied to a lifeform.
+ *
+ * @param lifeformId
+ */
+getEffects(lifeformId: LifeformId): string[]
+/**
+ * Remove an effect from a lifeform.
+ *
+ * @param lifeformId
+ * @param name
+ */
+removeEffect(lifeformId: LifeformId, name: string): void
+/**
+ * Change a part of a player's skin.
+ * UGC code is restricted to cosmetics from packs with ugcSelectable; internal code can use any cosmetics.
+ * @param playerId Player to change
+ * @param cosmeticType Type of cosmetic
+ * @param cosmeticName Chosen cosmetic, will be made lowercase automatically
+ */
+changePlayerIntoSkin(playerId: PlayerId, cosmeticType: CosmeticType, cosmeticName: CosmeticName): void
+/**
+ * Remove gamemode-applied skin from a player
+ * @param playerId
+ */
+removeAppliedSkin(playerId: PlayerId): void
+/**
+ * Get a single equipped cosmetic for a player.
+ * @param playerId
+ * @param cosmeticType Type of cosmetic
+ */
+getPlayerCosmetic(playerId: PlayerId, cosmeticType: CosmeticType): CosmeticName
+/**
+ * Scale node of a player's mesh by 3d vector.
+ * State from prior calls to this api is lost so if you want to have multiple nodes scaled, pass in all the scales at once.
+ *
+ * @param playerId
+ * @param nodeScales
+ */
+scalePlayerMeshNodes(playerId: PlayerId, nodeScales: EntityMeshScalingMap): void
+/**
+ *  Attach/detach mesh instances to/from an entity
+ *  @param eId
+ *  @param node node to attach to
+ *  @param type if null, detaches mesh from this node
+ *  @param opts
+ *  @param offset
+ *  @param rotation
+ */
+updateEntityNodeMeshAttachment<MeshType extends MeshEntityType>(eId: EntityId, node: EntityNamedNode, type: PNull<MeshType>, opts?: MeshEntityOpts[MeshType], offset?: Pos, rotation?: Pos): void
+/**
+ * Set the pose of the player
+ * @param playerId
+ * @param pose
+ * @param poseOffset
+ */
+setPlayerPose(playerId: PlayerId, pose: PlayerPose, poseOffset?: Pos): void
+/**
+ * Set physics state of player (vehicle type and tier).
+ *
+ * For types that have tiers (e.g. BOAT, GLIDER, CAR), a \`tier\` of \`null\` defaults to the first
+ * tier (0). Types without tiers (e.g. DEFAULT) must be given a \`null\` tier.
+ * @param playerId
+ * @param physicsState
+ * @param positionOffset - Optional offset to adjust the player's collision box
+ */
+setPlayerPhysicsState(playerId: PlayerId, physicsState: PlayerPhysicsState<PhysicsType>, positionOffset?: Pos): void
+/**
+ * Get physics state for player
+ * @param playerId
+ */
+getPlayerPhysicsState(playerId: PlayerId): PlayerPhysicsState<PhysicsType>
+/**
+ * Put a player in a vehicle: teleport them to it, seat them at its \`riderOffset\` and give them the
+ * physics it confers. The vehicle's own physics state and rider offset are read from it, so a spawned
+ * vehicle and a rideable mob are entered the same way.
+ *
+ * Anyone already riding the vehicle is thrown off, and the player leaves whatever they were riding.
+ * @param playerId
+ * @param vehicleEId A spawned vehicle or a rideable mob.
+ */
+setPlayerVehicle(playerId: PlayerId, vehicleEId: EntityId): void
+/**
+ * Take a player off whatever they are riding, dropping them where it is. Does nothing if they are
+ * not riding anything.
+ * @param playerId
+ */
+exitPlayerVehicle(playerId: PlayerId): void
+/**
+ * The current value of a physics setting for a specific vehicle entity: the value set via
+ * \`setVehicleSetting\` if overridden, otherwise (when \`returnDefaultIfNotOverridden\`) the type/tier
+ * default from the vehicle's physics state. Mirrors \`getMobSetting\`.
+ *
+ * The one default not read from the type/tier is a mob's \`riderOffset\`, which comes from its ride height.
+ *
+ * A per-block setting (e.g. \`"IceCanAutoStep"\`) is \`undefined\` when that block is unlisted, which means
+ * the block does not change the setting rather than that the setting is off.
+ */
+getVehicleSetting<TSetting extends SettableVehicleSetting>(vehicleEId: EntityId, setting: TSetting, returnDefaultIfNotOverridden?: boolean): SettableVehicleSettingValue<TSetting>
+/**
+ * Override a physics setting for a specific vehicle entity, replacing the type/tier default for that
+ * vehicle's rider. The override is stored on the shared Bloxd and, when the vehicle currently has a
+ * rider, replicated to that rider's client. Mirrors \`setMobSetting\`.
+ *
+ * A setting can also be overridden for one block by naming the block first, e.g.
+ * \`setVehicleSetting(boatId, "IceCanAutoStep", true)\`. That is stored as an entry of the matching
+ * \`<setting>ByBlock\` record, which the physics tick reads as a precomputed block lookup.
+ */
+setVehicleSetting<TSetting extends SettableVehicleSetting>(vehicleEId: EntityId, setting: TSetting, value: SettableVehicleSettingValue<TSetting>): void
+/**
+ * Try to spawn a rideable vehicle, which players can mount with an alt action.
+ * There is a limit to the number of mesh entities with physics that can be created.
+ * WARNING: Either the "onPlayerAttemptSpawnVehicle" or the "onWorldAttemptSpawnVehicle" game callback will be called
+ * depending on whether "spawnerId" is provided. Calling this function inside those callbacks risks infinite recursion.
+ * @param vehicleType
+ * @param x
+ * @param y
+ * @param z
+ * @param opts Includes:
+ *  - spawnerId The ID of the player who spawned the vehicle. The vehicle faces away from them.
+ * @returns null if the vehicle could not be spawned, otherwise the entity ID of the vehicle.
+ */
+attemptSpawnVehicle(vehicleType: MeshEntityVehicleType, x: number, y: number, z: number, opts?: VehicleSpawnOpts): PNull<EntityId>
+/**
+ * Dispose of a vehicle's state and remove them from the world.
+ * Always succeeds.
+ * @param vehicleId
+ */
+despawnVehicle(vehicleId: EntityId): void
+/**
+ * Add following entity to player
+ * @param playerId
+ * @param eId
+ * @param offset
+ * @param followsPlayerRotation
+ */
+addFollowingEntityToPlayer(playerId: PlayerId, eId: EntityId, offset?: number[], followsPlayerRotation?: boolean): void
+/**
+ * Remove following entity from player
+ * @param playerId
+ * @param entityEId
+ */
+removeFollowingEntityFromPlayer(playerId: PlayerId, entityEId: EntityId): void
+/**
+ * Set camera zoom for a player
+ * @param playerId
+ * @param zoom
+ */
+setCameraZoom(playerId: PlayerId, zoom: number): void
+/**
+ * @param playerId hears the sound
+ * @param soundName Can also be a prefix. If so, a random sound with that prefix will be played
+ * @param volume 0-1. If it's too quiet and volume is 1, normalise your sound in audacity
+ * @param rate The speed of playback. Also affects pitch. 0.5-4. Lower playback = lower pitch
+ *        Good for varying the sound. E.g. item pickup sound has a random rate between 1 and 1.5.
+ * @param posSettings
+ * {playerIdOrPos: PlayerId | number[], maxHearDist: number, refDistance: number}
+ * playerIdOrPos: The player the sound originates from, or the position of the sound
+ * maxHearDist: sound is not played if player is further than this. Default 15
+ * refDistance: higher means the sound decreases less in volume with distance. Default 3. Hitting is 4. Guns are 10
+ *
+ */
+playSound(playerId: PlayerId, soundName: string, volume: number, rate: number, posSettings?: { playerIdOrPos: PlayerId | number[]; maxHearDist?: number; refDistance?: number; }): void
+/**
+ * See documentation for api.playSound
+ */
+broadcastSound(soundName: string, volume: number, rate: number, posSettings?: { playerIdOrPos: PlayerId | number[]; maxHearDist?: number; refDistance?: number; }, exceptPlayerId?: PlayerId): void
+/**
+ * See documentation for api.playSound
+ */
+playClientPredictedSound(soundName: string, volume: number, rate: number, posSettings?: { playerIdOrPos: PlayerId | number[]; maxHearDist?: number; refDistance?: number; }, predictedBy?: PlayerId): void
+
+calcExplosionForce(eId: EntityId, explosionType: ExplosionType, knockbackFactor: number, explosionRadius: number, explosionPos: number[], ignoreProjectiles: boolean): { force: Pos; forceFrac: number; }
+/**
+ * Add a custom killfeed message to the killfeed
+ * @param killer - The entity ID or a custom name and colour for the killer
+ * @param victim - The entity ID or a custom name and colour for the victim
+ * @param withItem - The item used
+ */
+addCustomKillfeedMessage(killer: { eId: EntityId } | { name: string; colour: string }, victim: { eId: EntityId } | { name: string; colour: string }, withItem: string): void
+/**
+ * Get the position of a player's target block and the block adjacent to it (e.g. where a block would be placed)
+ *
+ *
+ * Note: This position is a tick ahead of the client's block target info (noa.targetedBlock),
+ * since the client updates the blocktarget before the entities tick (and since it uses the renderposition of the camera)
+ *
+ * This normally doesn't matter but if you are client predicting something based on noa.targetedBlock
+ * (currently only applicable to in-engine code), you should not verify using this
+ *
+ * @param playerId
+ */
+getPlayerTargetInfo(playerId: PlayerId): { position: Pos; normal: Pos; adjacent: Pos }
+/**
+ * Get the position of a player's camera and the direction (both in Euclidean and spherical coordinates) they are attempting to use an item.
+ * The camPos has the same limitations described in getPlayerTargetInfo
+ *
+ * @param playerId
+ */
+getPlayerFacingInfo(playerId: PlayerId): { camPos: Pos; dir: Pos; angleDir: AngleDir; moveHeading: number }
+/**
+ * Raycast for a block in the world.
+ * Given a position and a direction, find the first block that the "ray" hits.
+ *
+ * @param fromPos
+ * @param dirVec
+ */
+raycastForBlock(fromPos: number[], dirVec: number[]): BlockRaycastResult
+/**
+ * Prevents the player from taking fall damage next time they land on the ground
+ * @param playerId
+ */
+preventFallDamageNextGrounding(playerId: PlayerId): void
+/**
+ * Check whether a player is crouching
+ *
+ * @param playerId
+ */
+isPlayerCrouching(playerId: PlayerId): boolean
+/**
+ * Get the aura info for a player
+ * @param playerId
+ */
+getAuraInfo(playerId: PlayerId): { level: number; totalAura: number; auraPerLevel: number }
+/**
+ * Sets the total aura for a player. Will not go over max level or under 0
+ * @param playerId
+ * @param totalAura
+ */
+setTotalAura(playerId: PlayerId, totalAura: number): void
+/**
+ * Set the aura level for a player - shortcut for setTotalAura(level * auraPerLevel)
+ * @param playerId
+ * @param level
+ */
+setAuraLevel(playerId: PlayerId, level: number): void
+/**
+ * Add (or remove if negative) aura to a player. Will not go over max level or under 0
+ * @param playerId
+ * @param auraDiff
+ * @returns The actual change in aura
+ */
+applyAuraChange(playerId: PlayerId, auraDiff: number): number
+/**
+ * Updates the particle systems of multiple mesh entities at specified nodes
+ * @param updates
+ */
+updateMeshParticleSystems(updates: MeshParticleSystemUpdates): void
+/**
+ * Gets a database value that is saved per lobby.
+ * @param key
+ */
+getLobbyDbValue(key: string): PNull<string | number>
+/**
+ * Sets a database value that is saved per lobby. This persists between sessions.
+ * @param key
+ * @param value
+ */
+setLobbyDbValue(key: string, value: string | number): void
+/**
+ * Deletes a database value that is saved per lobby.
+ * @param key
+ */
+deleteLobbyDbValue(key: string): void
+/**
+ * Deletes all database values that are saved per lobby.
+ */
+deleteAllLobbyDbValues(): void
+/**
+ * Gets a database value that is saved per player.
+ * @param playerId
+ * @param key
+ */
+getPlayerDbValue(playerId: PlayerId, key: string): PNull<string | number>
+/**
+ * Sets a database value that is saved per player. For custom games this persists between sessions and
+ * between lobbies, and is shared across all of the game's variations (e.g. a hub and its sub-modes).
+ * @param playerId
+ * @param key
+ * @param value
+ */
+setPlayerDbValue(playerId: PlayerId, key: string, value: string | number): void
+/**
+ * Deletes a database value that is saved per player.
+ * @param playerId
+ * @param key
+ */
+deletePlayerDbValue(playerId: PlayerId, key: string): void
+/**
+ * Deletes all database values that are saved per player, including persisted currencies.
+ * @param playerId
+ */
+deleteAllPlayerDbValues(playerId: PlayerId): void
+/**
+ * Dynamically define a currency for a player and show it on the HUD.
+ * Amounts will persist between sessions if \`persistent\` is set to true.
+ * Persistent currencies count towards db length limits.
+ *
+ * Example usage:
+ * \`\`\`js
+ * api.setCurrency(myId, "myCurrency", { amount: 100, icon: "coins", iconColour: "blue", persistent: true })
+ * \`\`\`
+ *
+ * @param playerId
+ * @param currencyId
+ * @param info
+ */
+setCurrency(playerId: PlayerId, currencyId: string, info: UgcCurrencyInfo): void
+/**
+ * Delete a currency from a player. This will make the currency unknown to the player.
+ * @param playerId
+ * @param currencyId
+ */
+deleteCurrency(playerId: PlayerId, currencyId: string): void
+/**
+ * Set the amount of a currency a player has. For persistent currencies, amount/subtext count towards db length limits.
+ * @param playerId
+ * @param currencyId
+ * @param amount
+ * @param subtext
+ */
+setCurrencyAmount(playerId: PlayerId, currencyId: string, amount: number, subtext?: string | CustomTextStyling): void
+/**
+ * Give a player an amount of currency. Can be negative to remove money.
+ * @param playerId
+ * @param currencyId
+ * @param amount
+ */
+giveCurrencyAmount(playerId: PlayerId, currencyId: string, amount: number): void
+/**
+ * Set a default value to be returned by your callback code if it throws an error.
+ *
+ * @param cbName The name of the callback to set the default value for.
+ * @param value The default value to return.
+ */
+setCallbackValueFallback(cbName: UserCallbacks, value: any): void
+/**
+ * Set the gamemode of a player. This is persistent across lobbies for custom games.
+ *
+ * @param playerId The ID of the player to set the gamemode of.
+ * @param gamemode The gamemode to set the player to.
+ */
+setPlayerGamemode(playerId: PlayerId, gamemode: WorldGamemode): void
+/**
+ * Get the gamemode of a player.
+ *
+ * @param playerId The ID of the player to get the gamemode of.
+ * @returns The gamemode of the player.
+ */
+getPlayerGamemode(playerId: PlayerId): WorldGamemode
+/**
+ * Returns true if your code is about to be interrupted for exceeding its time budget.
+ * Use this to break up long-running code into smaller chunks.
+ *
+ *
+ * ### Example:
+ * \`\`\`js
+ * // Resume from where we stopped last time (or 0 on the first run)
+ * let savedLoopCounter = 0
+ *
+ * // ...
+ *
+ * for (let i = savedLoopCounter; i < 1000; i++) {
+ * 	if (api.isNearInterrupt()) {
+ * 		// Out of time - remember our progress and stop before getting killed
+ * 		savedLoopCounter = i
+ * 		break
+ * 	}
+ *
+ * 	someExpensiveFunction()
+ * }
+ * \`\`\`
+ */
+isNearInterrupt(): boolean
+/**
+ * Schedule small text to be displayed in the middle of the screen (middleTextLower).
+ * This text will be removed after the duration.
+ * Stacking queued texts will schedule them to be displayed one after the other.
+ * NOTE: Overriding the middleTextLower client option may cause queued texts to be displayed incorrectly.
+ *
+ * @param playerId The ID of the player to display the text to.
+ * @param text The text to display.
+ * @param duration The duration of the text in milliseconds.
+ * @returns The ID of the queued command.
+ */
+queueMiddleTextLower(playerId: PlayerId, text: string | CustomTextStyling, duration: number): QueuedCommandId
+/**
+ * Schedule large text to be displayed in the middle of the screen (middleTextUpper).
+ * This text will be removed after the duration.
+ * Stacking queued texts will schedule them to be displayed one after the other.
+ * NOTE: Overriding the middleTextUpper client option may cause queued texts to be displayed incorrectly.
+ *
+ * @param playerId The ID of the player to display the text to.
+ * @param text The text to display.
+ * @param duration The duration of the text in milliseconds.
+ * @returns The ID of the queued command.
+ */
+queueMiddleTextUpper(playerId: PlayerId, text: string | CustomTextStyling, duration: number): QueuedCommandId
+/**
+ * Schedule text to be displayed in the crosshair.
+ * This text will be removed after the duration.
+ * Stacking queued texts will schedule them to be displayed one after the other.
+ * NOTE: Overriding the crosshairText client option may cause queued texts to be displayed incorrectly.
+ *
+ * @param playerId The ID of the player to display the text to.
+ * @param text The text to display.
+ * @param duration The duration of the text in milliseconds.
+ * @returns The ID of the queued command.
+ */
+queueCrosshairText(playerId: PlayerId, text: string | CustomTextStyling, duration: number): QueuedCommandId
+/**
+ * Get the status of a queued command.
+ *
+ * @param id The ID of the queued command to get the status of.
+ * @returns NOT_IN_QUEUE, WAITING_TO_RUN, or CURRENTLY_RUNNING.
+ */
+getQueuedStatus(id: QueuedCommandId): QueuedStatusString
+/**
+ * Remove a queued command from the queue.
+ *
+ * @param id The ID of the queued command to remove.
+ */
+removeFromQueue(id: QueuedCommandId): void
+/**
+ * Add a request for the player to answer in the top right corner. E.g. accepting or denying a tprequest.
+ *
+ * Use onUiRequestResponded to handle the response.
+ *
+ * Example Usage:
+ * \`\`\`js
+ * const myRequestId = api.addUiRequest(playerId, {
+ *   type: "standard",
+ *   title: "Do you want to join the game?",
+ * }, 5000)
+ *
+ * onUiRequestResponded = (playerId, uiRequestId, response) => {
+ *   if (uiRequestId === myRequestId) {
+ *     api.log(response)
+ *   }
+ * }
+ * \`\`\`
+ *
+ *
+ * @param playerId The ID of the player to add the request to.
+ * @param parameters The parameters of the request.
+ * @param timeoutAfterMs The timeout after which the request will be automatically deleted. A response will not be given and onUiRequestResponded will not be called.
+ * @returns The ID of the request. Pass into deleteUiRequest or cross-reference with onUiRequestResponded.
+ */
+addUiRequest(playerId: PlayerId, parameters: UiRequestClientParameters, timeoutAfterMs?: number): UiRequestId
+/**
+ * Add a request for the player to answer in the form of a popup. This blocks the player from doing anything else until they respond.
+ *
+ * Use onUiRequestResponded to handle the response.
+ *
+ * Example Usage:
+ * \`\`\`js
+ * const myRequestId = api.addUiRequestPopup(playerId, "Do you want to join the game?")
+ *
+ * onUiRequestResponded = (playerId, uiRequestId, response) => {
+ *   if (uiRequestId === myRequestId) {
+ *     api.log(response)
+ *   }
+ * }
+ * \`\`\`
+ *
+ * @param playerId The ID of the player to add the request to.
+ * @param requestText The text of the request.
+ * @returns The ID of the request, or null if the request was rate limited. Pass into deleteUiRequest or cross-reference with onUiRequestResponded.
+ */
+addUiRequestPopup(playerId: PlayerId, requestText: string): PNull<UiRequestId>
+/**
+ * Matchmake a player into a sub-variation of the current custom game.
+ * Pass \`"default"\` for the default variation.
+ *
+ * @param playerId The player to matchmake
+ * @param varname Sub-variation name (\`[A-Za-z0-9_-]\`, 1-32 chars), or \`"default"\`
+ */
+matchmakeToVariation(playerId: PlayerId, varname: string): void
+/**
+ * Get the current sub-variation name.
+ * Returns \`"default"\` when there is no named sub-variation.
+ */
+getVariation(): string
+/**
+ * Log a message to chat.
+*/
+log(message: any): void
+
+	}
+
+export interface Console {
+		/** Log a message to chat. */
+		log(message: any): void
+	}
+
+export type EntityId = string
+
+export type Pos = [number, number, number]
+
+export type LifeformId = EntityId
+
+export type PlayerId = LifeformId
+
+export type PNull<T> = T | null
+
+export type PlayerDbId = string
+
+export type LifeformBodyPart = (_TypeOf["lifeformBodyParts"])[number]
+
+export interface PlayerAttemptDamageOtherPlayerOpts {
+	eId: PlayerId
+	hitEId: PlayerId
+	attemptedDmgAmt: number
+	withItem: string
+	bodyPartHit?: LifeformBodyPart
+	attackDir?: number[]
+	showCritParticles?: boolean
+	reduceVerticalKbVelocity?: boolean
+	horizontalKbMultiplier?: number
+	verticalKbMultiplier?: number
+	broadcastEntityHurt?: boolean
+	attackCooldownSettings?: PNull<{ type: string; cooldownMs: number }>
+	hittingSoundOverride?: HittingSoundOverride
+	ignoreOtherEntitySettingCanAttack?: boolean
+	isTrueDamage?: boolean
+	// The damaging playerDbId. If null, will default to the dbId of \`eId\`
+	damagerDbId?: PNull<PlayerId>
+}
+
+export type HittingSoundOverride = { sound: string; volume: number; pitch: number }
+
+export type ItemName = string
+
+export type EnchantmentAttributes = {
+	enchantments: Partial<Record<EnchantmentPerk, number>>
+	enchantmentTier: EnchantmentTier
+	id: string
+}
+
+export type EnchantmentPerk = (_TypeOf["enchantmentPerks"])[number]
+
+export type EnchantmentTier = (_TypeOf["enchantmentTiers"])[number]
+
+export type CustomTextStyling = (string | EntityName | TranslatedText | StyledIcon | StyledText | ProgressBar | StyledKeyBinding)[]
+
+export type TranslatedText = {
+	translationKey: string
+	params?: Record<string, string | number | boolean | EntityName>
+}
+
+export type EntityName = {
+	entityName: string
+	ranks?: Readonly<Rank[]>
+	style?: {
+		color?: string
+		colour?: string
+	}
+}
+
+export type Rank = (_TypeOf["ranks"])[number]
+
+export type StyledIcon = {
+	icon: string
+	style?: {
+		color?: string
+		colour?: string
+		fontSize?: FontSize
+		opacity?: number
+	}
+}
+
+export type FontSize = string
+
+export type StyledText = {
+	str: string | EntityName | TranslatedText
+	style?: TextStyle
+}
+
+export type TextStyle = {
+	color?: string
+	colour?: string
+	fontWeight?: string
+	fontSize?: FontSize
+	fontStyle?: string
+	opacity?: number
+}
+
+export type ProgressBar = {
+	// Mandatory discriminator: marks this CustomTextStyling item as a progress bar.
+	type: "ProgressBar"
+	progress: number
+	width?: FontSize
+	height?: FontSize
+	colours?: string[]
+	backgroundColour?: string
+}
+
+export type StyledKeyBinding = {
+	type: "StyledKeyBinding"
+	action: NoaAction
+	style?: TextStyle
+}
+
+export type NoaAction = (_TypeOf["noaActions"])[number]
+
+export type ClientOption = keyof ClientOptions
+
+export type EarthSkyBox = {
+	type: "earth"
+	inclination?: number
+	turbidity?: number
+	infiniteDistance?: boolean
+	luminance?: number
+	// Sky appearance (light intensity); higher = more saturated sky.
+	rayleigh?: number
+	// Mie scattering coefficient in [0, 0.1]; affects mieDirectionalG impact.
+	mieCoefficient?: number
+	// Amount of haze particles per Mie scattering theory.
+	mieDirectionalG?: number
+	// Distance of the sun from the active scene camera.
+	distance?: number
+	// When \`useSunPosition\` is true, this overrides \`inclination\` + \`azimuth\`.
+	sunPosition?: Vec3
+	useSunPosition?: boolean
+	xCameraOffset?: number
+	yCameraOffset?: number
+	zCameraOffset?: number
+	// Direction the sky considers "up"; defaults to [0, 1, 0].
+	up?: Vec3
+	// Dither the sky to reduce visible banding.
+	dithering?: boolean
+	azimuth?: number
+	// Not part of sky model by default; heavily tint to a vertex color
+	vertexTint?: Vec3
+}
+
+export type Vec3 = [number, number, number]
+
+export type LobbyLeaderboardInfo = Record<
+	string,
+	{
+		displayName?: string | CustomTextStyling
+		hidden?: boolean
+		sortOrder?: "ascending" | "descending" // No value means descending
+		sortPriority?: number
+	}
+>
+
+export type TextWithDisplayOptions = {
+	showBackground?: boolean // Defaults to true. When false, the option's background panel is hidden.
+	content: string | CustomTextStyling
+}
+
+export type HeaderChip = string | CustomTextStyling | TextWithDisplayOptions
+
+export type GunshotOrigin = "default" | "head"
+
+export type ShopCategoryKey = string
+
+export type ShopItemKey = string
+
+export type ShopItem = {
+	image: string
+	schematicId?: SchematicId
+	cost?: number
+	currency?: string
+	amount?: number // Display amount shown on the shop tile image (0 and 1 are not displayed)
+	imageColour?: string
+	canBuy?: boolean
+	isSelected?: boolean
+	buyButtonText?: string | CustomTextStyling
+	customTitle?: string | CustomTextStyling
+	description?: string | CustomTextStyling
+	onBoughtMessage?: string | CustomTextStyling
+	redDot?: boolean
+	forceRemoveRedDot?: boolean
+	isRewardedAd?: boolean
+	badge?: { text: string | CustomTextStyling; type: ShopItemBadgeType }
+	userInput?: ShopItemUserInput
+	enchant?: {
+		tier: EnchantmentTier
+		enchantments: Partial<Record<EnchantmentPerk, number>>
+		enchantmentData?: Record<string, { icon?: string; description?: string }>
+	}
+
+	// Not defined on client, must be defined on server
+	boughtCallback?: (
+		playerId: PlayerId,
+		cost: number,
+		currency: string,
+		categoryKey: ShopCategoryKey,
+		itemKey: ShopItemKey,
+		userInput: string,
+		amount: number | undefined,
+	) => void
+	sell?: boolean // Optional, defaults to false. If true, the sign of "cost" is flipped. So a "cost" of -25 would give the player 25 currency AND be displayed as "25" (instead of -25)
+	sortPriority?: number // Descending, bigger number means closer to the top
+	hidden?: boolean
+}
+
+export type ShopItemUserInput =
+	| { type: "text"; placeholderText?: string; wordCharsOnly?: boolean; initialValue?: string } // wordCharsOnly defaults to false. If true, only allows \w character (alphanumeric and _). initialValue always takes precedence as the text input value when set.
+	| { type: "number"; placeholderText?: string; initialValue?: string }
+	| {
+			type: "dropdown"
+			dropdownOptions: readonly (string | { option: string; cost: number })[]
+			shouldResetSelectionOnOptionsChange?: boolean // Defaults to false. If true, the selection will reset to the first option when dropdownOptions changes.
+			initialValue?: string
+			autoSubmit?: boolean // Defaults to false. If true, the dropdown will automatically submit when the user selects an option.
+	  }
+	| { type: "player"; excludedPlayers?: PlayerId[] } // Defaults to excluding the current player
+	| { type: "color"; initialValue?: string }
+
+export type SchematicId = string
+
+export type ShopItemBadgeType = (_TypeOf["shopItemBadgeTypes"])[number]
+
+export type ShopCategoryConfig = Partial<{
+	autoSelectCategory: boolean
+	customTitle: string // Supports translation keys and ordinary text
+	redDot: boolean
+	forceRemoveRedDot: boolean
+	sortPriority: number
+	description: string | CustomTextStyling
+}>
+
+export type OtherEntitySetting = keyof OtherEntitySettings
+
+export type EntityMeshScalingMap = {
+	[key in EntityNamedNode]?: number[]
+}
+
+export type EntityNamedNode = PlayerMeshNamedNode
+
+export type PlayerMeshNamedNode = (_TypeOf["playerMeshNamedNodes"])[number]
+
+export type LobbyLeaderboardValues = Record<string, string | number | CustomTextStyling>
+
+export type ChatTags = CustomTextStyling[]
+
+export type NameTagInfo = {
+	backgroundColor?: string
+	content?: (CustomTextStyling[number] | RankInfo)[]
+	subtitle?: (CustomTextStyling[number] | RankInfo)[]
+	subtitleBackgroundColor?: string
+	minLighting?: number
+	healthbar?: HealthbarInfo
+	border?: NameTagBorder
+}
+
+export type RankInfo = {
+	// Font Awesome icon name
+	icon: string
+	mainRGB: string
+	// Defaults to mainRGB
+	bracketRGB?: string
+	chatTag: {
+		str: string
+		// Defaults to mainRGB
+		strRGB?: string
+	}[]
+	// Defaults to none
+	nameTag: {
+		// Defaults to normal name colour (white)
+		iconRGB?: string
+		// Defaults to none
+		iconShadowRGB?: string
+	}
+	visible: boolean // If false, this rank will not be shown in the player list or in the chat
+}
+
+export type HealthbarInfo = Readonly<{
+	// Controls when the healthbar is shown.
+	// "onDamage" (default) shows it for a few seconds after the entity takes damage.
+	display?: HealthbarDisplay
+	height?: FontSize
+	// Track colour behind the depleting bar. Undefined leaves the background transparent.
+	backgroundColour?: string
+	// Fill colour of the bar. Either a flat colour, or a gradient keyed on health fraction.
+	// Undefined uses the default green -> orange -> red depleting gradient.
+	foregroundColour?: string | readonly HealthbarColourGradient[]
+}>
+
+export type NameTagBorder = Readonly<{
+	colour: string
+	// Visual preset:
+	// - "solid": a flat outline.
+	// - "glow": an outline with an outer glow - reads as powerful/elite, ideal for bosses.
+	// - "double": two concentric outlines for an ornate, high-stakes look.
+	style?: NameTagBorderStyle
+	width?: FontSize
+	applyTo?: NameTagBorderTarget
+}>
+
+export type HealthbarDisplay = (_TypeOf["healthbarDisplays"])[number]
+
+export type HealthbarColourGradient = Readonly<{ healthFraction: number; colour: string }>
+
+export type NameTagBorderStyle = (_TypeOf["nameTagBorderStyles"])[number]
+
+export type NameTagBorderTarget = (_TypeOf["nameTagBorderTargets"])[number]
+
+export type MultilineTextBox = {
+	content: (CustomTextStyling[number] | RankInfo)[]
+	backgroundColor?: string
+	animateIn?: boolean
+}
+
+export type TempParticleSystemOpts = ParticleSystemOpts & {
+	dir1: number[]
+	dir2: number[]
+	pos1: number[]
+	pos2: number[]
+	manualEmitCount: number
+	hideDist: number
+}
+
+export type ParticlePresetOpts = {
+	presetId: ParticlePresetId
+	pos1: number[]
+	pos2: number[]
+}
+
+export type ParticleSystemOpts = {
+	texture: string
+	minLifeTime: number
+	maxLifeTime: number
+	minEmitPower: number
+	maxEmitPower: number
+	minSize: number
+	maxSize: number
+	gravity: number[]
+	velocityGradients: VelocityGradient[]
+	colorGradients: TimeColorGradient[] | RandomColorGradient[]
+	blendMode: ParticleSystemBlendMode
+}
+
+export type VelocityGradient = {
+	timeFraction: number
+	factor: number
+	factor2: number
+}
+
+export type TimeColorGradient = {
+	timeFraction: number
+	minColor: [number, number, number, number]
+	maxColor?: [number, number, number, number]
+}
+
+export type RandomColorGradient = {
+	color: [number, number, number]
+}
+
+export type ParticlePresetId = keyof _TypeOf["particlePresets"]
+
+export type AnimationSchema = Readonly<{
+	animationDurationMs: number
+	loop?: LoopModeSchema
+	nodeAnimations?: NodeSkeletonAnimationSchema
+}>
+
+export type BlockbenchAnimationSchema = Readonly<{
+	animation_length: number // The duration of the animation in seconds.
+	loop?: BlockbenchLoopModeSchema
+	bones?: BlockbenchBonesAnimationSchema
+}>
+
+export type LoopModeSchema = boolean | "hold-on-last-frame"
+
+export type AnimationTimelineSchema = readonly KeyframeSchema[]
+
+export type KeyframeSchema = Readonly<{
+	timeFraction: number
+	rotation?: LerpPointSchema // Rotations are assumed to be in radians.
+	position?: LerpPointSchema // Position offsets in mesh-local units; (0, 0, 0) means the node's rest pose.
+}>
+
+export type LerpPointSchema =
+	| Point
+	| Readonly<{
+			lerpMode?: LerpModeSchema
+			point: Point
+	  }>
+	| Readonly<{
+			lerpMode?: LerpModeSchema
+			pre: Point // When lerping towards a point, we lerp towards its pre.
+			post: Point // When lerping away from a point, we lerp away from its post.
+	  }>
+
+export type Point = Readonly<Vec3>
+
+export type LerpModeSchema = "linear" | "catmull-rom-spline"
+
+export type BlockbenchLoopModeSchema = boolean | "hold_on_last_frame"
+
+export type BlockbenchAnimationTimelineSchema = Point | Readonly<Record<TimestampString, BlockbenchAnimationFrameSchema>>
+
+export type TimestampString = string
+
+export type BlockbenchAnimationFrameSchema =
+	| Point
+	| Readonly<{
+			lerp_mode?: BlockbenchLerpModeSchema
+			pre?: Point // When lerping towards a point, we lerp towards its pre.
+			post: Point // When lerping away from a point, we lerp away from its post.
+	  }>
+
+export type BlockbenchLerpModeSchema = "linear" | "catmullrom"
+
+export type NodeSkeletonAnimationSchema = Readonly<Record<NodeName, NodeAnimationSchema>>
+
+export type NodeName = string
+
+export type NodeAnimationSchema = Readonly<{
+	timeline: AnimationTimelineSchema
+}>
+
+export type BlockbenchBonesAnimationSchema = Readonly<Record<NodeName, BlockbenchBoneAnimationSchema>>
+
+export type BlockbenchBoneAnimationSchema = Readonly<{
+	rotation?: BlockbenchAnimationTimelineSchema // Blockbench rotations are in degrees.
+	position?: BlockbenchAnimationTimelineSchema // Blockbench position offsets in mesh-local units; rest pose is (0, 0, 0).
+}>
+
+export type MobId = LifeformId
+
+export type MobDbId = string
+
+export type BlockName = string
+
+export type BlockId = number
+
+export type WorldBlockChangedInfo = {
+	cause: PNull<WorldBlockChangedCause>
+}
+
+export type WorldBlockChangedCause = "Paintball" | "FloorCreator" | "Sapling" | "StemFruit" | "MeltingIce" | "Explosion"
+
+export type GameChunk = {
+	blockData: any
+	extraInfo: PersistedExtraInfo
+}
+
+export type PersistedExtraInfo = {
+	specialBlocks: any[]
+	entities: any[]
+	// We allow games and plugins to store custom metadata in the chunk,
+	// but that metadata should be:
+	// - minimal, to avoid issues where the chunk is too large to store;
+	// - updated infrequently, to avoid excessive writes to the DB.
+	customMetadata: any
+}
+
+export type ItemAttributes = { customDisplayName?: string; customDescription?: string; customAttributes?: Record<string, any> }
+
+export type ItemDropOptions = Readonly<
+	Partial<{
+		doPhysics: boolean
+		size: number
+	}>
+>
+
+export type AudioEntityOpts = {
+	soundName: string
+	// Base relative volume in [0, 1], before distance attenuation.
+	volume: number
+	// Inverse-distance reference distance in blocks; larger = gentler falloff.
+	refDistance: number
+	// Hard cutoff distance in blocks; beyond this the entity is silent.
+	maxHearDist: number
+	// Playback rate multiplier (1 = normal pitch/speed).
+	rate: number
+}
+
+export type AnimParams = { animTextures: string[]; animationInterval: number }
+
+export type HarvestType = "granule" | "wood" | "rock" | "cuttable"
+
+export type BlockMetadataModelType =
+	| "CentreCross"
+	| "SquareSided"
+	| "CustomPlanes"
+	| "CustomModel"
+	| "Slab"
+	| "door"
+	| "trapdoor"
+	| "rotatableOffset"
+	| "rotatable"
+
+export type SpecialToolDrop = { tool: ItemName | ItemName[]; drops: ItemName | BlockName }
+
+export type RecursiveReadonly<T> = T extends Primitive
+	? T
+	: T extends (...args: never[]) => unknown
+		? T
+		: T extends readonly unknown[]
+			? number extends T["length"]
+				? ReadonlyArray<RecursiveReadonly<T[number]>> // T[]
+				: { readonly [K in keyof T]: RecursiveReadonly<T[K]> } // Tuple
+			: Readonly<{ [K in keyof T]: RecursiveReadonly<T[K]> }>
+
+export type Primitive = string | number | boolean | bigint | symbol | undefined | null
+
+export type SoundType = "stone" | "wood" | "gravel" | "grass" | "glass" | "sand" | "snow" | "cloth"
+
+export type GunStatsOverride = Partial<Omit<GunMetadata, NonOverridableStats>>
+
+export type GunMetadata = {
+	gunType: GunCategory // Used for sounds
+	scopeType: "none" | "sniper"
+	muzzleFlashOffsetFromGun: Vec3
+	muzzleFlashScale?: number
+	autoFireWithMouse: boolean
+	fireRate: number
+	fireRateWithHeldTouch?: number
+	burstCount?: number
+	burstDelay?: number
+	damage: number
+	shotPelletCount?: number
+	reloadTime?: number
+	clipSize: number
+	reloadBulletsIndividually?: boolean
+	bulletReloadTime?: number
+	cockTime?: number
+	tagSpeedMult: number
+	subsequentTagSpeedReductionScalar: number
+	inaccuracyStanding: number
+	inaccuracyFromShot: number
+	inaccuracyMovement: number
+	yVelocityInaccuracy: number
+	inaccuracyFromJump: number
+	altInaccuracyStanding: number
+	altInaccuracyFromShot: number
+	altInaccuracyMovement: number
+	recoveryRate: number
+
+	msPerRound?: number // computed from fireRate
+	msPerRoundTouchScreen?: number // computed from fireRateWithHeldTouch
+
+	altYVelocityInaccuracy?: number
+	altInaccuracyFromJump?: number
+
+	hasVerticalInaccuracy?: boolean
+
+	keepScopeOnShot?: boolean
+
+	aimZoomFactor?: number
+
+	// Kickback
+	kickbackDecreaseRate: number
+	minKickback?: number
+	maxKickback?: number
+	kickbackRate?: number
+}
+
+export type NonOverridableStats =
+	// Precomputed values
+	| "msPerRound"
+	| "msPerRoundTouchScreen"
+
+	// These two don't even work lol
+	// TODO: Fix them
+	| "tagSpeedMult"
+	| "subsequentTagSpeedReductionScalar"
+
+export type GunCategory = (_TypeOf["gunCategories"])[number]
+
+export type WeaponComboInfo = Readonly<{
+	comboWindowMs: number
+	comboMultipliers: readonly number[]
+	backstabAngle?: number // If present, hitting an enemy from behind within this angle (radians) skip to end of combo
+}>
+
+export type AnyMetadataItem = Partial<BlockMetadataItem & NonBlockMetadataItem>
+
+export type CustomItemStat = (_TypeOf["customItemStats"])[number]
+
+export type InvenItem = { name: string; amount: PNull<number>; attributes: ItemAttributes; typeObj: any }
+
+export type RecipesForItem = RecursiveReadonly<
+	{
+		requires: { items: ItemName[]; amt: number }[]
+		produces: number
+		station?: string | string[]
+		onCraftedAura?: number
+		isStarterRecipe?: boolean
+		attributes?: ItemAttributes
+	}[]
+>
+
+export type EntityType = PNull<NetworkedEntityType | "Mesh" | "Item">
+
+export type NetworkedEntityType =
+	| LifeformType
+	| ThrowableItem
+	| string
+	| string
+	| "AudioEntity"
+
+export type LifeformType = (_TypeOf["lifeformTypes"])[number]
+
+export type ThrowableItem = string
+
+export type MeshEntityType = keyof MeshEntityOpts
+
+export type MeshEntityOptsStringified = string
+
+export type MeshEntityOpts = {
+	Box: CommonMeshEntityOpts & {
+		width: number
+		height: number
+		depth: number
+		diffuseColor?: number[]
+		emissiveColor?: number[]
+		backFaceCulling?: boolean // Default true
+		texture?: string // Can be a blockname. Wraps every one block
+		faceUV?: number[][]
+		animateTexture?: boolean // If true, \`texture\` must be an animated block name (e.g. "Lava", "Red Portal") and the Box cycles through its frames.
+	}
+	BloxdBlock: CommonMeshEntityOpts & {
+		blockName: BlockNameOrId
+		size: number | [number, number, number]
+	}
+	Person: CommonMeshEntityOpts & {
+		size?: number
+		textures?: Partial<Cosmetics>
+		pose?: PlayerPose
+	}
+	ParticleEmitter: MeshParticleSystemOpts
+}
+
+export type CommonMeshEntityOpts = {
+	hideDist?: number
+	meshOffset?: number[]
+	autoRotate?: boolean
+	lineToEId?: EntityId // EntityId to connect to using a line
+}
+
+export type BlockNameOrId = BlockName | BlockId
+
+export type Cosmetics = Record<CosmeticType, CosmeticName>
+
+export type PlayerPose = (_TypeOf["playerPoses"])[number]
+
+export type MeshParticleSystemOpts = ParticleSystemOpts &
+	CommonMeshEntityOpts & {
+		height: number
+		width: number
+		depth: number
+		emitRate: number
+		dir1?: number[]
+		dir2?: number[]
+	}
+
+export type CosmeticType = (_TypeOf["cosmeticTypes"])[number]
+
+export type CosmeticName = string
+
+export type MobHerdId = number
+
+export type MobType = (_TypeOf["mobTypes"])[number]
+
+export type MobSpawnOpts<TMobType extends MobType> = Partial<{
+	mobHerdId: MobHerdId
+	spawnerId: PlayerId
+	mobDbId: MobDbId
+	name: string
+	playSoundOnSpawn: boolean
+	variation: MobVariation<TMobType>
+	physicsOpts: Partial<{
+		width: number
+		height: number
+		collidesEntities: boolean
+	}>
+}>
+
+export type MobVariation<TMobType extends MobType> = (_TypeOf["mobVariations"])[TMobType][number]
+
+export type MobSetting = (_TypeOf["mobSettings"])[number]
+
+export type MobSettings<TMobType extends MobType> = {
+	variation: MobVariation<TMobType>
+	name: string
+	maxHealth: number
+	initialHealth: number
+	idleSound: PNull<string>
+	attackSound: PNull<string>
+	secondaryAttackSound: PNull<string>
+	hurtSound: PNull<string>
+	onDeathItemDrops: readonly MobItemDrop[]
+	onDeathParticleTexture: string
+	onDeathAura: number
+	baseWalkingSpeed: number
+	baseRunningSpeed: number
+	walkingSpeedMultiplier: number
+	runningSpeedMultiplier: number
+	jumpCount: number
+	baseJumpImpulseXZ: number
+	baseJumpImpulseY: number
+	jumpMultiplier: number
+	runAwayRadius: number
+	chaseRadius: number
+	territoryRadius: number
+	hostilityRadius: number
+	stoppingRadius: number
+	attackInterval: number
+	attackRadius: number
+	secondaryAttackRadius: number
+	attackDamage: number
+	secondaryAttackDamage: number
+	isReceivingDamageCooldownGlobal: boolean // When the mob is attacked, a short cooldown prevents further damage from the same attack type. If true, all attackers share that cooldown. If false, each attacker has their own.
+	knockbackReceivedMultiplier: number // Scales incoming knockback when the mob is hit: 0 = immune (no knockback), 1 = normal, 2 = double. Applied on top of any worn-armour/effect knockback resistance.
+	attackImpulse: number
+	secondaryAttackImpulse: number
+	rangedAttackInaccuracy: number // Total angular width of the random cone (in radians), 0 = perfectly accurate (laser-aim). Only affects throwable/projectile attacks
+	burstAttackInfo: PNull<MobBurstAttackInfo>
+	secondaryBurstAttackInfo: PNull<MobBurstAttackInfo>
+	heldItemName: PNull<ItemName>
+	heldItemEnchantmentTier: PNull<EnchantmentTier>
+	armour: MobArmour
+	attackItemName: PNull<ItemName>
+	secondaryAttackItemName: PNull<ItemName>
+	swingArmOnAttack: boolean
+	swingArmOnSecondaryAttack: boolean
+	attackEffectName: PNull<string>
+	attackEffectDuration: number
+	warpTargetSpecialAttackInfo: PNull<MobWarpTargetSpecialAttackInfo>
+	combatTetherInfo: PNull<MobCombatTetherCombatInfo>
+	evadeInfo: PNull<MobEvadeInfo>
+	chargeSpecialAttackInfo: PNull<MobChargeSpecialAttackInfo>
+	tameInfo: PNull<Readonly<MobTameInfo>>
+	onTamedHealthMultiplier: number
+	petInfo: Readonly<MobPetInfo> // Instance-specific information related to mob feeding
+	ownerDbId: PNull<PlayerDbId>
+	minFollowingRadius: number
+	maxFollowingRadius: number
+	isRideable: boolean
+	healthRegen: PNull<MobHealthRegenSettings>
+	ridingSpeedMult: number
+	bridgeInfo: PNull<MobBridgeInfo>
+	// Impulse-driven movement (independent slide / jump / random-facing capabilities). \`walking*\` apply while
+	// moving at walking speed (idle wander + walkToPosition), \`running*\` at running speed (chase/flee/follow/
+	// runToPosition). Null = ordinary speed-driven movement.
+	walkingSlideInfo: PNull<MobSlideInfo>
+	runningSlideInfo: PNull<MobSlideInfo>
+	walkingJumpInfo: PNull<MobJumpInfo>
+	runningJumpInfo: PNull<MobJumpInfo>
+	walkingRandomFacingInfo: PNull<MobRandomFacingInfo>
+	runningRandomFacingInfo: PNull<MobRandomFacingInfo>
+	metaInfo: string
+}
+
+export type MobItemDrop = Readonly<{
+	itemName: ItemName
+	probabilityOfDrop?: number
+
+	// If a mob drops an item, then we choose a random amount within these bounds.
+	dropMinAmount?: number
+	dropMaxAmount?: number
+
+	// If true, the item will "burst" out of the mob rather than just dropping.
+	applyBurstImpulseToDrop?: boolean
+}>
+
+export type MobBurstAttackInfo = Readonly<{
+	burstAttackIntervals: readonly number[]
+}>
+
+export type MobArmour = Partial<Readonly<Record<ArmourPart, MobArmourPiece>>>
+
+export type MobWarpTargetSpecialAttackInfo = Readonly<{
+	cooldown: number
+	range: number
+	sound: PNull<string>
+	delay: number
+	minDestinationRadius: number
+	maxDestinationRadius: number
+	swingArm: boolean
+	particleOpts: PNull<TempMobParticleOpts>
+}>
+
+export type MobCombatTetherCombatInfo = Readonly<{
+	range: number
+	particleOpts: MobParticleOpts
+}>
+
+export type MobEvadeInfo = Readonly<{
+	probability: number
+	impulse: number
+	minAngle: number
+	maxAngle: number
+}>
+
+export type MobChargeSpecialAttackInfo = Readonly<{
+	// Multiplier applied to the running speed during the straight dash. Defaults to 1.
+	chargeSpeedMult?: number
+	// Max heading error (radians) at which the mob is considered "facing" its target and may dash. Defaults to a small tolerance.
+	faceTolerance?: number
+	// Pose shown while dashing, reverted to the resting pose when the charge ends. Defaults to "zombie".
+	chargePose?: PlayerPose
+}>
+
+export type MobTameInfo = {
+	tameItemName: ItemName | readonly ItemName[]
+	probabilityOfTame: number
+	isSaddleable?: boolean
+	saddleItemName?: ItemName
+	foodItemNames?: readonly ItemName[]
+	foodItemsWithEffects?: readonly Readonly<ItemNameWithEffects>[]
+	supportsFriendship?: boolean
+	likedFoods?: readonly ItemName[]
+	neutralFoods?: readonly ItemName[]
+	dislikedFoods?: readonly ItemName[]
+	guaranteedDrop?: ItemName
+	commonDrops?: ItemName[]
+	levelUpBonuses?: LevelUpBonuses
+}
+
+export type MobPetInfo = {
+	friendshipPoints: number
+	lastFedAt: number
+	highestFriendshipLevelReached: MobFeedLevel
+	superlikedFood: PNull<ItemName>
+	superlikedFoodKnown: boolean
+	bonusesGained: readonly MobLevelUpBonus[]
+}
+
+export type MobHealthRegenSettings = Readonly<{
+	amount: number
+	interval: number
+	startAfter: number
+}>
+
+export type MobBridgeInfo = Readonly<{
+	// The block to place.
+	blockToPlace: BlockName
+	// If true, only place while stood on solid ground (decorates the surface walked over); if false, place
+	// even while airborne (lets the mob bridge a gap beneath itself).
+	mustBeGrounded: boolean
+	// Only overwrite a cell currently holding one of these blocks, so real terrain is never destroyed.
+	// Omitted means \`["Air"]\` (fill empty space only); an empty array replaces nothing at all, not even
+	// air. A cell already holding \`blockToPlace\` is skipped (would be a no-op).
+	blocksToReplace?: readonly BlockName[]
+	// Vertical offset from the cell the mob occupies. Defaults to 0 (a surface trail); -1 places beneath the
+	// mob's feet (bridging). Non-negative offsets intersect the mob, so \`blockToPlace\` must be non-solid there.
+	yOffset?: number
+	// If a |Decaying variant exists for \`blockToPlace\`, use it to turn blocks into air after \`msToDecay\` ms.
+	msToDecay?: number
+}>
+
+export type MobSlideInfo = Readonly<{
+	// Horizontal impulse at the start of a slide (initial speed = impulse / mass).
+	impulse: number
+	// Lowered friction the burst coasts on (below the mob's normal friction so it carries far), restored on end.
+	friction: number
+	// How long (ms) the low-friction coast lasts.
+	durationBounds: Bounds
+	// Rest (ms) after the coast ends before the next slide. Larger = fewer slides.
+	intervalBounds: Bounds
+}>
+
+export type MobJumpInfo = Readonly<{
+	// Rest (ms) between hops (a hop only fires once grounded). Larger = fewer hops.
+	intervalBounds: Bounds
+}>
+
+export type MobRandomFacingInfo = Readonly<{
+	// Weighted offsets to pick from (via getWeightedRandom); \`weight\`s are non-negative,
+	// and at least one must be greater than 0. E.g. \`[{ offset: Math.PI, weight: 2 },
+	// { offset: 0, weight: 1 }]\` faces backwards twice as often as forwards.
+	offsets: readonly Readonly<{ offset: number; weight: number }>[]
+	// Bounds (ms) between re-rolls.
+	intervalBounds: Bounds
+}>
+
+export type ArmourPart = (_TypeOf["armourPieces"])[number]
+
+export type MobArmourPiece = Readonly<{
+	itemName: ItemName
+	enchantmentTier?: EnchantmentTier
+}>
+
+export type TempMobParticleOpts = Readonly<{
+	duration: number
+}> &
+	MobParticleOpts
+
+export type MobParticleOpts = Readonly<Pick<MeshParticleSystemOpts, "texture" | "colorGradients">>
+
+export type ItemNameWithEffects = { itemName: ItemName; effects: readonly Readonly<EffectOpts>[]; healAmt?: number }
+
+export type LevelUpBonuses = RecursiveReadonly<Record<MobFeedLevelUpLevels, MobLevelUpBonus>>
+
+export type EffectOpts = { name: PotionEffect; duration: number; level: number }
+
+export type PotionEffect = (_TypeOf["potionEffects"])[number]
+
+export type MobFeedLevelUpLevels = Exclude<MobFeedLevel, 0>
+
+export type MobLevelUpBonus = (_TypeOf["mobLevelUpBonuses"])[number]
+
+export type MobFeedLevel = InclusiveRange<_TypeOf["MAX_MOB_FEED_LEVEL"]>
+
+export type InclusiveRange<N extends number, Arr extends number[] = []> = Arr["length"] extends N
+	? Arr[number] | Arr["length"]
+	: InclusiveRange<N, [...Arr, Arr["length"]]>
+
+export type Bounds = Readonly<MutableBounds>
+
+export type MutableBounds = {
+		min: number
+		max: number
+	}
+
+export type MobAiState = (_TypeOf["mobAiStates"])[number]
+
+export type MobAiStateParams<TState extends MobAiState> = MobWorldView[TState]
+
+export type MobWorldView = {
+	// The mob is stood still, but it still has awareness of its environment.
+	// For example: if the mob is hostile, it will still chase and attack nearby players.
+	idle: null
+	// The mob is stood still, and it has no awareness of its environment.
+	// It will not even react if provoked.
+	disabled: null
+	// The mob is stood still (idle) and is about to turn.
+	idleBeforeTurning: null
+	// The mob has chosen a new direction at random and is turning to face it.
+	turning: null
+	// The mob is stood still (idle) and is about to walk.
+	idleBeforeWalking: null
+	// The mob is walking in the direction it is facing.
+	walking: null
+	// The mob is running away from the target lifeform.
+	runningAway: { targetId: LifeformId }
+	// The mob is chasing the target lifeform.
+	chasing: { targetId: LifeformId }
+	// A charge-attack mob is stood still, rotating at its \`turnRate\` until it faces the target,
+	// at which point it captures the target's current position and transitions to \`charging\`.
+	turningBeforeCharging: { targetId: LifeformId }
+	// A charge-attack mob is dashing straight at the position of the target captured when it
+	// entered the state, ignoring the target's live position mid-dash (so the charge is dodgeable).
+	charging: { targetId: LifeformId }
+	// The mob is following the target lifeform.
+	// It will stop if it is within the \`minFollowingDistance\` (mob setting) of the target,
+	// and teleport to the target if it is outside the \`maxFollowingDistance\` (mob setting) of the target.
+	following: { targetId: LifeformId }
+	// The mob is stood still looking at the target.
+	watching: { targetId: LifeformId }
+	// The mob is walking towards the position.
+	// It will stop if it is within the \`stoppingRadius\` (mob setting) of the position.
+	walkingToPosition: { pos: Pos }
+	// The mob is running towards the position.
+	// It will stop if it is within the \`stoppingRadius\` (mob setting) of the position.
+	runningToPosition: { pos: Pos }
+}
+
+export type MeshEntityPhysicsOpts = {
+	doPhysics: boolean
+	onCollideTerrain?: () => void // Unsupported for custom code
+	collidesEntities?: boolean
+	collideBits?: number // bitmask category of this entity
+	collideMask?: number // bitmask category of entities this entity collides with
+	heightExpandAmt?: number // expand hitbox height by this amount
+	widthExpandAmt?: number // expand hitbox width by this amount
+}
+
+export type QTEType = keyof QTEDefinitions
+
+export type QTEClientParameters<T extends QTEType = QTEType> = {
+	type: T
+	parameters: QTEParametersForType<T>
+}
+
+export type QTEParametersForType<T extends QTEType> = QTEDefinitions[T]["params"]
+
+export interface QTEDefinitions {
+	progressBar: { params: ProgressBarQteParams; state: ProgressBarQteState }
+	timedClick: { params: TimedClickQteParams; state: TimedClickQteState }
+	gravityBar: { params: GravityBarQteParams; state: GravityBarQteState }
+	precisionBar: { params: PrecisionBarQteParams; state: PrecisionBarQteState }
+	rhythmClick: { params: RhythmClickQteParams; state: RhythmClickQteState }
+}
+
+export type ProgressBarQteParams = Readonly<{
+	/** Starting progress value (0-100) @default 30 */
+	progressStartValue?: number
+	/** How much progress drains each tick while the player isn't clicking @default 0.075 */
+	progressDecreasePerTick: number
+	/** How much progress is gained per click @default 5 */
+	progressPerClick: number
+	/** If true, the QTE fails when progress reaches 0; otherwise progress clamps at 0 @default false */
+	canFail: boolean
+	/** Rich text shown as the QTE prompt @default [{ str: "Click repeatedly to complete!" }] */
+	description: CustomTextStyling
+	/** Icon displayed on the click target @default "fa-solid fa-computer-mouse" */
+	clickIcon: string
+	/** Scale multiplier for the click icon (must be > 0) @default 1 */
+	scale?: number
+	/** Rotation in degrees for the click icon (must be ≥ 0) @default 15 */
+	rotation?: number
+}>
+
+export type ProgressBarQteState = {
+	progress: number
+	clickCount: number
+}
+
+export type TimedClickQteParams = Readonly<{
+	/** Duration in milliseconds the player has to click @default 3000 */
+	timeWindow: number
+	/** Icon displayed on the click target @default "fa-solid fa-computer-mouse" */
+	icon: string
+	/** Rich text shown as the QTE prompt @default [{ str: "Click to complete the QTE!" }] */
+	label: CustomTextStyling
+	/** Whether to display a countdown timer @default true */
+	showTimer: boolean
+	/** Scale multiplier for the icon (must be > 0) @default 1 */
+	scale?: number
+	/** Rotation in degrees for the icon (must be ≥ 0) @default 15 */
+	rotation?: number
+	/** If true, the icon pulses with a breathing animation anchored to the centre @default false */
+	breatheCenter?: boolean
+}>
+
+export type TimedClickQteState = {
+	timeRemaining: number
+	timeWindow: number
+}
+
+export type GravityBarQteParams = Readonly<{
+	/** Starting progress value (0-100) @default 30 */
+	progressStartValue?: number
+	/** Size of the player's catch zone as a fraction of the bar (must be > 0, 0-1) @default 0.25 */
+	catchZoneSize: number
+	/** Speed at which the mover travels along the bar (must be > 0) @default 3 */
+	moverSpeed: number
+	/** How erratically the mover changes direction (higher = more unpredictable) @default 0.8 */
+	moverErraticness: number
+	/** Downward pull on the catch zone when the player isn't holding click @default 1 */
+	gravity: number
+	/** Upward force on the catch zone while the player holds click @default 1.5 */
+	riseSpeed: number
+	/** Progress gained per second while the mover is inside the catch zone @default 8 */
+	progressGainPerSecond: number
+	/** Progress lost per second while the mover is outside the catch zone @default 4 */
+	progressDrainPerSecond: number
+	/** If true, the QTE fails when progress reaches 0; otherwise progress clamps at 0 @default false */
+	canFail: boolean
+	/** Rich text shown as the QTE prompt @default [{ str: "Hold to catch!" }] */
+	description: CustomTextStyling
+	/** Icon displayed on the mover @default "Moonfish" */
+	icon?: string
+}>
+
+export type GravityBarQteState = {
+	catchZonePosition: number
+	catchZoneSize: number
+	moverPosition: number
+	progress: number
+	isCatching: boolean
+}
+
+export type PrecisionBarQteParams = Readonly<{
+	/** Speed of the marker in full bar-widths per second (must be > 0, e.g. 1.0 = one full sweep per second) @default 0.5 */
+	speed: number
+	/** Fraction of the bar that counts as the success zone, centred in the middle (must be > 0, 0-1, e.g. 0.15 = 15%) @default 0.15 */
+	successZoneSize: number
+	/** Rich text shown as the QTE prompt @default [{ str: "Click when the marker is within the green zone." }] */
+	label: CustomTextStyling
+	/** Icon displayed on the marker @default "" */
+	icon?: string
+	/** Scale multiplier for the icon (must be > 0) @default 1 */
+	scale?: number
+	/** Rotation in degrees for the icon (must be ≥ 0) @default 0 */
+	rotation?: number
+}>
+
+export type PrecisionBarQteState = {
+	/** Marker position as 0–1 where 0.5 is the centre */
+	markerPosition: number
+}
+
+export type RhythmClickQteParams = Readonly<{
+	/** Number of successful clicks needed to complete the QTE (must be a positive integer) @default 5 */
+	requiredSuccesses: number
+	/** Duration in milliseconds for the outer circle to shrink from max size to centre (must be > 0) @default 1200 */
+	shrinkDurationMs: number
+	/** Fraction of the inner circle radius that counts as a successful overlap (must be > 0, 0-1, e.g. 0.15 = ±15%) @default 0.15 */
+	toleranceFraction: number
+	/** Max misses allowed before failing. If omitted, unlimited misses are permitted (must be a non-negative integer) @default 3 */
+	maxMisses?: number
+	/** Rich text shown as the QTE prompt @default [{ str: "Click when the circles align!" }] */
+	label: CustomTextStyling
+	/** Icon displayed in the centre of the circles @default "" */
+	icon?: string
+}>
+
+export type RhythmClickQteState = {
+	/** Current outer circle radius as a fraction of the max radius (1 = fully expanded, 0 = at centre) */
+	outerCircleProgress: number
+	/** Number of successful clicks so far */
+	successes: number
+	/** Number of required successes to complete */
+	requiredSuccesses: number
+	/** Number of misses so far */
+	misses: number
+	/** Result of the most recent click: null if no click yet, true if hit, false if miss */
+	lastClickResult: boolean | null
+}
+
+export type QTERequestId = number
+
+export type UiRequestId = number
+
+export type IngameIconName = (_TypeOf["ingameIconNames"])[number]
+
+export type InbuiltEffectInfo = { inbuiltLevel: number; initiatorId?: PlayerId }
+
+export type PlayerPhysicsState<TPhysicsType extends PhysicsType> = Readonly<{ type: TPhysicsType; tier: PhysicsTier<TPhysicsType> }>
+
+export type PhysicsTier<TPhysicsType extends PhysicsType> = PNull<PhysicsTiers[TPhysicsType]>
+
+export type PhysicsTiers = {
+	[0]: null
+	[1]: BoatTier
+	[2]: GliderTier
+	[3]: BalloonTier
+	[4]: SleepingTier
+	[5]: null
+	[6]: CarTier
+	[7]: null
+}
+
+export type SettableVehicleSetting = VehicleSetting | BlockVehicleSetting
+
+export type SettableVehicleSettingValue<TSetting extends SettableVehicleSetting> = TSetting extends VehicleSetting
+	? VehicleSettingValue<TSetting>
+	: BlockVehicleSettingValue<TSetting>
+
+export type VehicleSetting = Exclude<keyof ResolvedPhysicsSettings<PhysicsType>, ByBlockRecordKey | "upwardImpulseOnUse">
+
+export type BlockVehicleSetting = string
+
+export type ResolvedPhysicsSettings<TPhysicsType extends PhysicsType> = DefaultPhysicsTypeSettings & AllPhysicsSettings[TPhysicsType]
+
+export type ByBlockRecordKey = string
+
+export type DefaultPhysicsTypeSettings = Readonly<{
+	/** How heavy it is. Heavier things resist being pushed around, and sink rather than float. */
+	mass: number
+	/** How much water and lava slow it down. \`-1\` uses the world's normal drag. */
+	fluidDrag: number
+	/** \`fluidDrag\` for sideways movement only. \`-1\` falls back to \`fluidDrag\`. */
+	fluidDragHorizontal: number
+	/** \`fluidDrag\` for up-and-down movement only. \`-1\` falls back to \`fluidDrag\`. */
+	fluidDragVertical: number
+	/** How hard gravity pulls it down, compared to a normal player. \`0\` = it never falls. */
+	gravityMultiplier: number
+	/** How wide it is, in blocks. */
+	width: number
+	/** How tall it is, in blocks. */
+	height: number
+	/** Whether the rider is allowed to sprint. */
+	canRun: boolean
+	/**
+	 * How hard the rider pushes off the ground when jumping, compared to a normal jump. \`0\` = cannot jump.
+	 * Multiplies the \`jumpAmount\` client option rather than replacing it, and heavier types need a bigger
+	 * value to reach the same height.
+	 */
+	jumpMultiplier: number
+	/** An upward shove the moment the rider uses the vehicle, like a balloon lifting off. \`0\` = none. */
+	upwardImpulseOnUse: number
+	/** Whether it climbs one-block steps by itself, rather than the rider jumping them. */
+	canAutoStep: boolean
+	/** Overrides \`canAutoStep\` for particular blocks, by block name. Unlisted blocks use \`canAutoStep\`. */
+	canAutoStepByBlock: Readonly<Record<BlockName, boolean>>
+	/**
+	 * Where the rider sits, as \`[x, y, z]\` blocks from the middle of the vehicle. A rideable mob defaults
+	 * to its own ride height rather than to this type's value.
+	 */
+	riderOffset: Pos
+	/** How the rider's body is posed while riding. */
+	pose: PlayerPose
+	/**
+	 * A badge shown to the rider for as long as they ride. \`null\` = none. \`icon\` is an ingame icon or an
+	 * item name. \`name\` must be one that a physics type already uses, such as \`"Driving"\` or \`"Boating"\`,
+	 * because only those are cleared again when the rider gets off.
+	 */
+	effect: PNull<{ name: string; icon: string; duration?: number }>
+	/** How quickly it slows to a stop once the rider stops steering. Bigger = stops sooner. */
+	standingFriction: number
+	/** Its top speed, as a multiplier on normal walking speed. \`0\` = it cannot move. */
+	speedMultiplier: number
+	/** An extra speed multiplier used while on solid ground. */
+	landSpeedMultiplier: number
+	/** An extra speed multiplier used while in water or lava. */
+	fluidSpeedMultiplier: number
+	/** An extra speed multiplier used while in the air. */
+	airSpeedMultiplier: number
+	/**
+	 * Extra speed multipliers for the block underfoot, by block name. Solid ground only, and stacks with
+	 * \`speedMultiplier\` and the land/fluid/air multiplier. When several listed blocks are underfoot, the
+	 * value furthest from \`1\` wins.
+	 */
+	speedMultiplierByBlock: Readonly<Record<BlockName, number>>
+	/** Caps how hard it is pushed while far below the speed it is aiming for, so it takes longer to get going. \`0\` = no cap. */
+	maxPushDistance: number
+	/** How hard steering pushes it. Bigger = it speeds up and changes direction more sharply. */
+	movementForceMultiplier: number
+	/** Turns off the usual steering-driven movement, as for a sleeping player. */
+	disableBaseMovement: boolean
+	/** Whether footstep sounds are silenced. */
+	disableFootstepSounds: boolean
+	/**
+	 * How bouncy walls are: \`0\` stops dead, \`1\` keeps all its speed. Stacks with the \`bounciness\` client
+	 * option. Rebounds have a floor speed, so slow bumps come back faster than they arrived.
+	 */
+	horizontalBounciness: number
+	/**
+	 * How bouncy the floor is: \`0\` lands flat, \`1\` bounces back as fast as it fell. Stacks with the
+	 * \`bounciness\` client option, and has the same rebound floor as \`horizontalBounciness\`.
+	 */
+	verticalBounciness: number
+	/** How fast it must hit a wall, in blocks per second, before \`horizontalBounciness\` applies. \`0\` = any contact. */
+	minHorizontalSpeedToBounce: number
+	/**
+	 * How fast it must be falling, in blocks per second, before \`verticalBounciness\` applies. \`0\` bounces
+	 * off any contact, leaving a bouncy vehicle jiggling in place.
+	 */
+	minVerticalSpeedToBounce: number
+	/** Shakes the camera when it hits a wall hard enough; it need not bounce. \`null\` = no shake. See \`ImpactCameraShakeOpts\`. */
+	horizontalImpactCameraShake: PNull<ImpactCameraShakeOpts>
+	/** Shakes the camera when it hits a floor or ceiling hard enough; it need not bounce. \`null\` = no shake. See \`ImpactCameraShakeOpts\`. */
+	verticalImpactCameraShake: PNull<ImpactCameraShakeOpts>
+	/**
+	 * Makes it steer like a car: left and right turn it rather than sliding it sideways. \`null\` moves
+	 * freely in any direction, like a walking player. See \`SteeringOpts\`.
+	 */
+	steering: PNull<SteeringOpts>
+	/** Locks the direction it faces, in radians, ignoring the camera. \`null\` = it faces wherever the camera or steering points. */
+	fixedHeading: PNull<number>
+	/** Makes it skip across water like a stone once it is fast enough. \`null\` = it floats normally. See \`FluidSkipOpts\`. */
+	fluidSkip: PNull<FluidSkipOpts>
+	/**
+	 * Lets it fly once mid-air and descending. Supported movement types: \`GLIDING\` and \`FLOATING\`.
+	 * \`null\` = it cannot fly. See \`AirborneModeOpts\`.
+	 */
+	airborneMode: PNull<AirborneModeOpts>
+	/** How it moves while flying. \`null\` = it steers the same way it does on the ground. See \`AirborneMovementOpts\`. */
+	airborneMovement: PNull<AirborneMovementOpts>
+	/**
+	 * Caps how fast it falls while flying. Only used when \`airborneMovement\` is \`"heading"\`.
+	 * \`null\` = it falls at full speed. See \`FallSpeedLimitOpts\`.
+	 */
+	airborneFallSpeedLimit: PNull<FallSpeedLimitOpts>
+}>
+
+export type AllPhysicsSettings = {
+	[0]: {}
+	[1]: {}
+	[2]: {}
+	[3]: {}
+	[4]: {}
+	[5]: {}
+	[6]: {}
+	[7]: {}
+}
+
+export type ImpactCameraShakeOpts = Readonly<{
+	/** The crash speed, in blocks per second, needed to shake at all, so small bumps are ignored. */
+	minSpeed: number
+	/** How much shake each extra block per second adds. Shake runs from \`0\` (still) to \`1\` (violent). */
+	intensityPerSpeed: number
+	/** The most shake one crash can cause. */
+	maxIntensity: number
+	/** How long the shake lasts, in milliseconds. */
+	durationMs: number
+}>
+
+export type SteeringOpts = Readonly<{
+	/** How fast it turns, in radians per second. Bigger = snappier steering and tighter corners. */
+	turnRate: number
+	/** How much speed a hard corner costs, from \`0\` (none) to \`1\` (all of it). */
+	corneringSpeedDamping: number
+	/**
+	 * How much it grips the ground. \`0\` slides sideways like a hovercraft on ice; bigger values make it
+	 * follow its nose round corners. Solid ground only, unless \`gripInFluid\` is on.
+	 */
+	gripStrength: number
+	/** Whether it also grips while floating in water, so a boat can corner like a kart. */
+	gripInFluid: boolean
+}>
+
+export type FluidSkipOpts = Readonly<{
+	/** How fast it must be going, in blocks per second, to start skipping. */
+	minSpeed: number
+	/** How much of its speed above \`minSpeed\` becomes upward launch speed. Bigger = higher skips. */
+	launchSpeedFraction: number
+	/** How snappily it leaves the water. Bigger = a sharp pop; smaller = a slow heave. */
+	launchApproachRate: number
+}>
+
+export type AirborneModeOpts = Readonly<{
+	/** Which movement type to switch to: \`GLIDING\` for gliders, \`FLOATING\` for balloons. */
+	activeMovementType: MovementType
+	/** How long the flying lasts, in milliseconds, before it drops the rider. \`null\` = no limit. */
+	durationMs: PNull<number>
+	/** Whether the flying ending also throws the rider off, as a popping balloon does. */
+	exitsVehicleOnEnd: boolean
+}>
+
+export type AirborneMovementOpts = HeadingAirborneMovement | CameraDirectionAirborneMovement
+
+export type FallSpeedLimitOpts = Readonly<{
+	/** The fastest it may fall, in blocks per second. */
+	maxFallSpeed: number
+	/** Roughly how long, in seconds, it takes to slow back to the limit. Smaller = a firmer catch. */
+	slowDownSeconds: number
+	/** Whether to also cancel gravity while holding it back, so the limit is not slowly overpowered. */
+	compensateGravity: boolean
+}>
+
+export type HeadingAirborneMovement = Readonly<{ model: "heading" }>
+
+export type CameraDirectionAirborneMovement = Readonly<{
+	model: "cameraDirection"
+	/** The fastest it can fly. Better gliders get a bigger value, and dive and climb more sharply. */
+	maxSpeed: number
+	/** The slowest it can fly. It never stalls below this, however steeply it climbs. */
+	minSpeed: number
+	/** How much looking up or down changes its speed. Bigger = dives gain speed quickly. */
+	pitchAcceleration: number
+	/** How much drag slows it each tick. \`0\` = none. */
+	friction: number
+	/** How many ticks an outside shove - a fuel boost, or knockback - keeps its momentum before flight takes over again. */
+	impulseDecayTicks: number
+	/** How strongly it is nudged forwards, then gently downwards, so a level glider sinks slowly. */
+	biasMagnitude: number
+	/** How much leftover speed from a shove is shed each tick. */
+	excessVelocityBleedPerTick: number
+}>
+
+export type PerBlockVehicleSetting = (_TypeOf["perBlockVehicleSettings"])[number]
+//@ts-ignore
+export type VehicleSettingValue<TVehicleSetting extends StoredVehicleSetting> = ResolvedPhysicsSettings<PhysicsType>[TVehicleSetting]
+
+export type BlockVehicleSettingValue<TSetting extends string> = {
+	[TPerBlockSetting in PerBlockVehicleSetting]: TSetting extends string
+		? PerBlockVehicleSettingValue<TPerBlockSetting>
+		: never
+}[PerBlockVehicleSetting]
+//@ts-ignore
+export type PerBlockVehicleSettingValue<TSetting extends PerBlockVehicleSetting> = VehicleSettingValue<string>[BlockName]
+
+export type MeshEntityVehicleType = (_TypeOf["meshEntityVehiclesTypes"])[number]
+
+export type VehicleSpawnOpts = Partial<{
+	spawnerId: PlayerId
+}>
+
+export type AngleDir = {
+	theta: number
+	phi: number
+}
+
+export type BlockRaycastResult = PNull<{
+	blockID: BlockId // The block ID of the block that was hit
+	position: Pos // The position of the block that was hit
+	normal: Pos // The normal of the face that was hit
+	adjacent: Pos // The position of the block adjacent to the hit face
+}>
+
+export type MeshParticleSystemUpdates = Record<EntityId, Record<NodeName, MeshParticleSystemUpdate>>
+
+export type MeshParticleSystemUpdate = {
+	particleSystemDir1?: number[]
+	particleSystemDir2?: number[]
+	particleSystemMinSize?: number
+	particleSystemMaxSize?: number
+	particleSystemPlayingState?: boolean
+	particleSystemColorGradients?: TimeColorGradient[]
+}
+
+export type UgcCurrencyInfo = {
+	amount: number
+	icon: string
+	iconColour?: string
+	persistent?: boolean
+	hidden?: boolean
+	subtext?: string | CustomTextStyling
+}
+
+export type UserCallbacks = "tick" | "onClose" | "onPlayerJoin" | "onPlayerLeave" | "onPlayerJump" | "onRespawnRequest" | "playerCommand" | "onPlayerChat" | "onPlayerChangeBlock" | "onBlockStand" | "onBlockStandStart" | "onBlockStandStop" | "onPlayerAttemptCraft" | "onPlayerCraft" | "onPlayerAttemptOpenChest" | "onPlayerOpenedChest" | "onPlayerMoveItemOutOfInventory" | "onPlayerDropItem" | "onPlayerPickedUpItem" | "onPlayerSelectInventorySlot" | "onPlayerAttack" | "onPlayerDamagingOtherPlayer" | "onPlayerDamagingMob" | "onMobDamagingPlayer" | "onMobDamagingOtherMob" | "onAttemptKillPlayer" | "onPlayerKilledOtherPlayer" | "onMobKilledPlayer" | "onPlayerKilledMob" | "onMobKilledOtherMob" | "onPlayerPotionEffect" | "onPlayerDamagingMeshEntity" | "onPlayerBreakMeshEntity" | "onPlayerUsedThrowable" | "onPlayerThrowableHitTerrain" | "onTouchscreenActionButton" | "onPlayerMoveInvenItem" | "onPlayerMoveItemIntoIdxs" | "onPlayerSwapInvenSlots" | "onPlayerMoveInvenItemWithAmt" | "onPlayerAttemptAltAction" | "onPlayerAltAction" | "onPlayerClick" | "onPlayerClickUp" | "onClientOptionUpdated" | "onMobSettingUpdated" | "onInventoryUpdated" | "onChestUpdated" | "onWorldChangeBlock" | "onCreateBloxdMeshEntity" | "onEntityCollision" | "onPlayerAttemptSpawnMob" | "onWorldAttemptSpawnMob" | "onPlayerSpawnMob" | "onWorldSpawnMob" | "onWorldAttemptDespawnMob" | "onMobDespawned" | "onPlayerAttemptSpawnVehicle" | "onWorldAttemptSpawnVehicle" | "onPlayerSpawnVehicle" | "onWorldSpawnVehicle" | "onVehicleDespawned" | "onEntityDeleted" | "onChunkLoaded" | "onPlayerRequestChunk" | "onItemDropCreated" | "onPlayerStartChargingItem" | "onPlayerFinishChargingItem" | "onPlayerAttemptFish" | "onPlayerSucceededFishCatch" | "onPlayerFailedFishCatch" | "onPlayerFinishQTE" | "onPlayerToggledShopMenu" | "onPlayerBoughtShopItem" | "onPlayerPlayedEmote" | "onPlayerEnteredVehicle" | "onPlayerExitedVehicle" | "onUiRequestResponded" | "doPeriodicSave"
+
+export type WorldGamemode = (_TypeOf["worldGamemodes"])[number]
+
+export type QueuedCommandId = string
+
+export type QueuedStatusString = (_TypeOf["QUEUED_COMMAND_STATUS_STRINGS"])[keyof _TypeOf["QUEUED_COMMAND_STATUS_STRINGS"]]
+
+export type UiRequestClientParameters = {
+	type: "standard" | "rewardedAd"
+	title: string | CustomTextStyling
+	icons?: string[]
+	acceptText?: string | CustomTextStyling
+	denyText?: string | CustomTextStyling
+	successText?: string | CustomTextStyling
+	autoDismissAfterMs?: number
+}
+
+export type MultiBlockInfo = {
+	positions: { block: string; id: number; x: number; y: number; z: number }[]
+}
+
+export type BoughtShopItem = Omit<ShopItem, "boughtCallback" | "schematicId" | "isRewardedAd">
+
+export type OnPlayerChatObjectResponse = Record<PlayerId, false | ChatMessageObject>
+
+export type ChatMessageObject = {
+	prefixContent?: ChatTags
+	chatContent?: CustomTextStyling
+}
+
+export type FishingAttemptOptions = {
+	/** Item selected for this attempt's reward. Defaults to an engine-selected fish. */
+	caughtItemName?: ItemName
+	/** Delay after entering water, in milliseconds. Defaults to the rod's metadata config. */
+	biteDelayMs?: number
+	/** Defaults to a timed-click QTE with a nine-second window. */
+	qte?: { [T in QTEType]: QTEClientParameters<T> }[QTEType]
+}
+
+export interface _TypeOf {
+	lifeformBodyParts: readonly ["Torso", "Head", "ArmRight", "ArmLeft", "LegLeft", "LegRight"]
+	enchantmentPerks: readonly ["Damage", "Attack Speed", "Critical Damage", "Protection", "Health", "Health Regen", "Stomp Damage", "Knockback Resist", "Arrow Speed", "Arrow Damage", "Quick Charge", "Break Speed", "Momentum", "Mining Yield", "Farming Yield", "Mining Aura", "Digging Aura", "Lumber Aura", "Farming Aura", "Horizontal Knockback", "Vertical Knockback"]
+	enchantmentTiers: readonly ["Tier 1", "Tier 2", "Tier 3", "Tier 4", "Tier 5"]
+	ranks: readonly ["developer", "admin", "super", "youtuber", "creatorLevel1", "creatorLevel2", "creatorLevel3"]
+	noaActions: readonly ["forward", "backward", "left", "right", "sprint", "jump", "crouch", "primary-fire", "alt-fire", "SpecialAction1", "SpecialAction2", "ReloadGun", "DropItem", "mid-fire", "Zoom", "SwapCameraZoom", "OpenInventory", "OpenLobbyLeaderboard", "OpenShop", "OpenCharacterCustomization", "OpenSettings", "OpenInviteLink", "OpenTasksAndLeaderboard", "OpenCodeEditor", "OpenEmoteWheel", "HideUi", "ShowDebugOverlay", "HotBarSlot1", "HotBarSlot2", "HotBarSlot3", "HotBarSlot4", "HotBarSlot5", "HotBarSlot6", "HotBarSlot7", "HotBarSlot8", "HotBarSlot9", "HotBarSlot10", "toggleFreeCam", "freeCamForward", "freeCamBackward", "freeCamLeft", "freeCamRight", "freeCamUp", "freeCamDown", "recordGame", "recordClip", "replayViewerOpen", "replayPlayPause", "replaySkipBack", "replaySkipForward", "replayChangeCameraMode", "replayLoad", "replaySave", "replaySaveAs", "replayExit", "replaySpeedUp", "replaySpeedDown", "replayTimelineZoomIn", "replayTimelineZoomOut", "replayRecordKeyframe", "replayExportVideo"]
+	shopItemBadgeTypes: readonly ["new", "lucky"]
+	playerMeshNamedNodes: readonly ["TorsoNode", "HeadMesh", "ArmRightMesh", "ArmLeftMesh", "LegLeftMesh", "LegRightMesh"]
+	healthbarDisplays: readonly ["always", "never", "onDamage"]
+	nameTagBorderStyles: readonly ["solid", "glow", "double"]
+	nameTagBorderTargets: readonly ["both", "nametag", "healthbar"]
+	particlePresets: { readonly damageInner: unknown; readonly damageOuter: unknown; readonly bouncinessInner: unknown; readonly bouncinessOuter: unknown; readonly healthRegenInner: unknown; readonly healthRegenOuter: unknown; readonly speedInner: unknown; readonly speedOuter: unknown; readonly damageReductionInner: unknown; readonly damageReductionOuter: unknown; readonly invisibleInner: unknown; readonly invisibleOuter: unknown; readonly jumpBoostInner: unknown; readonly jumpBoostOuter: unknown; readonly knockbackInner: unknown; readonly knockbackOuter: unknown; readonly poisonedInner: unknown; readonly poisonedOuter: unknown; readonly slownessInner: unknown; readonly slownessOuter: unknown; readonly weaknessInner: unknown; readonly weaknessOuter: unknown; readonly cleansedInner: unknown; readonly cleansedOuter: unknown; readonly instantDamageInner: unknown; readonly instantDamageOuter: unknown; readonly instantHealthInner: unknown; readonly instantHealthOuter: unknown; readonly hasteInner: unknown; readonly hasteOuter: unknown; readonly shieldInner: unknown; readonly shieldOuter: unknown; readonly doubleJumpInner: unknown; readonly doubleJumpOuter: unknown; readonly heatResistanceInner: unknown; readonly heatResistanceOuter: unknown; readonly thiefInner: unknown; readonly thiefOuter: unknown; readonly miningYieldInner: unknown; readonly miningYieldOuter: unknown; readonly brainRotInner: unknown; readonly brainRotOuter: unknown; readonly auraInner: unknown; readonly auraOuter: unknown; readonly wallClimbingInner: unknown; readonly wallClimbingOuter: unknown; readonly airWalkInner: unknown; readonly airWalkOuter: unknown; readonly pickpocketerInner: unknown; readonly pickpocketerOuter: unknown; readonly lifestealInner: unknown; readonly lifestealOuter: unknown; readonly blindnessInner: unknown; readonly blindnessOuter: unknown; readonly poopyInner: unknown; readonly poopyOuter: unknown; readonly glowingInner: unknown; readonly glowingOuter: unknown; readonly nightVisionInner: unknown; readonly nightVisionOuter: unknown; readonly xRayVisionInner: unknown; readonly xRayVisionOuter: unknown; readonly defaultFirecrackerSmall: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly defaultFirecrackerLarge: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mango: unknown; readonly yellowFirecrackerSmall: unknown; readonly yellowFirecrackerLarge: unknown; readonly limeFirecrackerSmall: unknown; readonly limeFirecrackerLarge: unknown; readonly greenFirecrackerSmall: unknown; readonly greenFirecrackerLarge: unknown; readonly cyanFirecrackerSmall: unknown; readonly cyanFirecrackerLarge: unknown; readonly blueFirecrackerSmall: unknown; readonly blueFirecrackerLarge: unknown; readonly purpleFirecrackerSmall: unknown; readonly purpleFirecrackerLarge: unknown; readonly pinkFirecrackerSmall: unknown; readonly pinkFirecrackerLarge: unknown; readonly redFirecrackerSmall: unknown; readonly redFirecrackerLarge: unknown; readonly orangeFirecrackerSmall: unknown; readonly orangeFirecrackerLarge: unknown; readonly blackFirecrackerSmall: unknown; readonly blackFirecrackerLarge: unknown; readonly brownFirecrackerSmall: unknown; readonly brownFirecrackerLarge: unknown; readonly grayFirecrackerSmall: unknown; readonly grayFirecrackerLarge: unknown; readonly lightBlueFirecrackerSmall: unknown; readonly lightBlueFirecrackerLarge: unknown; readonly lightGrayFirecrackerSmall: unknown; readonly lightGrayFirecrackerLarge: unknown; readonly magentaFirecrackerSmall: unknown; readonly magentaFirecrackerLarge: unknown; readonly whiteFirecrackerSmall: unknown; readonly whiteFirecrackerLarge: unknown; readonly brainRot: unknown; readonly stomp: unknown; readonly fertiliser: unknown; readonly bonemeal: unknown; readonly mobTameSuccess: unknown; readonly mobTameFailure: unknown; readonly mobCatch: unknown; readonly spawnCaughtMob: unknown; readonly mobFeedDefault: unknown; readonly mobFeedSuperliked: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobFeedLike: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobFeedNeutral: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobFeedDisliked: { readonly colorGradients: TimeColorGradient[]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobDeath: unknown; readonly mobDeathSoul: unknown; readonly boardShopSuccess: unknown; readonly mobSpawnerBlockFail: { readonly colorGradients: [{ readonly timeFraction: 0; readonly minColor: [80, 80, 80, 1]; readonly maxColor: [160, 160, 160, 1]; }]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobSpawnerBlockPassive: { readonly colorGradients: [{ readonly timeFraction: 0; readonly minColor: [0, 200, 50, 1]; readonly maxColor: [0, 255, 100, 1]; }]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobSpawnerBlockNeutral: { readonly colorGradients: [{ readonly timeFraction: 0; readonly minColor: [200, 200, 0, 1]; readonly maxColor: [255, 255, 0, 1]; }]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobSpawnerBlockHostile: { readonly colorGradients: [{ readonly timeFraction: 0; readonly minColor: [200, 10, 0, 1]; readonly maxColor: [255, 20, 0, 1]; }]; readonly texture: string; readonly minLifeTime: number; readonly maxLifeTime: number; readonly minEmitPower: number; readonly maxEmitPower: number; readonly minSize: number; readonly maxSize: number; readonly gravity: number[]; readonly velocityGradients: VelocityGradient[]; readonly blendMode: ParticleSystemBlendMode; readonly dir1: number[]; readonly dir2: number[]; readonly manualEmitCount: number; readonly hideDist: number; }; readonly mobSpawnOrb: unknown; readonly aura: unknown; }
+	gunCategories: readonly ["semi_automatic", "submachine", "rifle", "pistol", "shotgun"]
+	customItemStats: readonly ["ttb", "displayName", "harvestLevel", "stoodOnSpeedMultiplier", "specialToolDrop", "specialToolBonusDrops", "description", "altActionable", "eatHealAmt", "eatShieldAmt", "damage", "attackRange", "attackCooldownMs", "secondaryDamage", "absorbThrowable", "armourReduction", "CrosshairText", "gunStats", "showInCreativeInven"]
+	lifeformTypes: readonly ["Player", "Pig", "Cow", "Sheep", "Horse", "Deer", "Slime", "Wolf", "Wildcat", "Spirit Golem", "Spirit Wolf", "Spirit Bear", "Spirit Stag", "Spirit Gorilla", "Bear", "Stag", "Gold Watermelon Stag", "Gorilla", "Cave Golem", "Draugr Zombie", "Draugr Skeleton", "Frost Golem", "Frost Zombie", "Frost Skeleton", "Draugr Knight", "Draugr Huntress", "Magma Golem", "Draugr Warper", "Frost Wraith", "Draugr Reaver", "Stalker", "Crone", "Iron Guardian", "Gold Guardian", "Diamond Guardian", "Moonstone Guardian", "NPC", "67", "Bobino Musculino", "Capitano Explovissimo"]
+	cosmeticTypes: readonly ["skin", "hat", "head", "eyebrows", "eyes", "back", "body", "legs", "shoes", "cape", "nameColour", "profileEffect", "emote"]
+	playerPoses: readonly ["standing", "sitting", "zombie", "gliding", "driving", "sleeping", "riding"]
+	mobVariations: { readonly Pig: readonly ["default"]; readonly Cow: readonly ["default", "cream"]; readonly Sheep: readonly ["default", "black", "red", "orange", "pink", "purple", "yellow", "blue", "brown", "cyan", "gray", "green", "lightBlue", "lightGray", "lime", "magenta"]; readonly Horse: readonly ["default", "black", "brown", "cream"]; readonly Slime: readonly ["default"]; readonly "Cave Golem": readonly ["default", "iron", "corrupted"]; readonly "Draugr Zombie": readonly ["default", "longHairChestplate", "longHairClothed", "shortHairClothed", "flower", "flower2", "mushroom", "vine", "vine2", "corrupted", "corrupted2"]; readonly "Draugr Skeleton": readonly ["default"]; readonly "Frost Golem": readonly ["default"]; readonly "Frost Zombie": readonly ["default", "longHairChestplate", "shortHairClothed"]; readonly "Frost Skeleton": readonly ["default"]; readonly "Draugr Knight": readonly ["default"]; readonly Wolf: readonly ["default", "white", "brown", "grey", "spectral"]; readonly Bear: readonly ["default"]; readonly Deer: readonly ["default"]; readonly Stag: readonly ["default"]; readonly "Gold Watermelon Stag": readonly ["default"]; readonly Gorilla: readonly ["default"]; readonly Wildcat: readonly ["default", "tabby", "grey", "black", "calico", "siamese", "leopard"]; readonly "Magma Golem": readonly ["default"]; readonly "Draugr Huntress": readonly ["default", "chainmail"]; readonly "Spirit Golem": readonly ["default"]; readonly "Spirit Wolf": readonly ["default"]; readonly "Spirit Bear": readonly ["default"]; readonly "Spirit Stag": readonly ["default"]; readonly "Spirit Gorilla": readonly ["default"]; readonly "Draugr Warper": readonly ["default"]; readonly "Frost Wraith": readonly ["default"]; readonly "Draugr Reaver": readonly ["default"]; readonly Stalker: readonly ["default", "crimson", "frost", "void"]; readonly Crone: readonly ["default"]; readonly "Iron Guardian": readonly ["default"]; readonly "Gold Guardian": readonly ["default"]; readonly "Diamond Guardian": readonly ["default"]; readonly "Moonstone Guardian": readonly ["default"]; readonly NPC: readonly ["default", "emma", "leo", "isabel", "sanjay", "imara", "enoch", "sara", "carmen"]; readonly "67": readonly ["default"]; readonly "Bobino Musculino": readonly ["default"]; readonly "Capitano Explovissimo": readonly ["default"]; }
+	mobTypes: readonly ["Pig", "Cow", "Sheep", "Horse", "Deer", "Slime", "Wolf", "Wildcat", "Spirit Golem", "Spirit Wolf", "Spirit Bear", "Spirit Stag", "Spirit Gorilla", "Bear", "Stag", "Gold Watermelon Stag", "Gorilla", "Cave Golem", "Draugr Zombie", "Draugr Skeleton", "Frost Golem", "Frost Zombie", "Frost Skeleton", "Draugr Knight", "Draugr Huntress", "Magma Golem", "Draugr Warper", "Frost Wraith", "Draugr Reaver", "Stalker", "Crone", "Iron Guardian", "Gold Guardian", "Diamond Guardian", "Moonstone Guardian", "NPC", "67", "Bobino Musculino", "Capitano Explovissimo"]
+	mobSettings: readonly ["variation", "name", "maxHealth", "initialHealth", "idleSound", "attackSound", "secondaryAttackSound", "hurtSound", "onDeathItemDrops", "onDeathParticleTexture", "onDeathAura", "baseWalkingSpeed", "baseRunningSpeed", "walkingSpeedMultiplier", "runningSpeedMultiplier", "jumpCount", "baseJumpImpulseXZ", "baseJumpImpulseY", "jumpMultiplier", "runAwayRadius", "chaseRadius", "territoryRadius", "hostilityRadius", "stoppingRadius", "attackInterval", "attackRadius", "secondaryAttackRadius", "attackDamage", "secondaryAttackDamage", "isReceivingDamageCooldownGlobal", "knockbackReceivedMultiplier", "attackImpulse", "secondaryAttackImpulse", "rangedAttackInaccuracy", "burstAttackInfo", "secondaryBurstAttackInfo", "heldItemName", "heldItemEnchantmentTier", "armour", "attackItemName", "secondaryAttackItemName", "swingArmOnAttack", "swingArmOnSecondaryAttack", "attackEffectName", "attackEffectDuration", "warpTargetSpecialAttackInfo", "combatTetherInfo", "evadeInfo", "chargeSpecialAttackInfo", "tameInfo", "onTamedHealthMultiplier", "petInfo", "ownerDbId", "minFollowingRadius", "maxFollowingRadius", "isRideable", "healthRegen", "ridingSpeedMult", "bridgeInfo", "walkingSlideInfo", "runningSlideInfo", "walkingJumpInfo", "runningJumpInfo", "walkingRandomFacingInfo", "runningRandomFacingInfo", "metaInfo"]
+	armourPieces: readonly ["Helmet", "Chestplate", "Gauntlets", "Leggings", "Boots"]
+	potionEffects: readonly ["Speed", "Damage Reduction", "Damage", "Invisible", "Jump Boost", "Knockback", "Poisoned", "Slowness", "Weakness", "Cleansed", "Instant Damage", "Health Regen", "Instant Health", "Haste", "Shield", "Double Jump", "Heat Resistance", "Thief", "X-Ray Vision", "Mining Yield", "Brain Rot", "Aura", "Wall Climbing", "Air Walk", "Pickpocketer", "Lifesteal", "Bounciness", "Blindness", "Poopy", "Glowing", "Night Vision"]
+	MAX_MOB_FEED_LEVEL: 5
+	mobLevelUpBonuses: readonly ["Renaming", "Special Drops", "Thorns", "Rainbow Wool", "Max Health +", "Damage +", "Riding Speed +", "Double Poop", "Self Yield", "Painting", "Friends", "Pack Leader", "Poison Claws", "Mob Power", "Mob Yield", "Feed Aura", "Antlers"]
+	mobAiStates: readonly ["idle", "disabled", "idleBeforeTurning", "turning", "idleBeforeWalking", "walking", "runningAway", "chasing", "turningBeforeCharging", "charging", "following", "watching", "walkingToPosition", "runningToPosition"]
+	ingameIconNames: readonly ["Damage", "Damage Reduction", "Speed", "VoidJump", "Fist", "Frozen", "Hydrated", "Invisible", "Jump Boost", "Poisoned", "Slowness", "Weakness", "Health Regen", "Haste", "Double Jump", "Heat Resistance", "Gliding", "Boating", "Obsidian Boating", "Riding", "Bunny Hop", "FallDamage", "Feather Falling", "Thief", "X-Ray Vision", "Mining Yield", "Brain Rot", "Rested Damage", "Rested Haste", "Rested Speed", "Rested Farming Yield", "Rested Aura", "Blindness", "Pickpocketer", "Lifesteal", "Bounciness", "Air Walk", "Wall Climbing", "Thorns", "Poopy", "Glowing", "Night Vision", "Draugr Knight Head", "Draugr Warper Head", "Magma Golem Head", "Mystery Fish", "Damage Enchantment", "Critical Damage Enchantment", "Attack Speed Enchantment", "Protection Enchantment", "Health Enchantment", "Health Regen Enchantment", "Stomp Damage Enchantment", "Knockback Resist Enchantment", "Arrow Speed Enchantment", "Arrow Damage Enchantment", "Quick Charge Enchantment", "Break Speed Enchantment", "Momentum Enchantment", "Mining Yield Enchantment", "Farming Yield Enchantment", "Mining Aura Enchantment", "Digging Aura Enchantment", "Lumber Aura Enchantment", "Farming Aura Enchantment", "Vertical Knockback Enchantment", "Horizontal Knockback Enchantment", "Self Yield", "Friends", "Riding Speed", "Feed Aura", "Double Poop", "Mob Slayer", "Rainbow Wool", "Pack Leader", "Max Health", "Poison Claws", "Mob Yield", "Antlers Bonus", "Health", "HealthShield", "Cross", "Friendship", "Dotted Friendship", "Hunger", "Empty Hunger", "Pixelated Heart", "Question Mark", "Trader Black", "Trader Blue", "Trader Piggy"]
+	perBlockVehicleSettings: readonly ["canAutoStep", "speedMultiplier"]
+	meshEntityVehiclesTypes: readonly ["Boat", "Obsidian Boat", "Hovercraft", "Yellow Kart", "White Kart", "Red Kart", "Purple Kart", "Pink Kart", "Orange Kart", "Magenta Kart", "Lime Kart", "Light Gray Kart", "Light Blue Kart", "Green Kart", "Gray Kart", "Cyan Kart", "Brown Kart", "Blue Kart", "Black Kart", "Off Roader", "Light Blue Car", "Speedboat"]
+	worldGamemodes: readonly ["survival", "peaceful", "creative", "survivaladventure", "peacefuladventure", "spectator"]
+	QUEUED_COMMAND_STATUS_STRINGS: { readonly 0: "NOT_IN_QUEUE"; readonly 1: "WAITING_TO_RUN"; readonly 2: "CURRENTLY_RUNNING"; }
+	ItemMetaInfo: {
+		readonly rootName: string
+		readonly rootId: number
+		readonly metaStr: string
+		readonly rot: number | null
+		readonly open: boolean | null
+		readonly halfblockPlacement: HalfblockPlacement | null
+		readonly growing: true | null
+		readonly treeBase: true | null
+		readonly treeCanopy: true | null
+		readonly books: number | null
+		readonly freshlyGrown: true | null
+		readonly roots: true | null
+		readonly lava: true | null
+		readonly top: true | null
+		readonly grassRoots: true | null
+		readonly breaking: true | null
+		readonly flashing: true | null
+		readonly charging: number | null
+		readonly direction: number | null
+		readonly requiresAmmo: true | null
+		readonly woodType: string | null
+		readonly caughtMobType: MobType | null
+	}
+	BlockMetadataItem: {
+		displayName: string | TranslatedText | CustomTextStyling
+		ttb?: number
+		textureInfo: | string
+			| (string | AnimParams)[]
+			| [number, number, number, number?]
+			| ({
+					colour?: [number, number, number, number?]
+			  } & AnimParams)
+		texturePerSide: number[]
+		harvestType: HarvestType
+		transTex: boolean
+		model: BlockMetadataModelType | string
+		itemTexture: string
+		drops: string
+		solid: boolean
+		heldItemScale: number
+		modelScale: number
+		meta: ItemMetaInfo
+		rootMetaDesc: string
+		particlesIgnoreBlack: boolean
+		harvestLevel: number
+		fluid: boolean
+		specialToolDrop: SpecialToolDrop
+		specialToolBonusDrops: RecursiveReadonly<Record<string, { bonusDrop: string; probabilityOfDrop: number }[]>>
+		damage: number
+		stoodOnSpeedMultiplier: number
+		description: string | TranslatedText | CustomTextStyling
+		altActionable: boolean
+		soundType: { break: SoundType; place: SoundType }
+		unlitStandaloneMesh: boolean
+		customPlanesInfo: { textureIdx: number; yRot: number }[]
+		customModelInfo: {
+			yOffset?: number
+			/** Only honoured by onRotatableCreate. */
+			yRotOffset?: number
+			/** Only honoured by onRotatableCreate. */
+			xRotOffset?: number
+			unlit?: boolean
+			emissiveColor?: Vec3
+			backFaceCulling?: boolean
+		}
+		absorbThrowable?: boolean
+		CrosshairText?: string | CustomTextStyling
+		/** Light emission as [R, G, B], each 0-15. Omit for no emission. */
+		lightEmission?: Vec3
+		/** Sky light emission level: null or 0-15. 0 is equivalent to null (no emission). */
+		skyLightEmission?: number
+		/** Light attenuation when light passes through this block. Default: 1 for air/transparent, 3 for fluid, 15 for opaque. */
+		lightFilter?: number
+		name: string
+		id: number
+		atlasIdx: number | number[]
+		stackable: boolean
+		heldItemGlb?: string
+		blockModel: string
+		blockModelItem: boolean
+		twoDBlockItem: boolean
+		rotatableOffsetAmt: number
+		canBePlacedOver: boolean
+		onMinedAura: number
+		showInCreativeInven?: boolean
+		gunStats?: GunStatsOverride
+	}
+	NonBlockMetadataItem: {
+		displayName?: string | TranslatedText | CustomTextStyling
+		type: "Item" | "Tool" | "Gun" | "FullAuto" | "Armour" | "GrayscaleArmour" | "Chargeable"
+		textureInfo: string | string[] | [number, number, number, number?]
+		weight: number
+		heldItemScale: number
+		heldItemGlb?: string
+		/** Extra Euler rotation (radians) applied only to the first-person held mesh, on top of the default hand pose. */
+		firstPersonHeldRotationOffset?: Vec3
+		/** Extra Euler rotation (radians) applied only to the third-person held mesh, on top of the default pose. */
+		thirdPersonHeldRotationOffset?: Vec3
+		description?: string | TranslatedText | CustomTextStyling
+		stackable: boolean
+		eatable?: boolean
+		chargeSound?: string
+		afterEatenItem?: ItemName
+		eatShieldAmt?: number
+		eatHealAmt?: number
+		chargeStages?: number
+		chargeTime?: number
+		minChargeStateToUse?: number
+		damage?: number
+		attackRange?: number
+		secondaryDamage?: number
+		holdAsAiming?: boolean
+		hideAimingUI?: boolean
+		requiresArrow?: boolean
+		knockbackHorizontalScalar?: number
+		knockbackVerticalScalar?: number
+		attackCooldownMs?: number
+		abilityCooldownMs?: number
+		dashImpulse?: number
+		comboInfo?: WeaponComboInfo
+		velocityMultiplier?: number
+		fishingRodInfo?: {
+			/** Minimum and maximum engine fishing bite delay, in milliseconds. */
+			biteDelayMs: readonly [number, number]
+		}
+		harvests?: HarvestType
+		multiplier?: number
+		level?: number
+		lumberjackHeight?: number
+		armourReduction?: number
+		knockbackReduction?: number
+		id?: number
+		name?: string
+		isCustom?: boolean
+		/** Light emission as [R, G, B], each 0-15. Omit for no emission. */
+		lightEmission?: Vec3
+		/** Spotlight reach in blocks. When set, the local player emits a directional beam (instead of the default omnidirectional held light) while holding this item, or wearing it if a helmet. */
+		spotlightRange?: number
+		/** Full cone apex angle in degrees (smaller = tighter beam). Only used with \`spotlightRange\`; omit for the default width. */
+		spotlightConeAngle?: number
+		meta?: ItemMetaInfo
+		rootMetaDesc?: string
+		keepMetaInChest?: boolean
+		gunType?: GunCategory
+		scopeType?: "none" | "sniper"
+		muzzleFlashOffsetFromGun?: Vec3
+		muzzleFlashScale?: number
+		autoFireWithMouse?: boolean
+		fireRate?: number
+		fireRateWithHeldTouch?: number
+		burstCount?: number
+		burstDelay?: number
+		shotPelletCount?: number
+		reloadTime?: number
+		clipSize?: number
+		reloadBulletsIndividually?: boolean
+		bulletReloadTime?: number
+		cockTime?: number
+		tagSpeedMult?: number
+		subsequentTagSpeedReductionScalar?: number
+		inaccuracyStanding?: number
+		inaccuracyFromShot?: number
+		inaccuracyMovement?: number
+		yVelocityInaccuracy?: number
+		inaccuracyFromJump?: number
+		altInaccuracyStanding?: number
+		altInaccuracyFromShot?: number
+		altInaccuracyMovement?: number
+		recoveryRate?: number
+		aimZoomFactor?: number
+		kickbackDecreaseRate?: number
+		minKickback?: number
+		maxKickback?: number
+		kickbackRate?: number
+		hasVerticalInaccuracy?: boolean
+		keepScopeOnShot?: boolean
+		msPerRound?: number
+		msPerRoundTouchScreen?: number
+		altYVelocityInaccuracy?: number
+		altInaccuracyFromJump?: number
+		fireInterval?: number
+		gunStats?: GunStatsOverride
+		showInCreativeInven?: boolean
+	}
+	LoadedChunk: {
+		anySetsRan: boolean
+		readonly lastUpdated: number
+		set(x: number, y: number, z: number, id: BlockId): void
+		get(x: number, y: number, z: number): number
+		/**
+		 * Returns the underlying array of the chunk
+		 * This exists for performance reasons only
+		 * Be careful using this - updating the data directly without calling set or setUnderlying will result in inconsistent state
+		 */
+		getUnderlyingData(): Uint16Array<ArrayBufferLike>
+		setUnderlying(idx: number, id: BlockId): void
+	}
+}
+
+export type ItemMetaInfo = _TypeOf["ItemMetaInfo"]
+
+export type BlockMetadataItem = _TypeOf["BlockMetadataItem"]
+
+export type NonBlockMetadataItem = _TypeOf["NonBlockMetadataItem"]
+
+export type LoadedChunk = _TypeOf["LoadedChunk"]
+
+export type Song = "Adigold - A Place To Be Free" | "Adigold - Butterfly Effect" | "Adigold - Dreamless Sleep" | "Adigold - Frozen Pulse" | "Adigold - Frozen Skies" | "Adigold - Healing Thoughts" | "Adigold - Here Forever" | "Adigold - Just a Little Hope" | "Adigold - Just Like Heaven" | "Adigold - Memories Remain" | "Adigold - Place To Be" | "Adigold - The Riverside" | "Adigold - The Wonder" | "Adigold - Vetrar (Cut B)" | "Awkward Comedy Quirky" | "battle-ship-111902" | "cdk-Silence-Await" | "corsairs-studiokolomna-main-version-23542-02-33" | "ghost-Reverie-small-theme" | "happy" | "Heroic-Demise-New" | "I-am-the-Sea-The-Room-4" | "Juhani Junkala [Retro Game Music Pack] Ending" | "Juhani Junkala [Retro Game Music Pack] Level 1" | "Juhani Junkala [Retro Game Music Pack] Level 2" | "Juhani Junkala [Retro Game Music Pack] Level 3" | "Juhani Junkala [Retro Game Music Pack] Title Screen" | "LonePeakMusic-Highway-1" | "Mojo Productions - Pirates" | "Mojo Productions - Sneaky Jazz" | "Mojo Productions - The Sneaky" | "Mojo Productions - The Sneaky Jazz" | "progress" | "raise-the-sails-152124" | "ramblinglibrarian-I-Have-Often-T" | "Slow-Motion-Bensound" | "snowflake-Ethereal-Space" | "the-epic-adventure-131399" | "TownTheme" | "The Suspense Ambient" | "Epic1" | "Epic2" | "Emotional Epic" | "Enemy Marked"
+
+export type ParticleSystemBlendMode = 0 | 1 | 2 | 3 | 4
+
+export type HalfblockPlacement = 0 | 1 | 2
+
+export type WalkThroughType = 0 | 1 | 2
+
+export type LobbyType = 0 | 1 | 2
+
+export type PhysicsType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
+
+export type BoatTier = 0 | 1 | 2
+
+export type GliderTier = 0 | 1 | 2 | 3
+
+export type BalloonTier = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15
+
+export type SleepingTier = 0 | 1 | 2 | 3
+
+export type CarTier = 0 | 1 | 2
+
+export type MovementType = 0 | 1 | 2
+
+export type ExplosionType = 0 | 1 | 2
+
+export type ClientOptions = {
+		canChange: boolean
+		ezBridging: boolean
+		speedMultiplier: number
+		crouchingSpeed: number
+		/** you should probably use speed multiplier - this doesn't make much sense on phone */
+		walkingSpeed: number
+		/** you should probably use speed multiplier - this doesn't make much sense on phone */
+		runningSpeed: number
+		jumpAmount: number
+		airJumpCount: number
+		bunnyhopMaxMultiplier: number
+		music: Song
+		musicVolumeLevel: number
+		/** Not recommended to use as it lags when being loaded. */
+		skyBox: string | EarthSkyBox
+		minChunkAddDist: [number, number]
+		showPlayersInUnloadedChunks: boolean
+		useInventory: boolean
+		/** For now just enables the full inventory UI */
+		useFullInventory: boolean
+		canCraft: boolean
+		canFish: boolean
+		canPickUpItems: boolean
+		playerZoom: number
+		zoomOutDistance: number
+		maxPlayerZoom: number
+		lobbyLeaderboardInfo: LobbyLeaderboardInfo
+		canCustomiseChar: boolean
+		/** used if canChange is true but useInventory is false */
+		defaultBlock: string
+		cantChangeError: string | CustomTextStyling
+		cantBreakError: string | CustomTextStyling
+		cantBuildError: string | CustomTextStyling
+		/** The contents of the action button. Supports custom text styling. onTouchscreenActionButton will be called when button pressed. */
+		touchscreenActionButton: string | CustomTextStyling
+		strictFluidBuckets: boolean
+		canUseZoomKey: boolean
+		canAltAction: boolean
+		canSeeNametagsThroughWalls: boolean
+		showBasicMovementControls: boolean
+		/** Centred text at the very top of the screen, level with the FPS counter / coordinates / room name. Drops below that strip when a centred placement would overlap it. */
+		middleTextTop: string | CustomTextStyling | TextWithDisplayOptions
+		middleTextUpper: string | CustomTextStyling | TextWithDisplayOptions
+		middleTextLower: string | CustomTextStyling | TextWithDisplayOptions
+		/** A row of compact chips rendered in the top-left HUD strip, concatenated immediately after the FPS counter / coordinates / room name. */
+		headerChips: HeaderChip[]
+		/** Lobby-only subtitle shown after the custom game name in the top-left header */
+		customVariationTitle: string
+		RightInfoText: string | CustomTextStyling | TextWithDisplayOptions
+		crosshairText: string | CustomTextStyling
+		/** If set, clients will only be able to see the closest x players (good for client perf in games with many players) */
+		numClosestPlayersVisible: number
+		showProgressBar: boolean
+		showKillfeed: boolean
+		/** Whether the viewer renders speech bubbles above other players when they send chat messages. Off by default. */
+		showChatBubbles: boolean
+		/** Allows player to select a channel that is passed as argument to onPlayerChat. See engineGameplayTypes.ts for expected format */
+		chatChannels: { channelName: string; elementContent: string | CustomTextStyling; elementBgColor: string; }[]
+		creative: boolean
+		/** while in creative */
+		flySpeedMultiplier: number
+		/** Ignored if creative is false */
+		canPickBlocks: boolean
+		/** Position of the compass target. If string, will be parsed as a player id */
+		compassTarget: string | number | number[]
+		ttbMultiplier: number
+		/** only applicable if useInventory is true */
+		inventoryItemsMoveable: boolean
+		invincible: boolean
+		maxShield: number
+		/** Shield upon joining and respawn. */
+		initialShield: number
+		maxHealth: number
+		/** Health upon joining and respawn. Can be null for the player to not have health. */
+		initialHealth: number
+		/** Fraction of max health that regens each regen tick */
+		healthRegenAmount: number
+		/** How often health regen is ticked */
+		healthRegenInterval: number
+		/** How long after a player receives damage to start regen again */
+		healthRegenStartAfter: number
+		/** Duration of the +damage effect from plum */
+		effectDamageDuration: number
+		/** Duration of +speed effect from cracked coconut */
+		effectSpeedDuration: number
+		/** Duration of +damage reduction effect from pear */
+		effectDamageReductionDuration: number
+		/** Duration of +health regen effect from cherry */
+		effectHealthRegenDuration: number
+		/** Duration of potion effects */
+		potionEffectDuration: number
+		/** Duration of splash potion effects */
+		splashPotionEffectDuration: number
+		/** Duration of arrow potion effects */
+		arrowPotionEffectDuration: number
+		/** RGBA array [r, g, b, a] for camera screen tint effect. Values fall between 0 and 1. */
+		cameraTint: [number, number, number, number]
+		/** Fog distance which overrides graphic settings. Uses graphic settings if null. */
+		fogChunkDistanceOverride: number
+		/** Fog colour override - as a hex string e.g. #ffffff */
+		fogColourOverride: string
+		/** Applies fog to the skybox, which is otherwise unaffected by fog */
+		fogOnSkybox: boolean
+		/** After dying, the player can respawn after this many seconds */
+		secsToRespawn: number
+		/** When player is dead, also shows a play again button matchmakes player into a new lobby. Mostly useful for sessionBased games */
+		usePlayAgainButton: boolean
+		/** If true, player will respawn automatically after secsToRespawn seconds. Won't show an ad so autoRespawn needs to be false some of the time */
+		autoRespawn: boolean
+		/** Text to show on respawn button. (E.g. "Spectate") */
+		respawnButtonText: string
+		/** Whether the player can use the respawn button. Otherwise forces either play again or exit */
+		useRespawnButton: boolean
+		/** MS before a killstreak expires. (defaults to never expiring) */
+		killstreakDuration: number
+		/** Damage multiplier for all types of damage */
+		dealingDamageMultiplier: number
+		/** Mult for when the player hits a head. Only applies to guns */
+		dealingDamageHeadMultiplier: number
+		/** Mult for when the player hits a leg. Only applies to guns */
+		dealingDamageLegMultiplier: number
+		/** Mult for when the player hits neither a leg or a head. Only applies to guns */
+		dealingDamageDefaultMultiplier: number
+		/** Where gunshots originate from. "default" preserves camera-assisted behavior. */
+		gunshotOrigin: GunshotOrigin
+		/** Mult for all types of incoming damage */
+		receivingDamageMultiplier: number
+		/** When the player is attacked, a short cooldown prevents further damage from the same attack type. If true, all attackers share that cooldown. If false, each attacker has their own. */
+		isReceivingDamageCooldownGlobal: boolean
+		/** Mult for horizontal knockback when dealing damage */
+		horizontalKnockbackMultiplier: number
+		/** Mult for vertical knockback when dealing damage */
+		verticalKnockbackMultiplier: number
+		/** Mult for the damage done by "stomping" on a lifeform, i.e.: falling on them wearing Spiked Boots. */
+		stompDamageMultiplier: number
+		/** Radius around the player that will be affected by the stomp damage. */
+		stompDamageRadius: number
+		/** Mult for the radius within which mobs can detect the player when crouching. If a player's mult is 2, then mobs will think they are twice as far away. */
+		crouchMobDetectionRadiusMultiplier: number
+		/** Scale factor to use for dropped item meshes */
+		droppedItemScale: number
+		/** Amount that player camera is affected by movement based fov */
+		movementBasedFovScale: number
+		/** Amount of friction to apply to airborne players - only change if absolutely necessary */
+		airFrictionScale: number
+		/** Amount of friction to apply to grounded players - only change if absolutely necessary */
+		groundFrictionScale: number
+		/** Amount of acceleration to apply to airborne players - only change if absolutely necessary */
+		airAccScale: number
+		/** Whether to allow players to strafe and conserve momentum while airborne */
+		airMomentumConservation: boolean
+		/** Multiplier applied to gravity during normal movement */
+		gravityMultiplier: number
+		/** How much the player bounces off of solid blocks */
+		bounciness: number
+		/** Whether the player can climb walls */
+		canClimbWalls: boolean
+		/** Whether the player can crouch */
+		canCrouch: boolean
+		/** Whether players take fall damage */
+		fallDamage: boolean
+		/** How much aura levels up the player */
+		auraPerLevel: number
+		/** Max aura the player can have */
+		maxAuraLevel: number
+		/** Distance in blocks over which we reduce the opacity of entities as they approach the camera */
+		proximityFadeDistance: number
+		/** Minimum opacity multiplier reachable when fading entities based on camera proximity */
+		proximityFadeMinOpacity: number
+		/** Force the camera to look in a specific direction [x, y, z]. Set to null to allow free camera movement. */
+		forcedCameraDirection: [number, number, number]
+		/** Duration in ms to animate/transition to the forced camera direction. 0 = instant. */
+		forcedCameraDirectionTransitionMs: number
+		/** Roll angle of the camera in radians */
+		cameraRoll: number
+		/** Duration in ms to animate/transition to the camera roll angle. 0 = instant. */
+		cameraRollTransitionMs: number
+		/** Third-person camera origin rotation offset [x, y, z] in radians. */
+		cameraRotationOffset: [number, number, number]
+		/** Third-person camera origin translation offset [x, y, z] in blocks. */
+		cameraPositionOffset: [number, number, number]
+		/** When null, just use the player's graphics setting. When set, forces lighting on (true) or off (false). */
+		lightingOverride: boolean
+		/** Sky light colour override - hex string e.g. #ffffff. */
+		skyLightColourOverride: string
+		/** Ambient (absence of sky light) colour override - hex string e.g. #ffffff. */
+		ambientLightColourOverride: string
+		/** The dimmest light the player can see by - hex string e.g. #ffffff. Anywhere darker is lifted to it, e.g. caves and night. */
+		visionMinLightColour: string
+		/** Held item light colour override - hex colour string e.g. #ffffff. Applied regardless of any held item. */
+		heldLightColourOverride: string
+		/** Held item light range override. Distance is measured in blocks. */
+		heldLightRangeOverride: number
+		/** Held item light cone angle override. Angle is measured in degrees. Larger number = wider beam. */
+		heldLightConeAngleOverride: number
+		/** When true, hides world and chunk coordinates regardless of the player's setting. */
+		hideCoordinates: boolean
+		/** Renders a terrain-following strip of animated chevron arrows on the ground from this player to the target position. Optional \`colour\` is any CSS colour string (e.g. "red", "#ffaa00", "rgb(255,0,0)"), or null for default white. */
+		groundArrowPath: { target: [number, number, number]; colour?: string; }
+	}
+
+export type OtherEntitySettings = {
+		opacity: number
+		zIndex: 0 | 1
+		overlayColour: string
+		canAttack: boolean
+		canSee: boolean
+		interactable: boolean
+		interactionPrompt: string | CustomTextStyling
+		showDamageAmounts: boolean
+		killfeedColour: string
+		meshScaling: EntityMeshScalingMap
+		colorInLobbyLeaderboard: string
+		lobbyLeaderboardValues: LobbyLeaderboardValues
+		lobbyLeaderboardTags: ChatTags
+		nameTagInfo: NameTagInfo
+		hasPriorityNametag: boolean
+		multilineTextBox: MultilineTextBox
+		nameColour: "default" | "yellow" | "lime" | "green" | "aqua" | "cyan" | "blue" | "purple" | "pink" | "red" | "orange"
+	}