bloxd.io.d.ts 2.0.1 → 2.2.0

package/dist/api-type-def/normal/block/getBlockId.d.ts

@@ -0,0 +1,12 @@
+import { BlockId } from "../../../type/index";
+/**
+ * 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 {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {BlockId}
+ */
+declare const getBlockId: (x: number, y: number, z: number) => BlockId;
+export { getBlockId };

package/dist/api-type-def/normal/block/getBlockSolidity.d.ts

@@ -0,0 +1,19 @@
+import { Coordinate } from "../../../type/index";
+/**
+ * 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.
+ *
+ * overload 1: getBlockSolidity(x: number, y: number, z: number): boolean
+ * overload 2: getBlockSolidity(pos: Coordinate): boolean
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {boolean}
+ */
+declare const getBlockSolidity: {
+    (x: number, y: number, z: number): boolean;
+    (pos: Coordinate): boolean;
+};
+export { getBlockSolidity };

package/dist/api-type-def/normal/block/getChunk.d.ts

@@ -0,0 +1,15 @@
+import { Coordinate } from "../../../type/index";
+/**
+ * Only use this instead of getBlock if you REALLY need the performance (i.e. you are iterating over tens of thousands of blocks)
+ * ReturnedObject.blockData is a 32x32x32 ndarray of block ids
+ * (see https://www.npmjs.com/package/ndarray)
+ * Each block id is a 16-bit number
+ * The ndarray should only be read from, writing to it will result in desync between the server and client
+ *
+ * @param {number[]} pos - The returned chunk contains pos
+ * @returns {PNull<GameChunk>} - null if the chunk is not loaded in a persisted world. ReturnedObject.blockData is an ndarray that can be accessed
+ *
+ * @throws allways happen error
+ */
+declare const getChunk: (pos: Coordinate) => never;
+export { getChunk };

package/dist/api-type-def/normal/block/getEmptyChunk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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
+ *
+ * @throws alwavs happen error
+ *
+ * @returns {GameChunk}
+ */
+declare const getEmptyChunk: () => never;
+export { getEmptyChunk };

package/dist/api-type-def/normal/block/getMetaInfo.d.ts

@@ -0,0 +1,9 @@
+import { Block, ItemMetaInfo } from "../../../type/index";
+/**
+ * Splits the block name by '|'. If no meta info, metaInfo is ''
+ *
+ * @param {BlockName | null | undefined} blockName
+ * @returns {ItemMetaInfo}
+ */
+declare const getMetaInfo: (blockName: Block | null | undefined) => ItemMetaInfo;
+export { getMetaInfo };

package/dist/api-type-def/normal/block/index.d.ts

@@ -0,0 +1,30 @@
+export declare const BlockApis: {
+    isBlockInLoadedChunk: (x: number, y: number, z: number) => boolean;
+    getBlock: {
+        (x: number, y: number, z: number): import("../../..").BlockName;
+        (pos: import("../../..").Coordinate): import("../../..").BlockName;
+    };
+    getBlockId: (x: number, y: number, z: number) => import("../../..").BlockId;
+    setBlock: {
+        (x: number, y: number, z: number, blockName: import("../../..").BlockName): void;
+        (pos: import("../../..").Coordinate, blockName: import("../../..").BlockName): void;
+    };
+    attemptWorldChangeBlock: (initatorDbId: null | import("../../..").PlayerDbId, x: number, y: number, z: number, blockName: import("../../..").BlockName, extraInfo?: import("../../..").WorldBlockChangedInfo) => "preventChange" | "preventDrop" | void;
+    getBlockSolidity: {
+        (x: number, y: number, z: number): boolean;
+        (pos: import("../../..").Coordinate): boolean;
+    };
+    setBlockRect: (pos1: import("../../..").Coordinate, pos2: import("../../..").Coordinate, blockName: import("../../..").Block) => void;
+    setBlockWalls: (pos1: import("../../..").Coordinate, pos2: import("../../..").Coordinate, blockName: import("../../..").Block, hasFloor?: boolean, hasCeiling?: boolean) => void;
+    getChunk: (pos: import("../../..").Coordinate) => never;
+    getEmptyChunk: () => never;
+    getMetaInfo: (blockName: import("../../..").Block | null | undefined) => import("../../..").ItemMetaInfo;
+    blockNameToBlockId: {
+        (blockName: import("../../..").BlockName): import("../../..").BlockId;
+        (blockName: import("../../..").BlockName, allowInvalidBlock: true): null | import("../../..").BlockId;
+        (blockName: import("../../..").BlockName, allowInvalidBlock: false): import("../../..").BlockId;
+    };
+    blockIdToBlockName: (blockId: import("../../..").BlockId) => import("../../..").BlockName;
+    blockCoordToChunkId: (pos: import("../../..").Coordinate) => import("../../..").ChunkId;
+    chunkIdToBotLeftCoord: (chunkId: import("../../..").ChunkId) => import("../../..").Coordinate;
+};

package/dist/api-type-def/normal/block/isBlockInLoadedChunk.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if the block at a specific position is in a loaded chunk.
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {boolean} - boolean
+ */
+declare const isBlockInLoadedChunk: (x: number, y: number, z: number) => boolean;
+export { isBlockInLoadedChunk };

package/dist/api-type-def/normal/block/setBlock.d.ts

@@ -0,0 +1,20 @@
+import { BlockName, Coordinate } from "../../../type/index";
+/**
+ * Set a block. Valid names are those either contained in blockMetadata.ts or are '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.
+ *
+ * overload1: setBlock(x: number, y: number, z: number, blockName: BlockName): void
+ * overload2: setBlock(pos: Coordinate, blockName: BlockName): void
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {BlockName} blockName
+ * @returns {void}
+ */
+declare const setBlock: {
+    (x: number, y: number, z: number, blockName: BlockName): void;
+    (pos: Coordinate, blockName: BlockName): void;
+};
+export { setBlock };

package/dist/api-type-def/normal/block/setBlockRect.d.ts

@@ -0,0 +1,11 @@
+import { Block, Coordinate } from "../../../type/index";
+/**
+ * Helper function that sets all blocks in a rectangle to a specific block.
+ *
+ * @param {number[]} pos1 - array [x, y, z]
+ * @param {number[]} pos2 - array [x, y, z]
+ * @param {BlockName} blockName
+ * @returns {void}
+ */
+declare const setBlockRect: (pos1: Coordinate, pos2: Coordinate, blockName: Block) => void;
+export { setBlockRect };

package/dist/api-type-def/normal/block/setBlockWalls.d.ts

@@ -0,0 +1,13 @@
+import { Block, Coordinate } from "../../../type/index";
+/**
+ * Create walls by providing two opposite corners of the cuboid
+ *
+ * @param {number[]} pos1 - array [x, y, z]
+ * @param {number[]} pos2 - array [x, y, z]
+ * @param {BlockName} blockName
+ * @param {boolean} [hasFloor]
+ * @param {boolean} [hasCeiling]
+ * @returns {void}
+ */
+declare const setBlockWalls: (pos1: Coordinate, pos2: Coordinate, blockName: Block, hasFloor?: boolean, hasCeiling?: boolean) => void;
+export { setBlockWalls };

package/dist/api-type-def/normal/entity/getEntityName.d.ts

@@ -0,0 +1,9 @@
+import { EntityId } from "../../../type/index";
+/**
+ * Get the in game name of an entity.
+ *
+ * @param {EntityId} entityId
+ * @returns {string}
+ */
+declare const getEntityName: (entityId: EntityId) => string;
+export { getEntityName };

package/dist/api-type-def/normal/entity/index.d.ts

@@ -0,0 +1,3 @@
+export declare const EntityApis: {
+    getEntityName: (entityId: import("../../..").EntityId) => string;
+};

package/dist/api-type-def/normal/forceRespawn.d.ts

@@ -1 +1,10 @@
-export {};
+import { Coordinate, PlayerId } from "../../type/index";
+/**
+ * Force respawn a player
+ *
+ * @param {PlayerId} playerId
+ * @param {Coordinate} [respawnPos]
+ * @returns {void}
+ */
+declare const forceRespawn: (playerId: PlayerId, respawnPos?: Readonly<Coordinate>) => void;
+export { forceRespawn };

package/dist/api-type-def/normal/getUnitCoordinatesLifeformWithin.d.ts

@@ -1,12 +1,10 @@
-import { Coordinate, LifeformId } from "../../type/index";
-interface GetUnitCoordinatesLifeformWithinInterface {
-    /**
-     * 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} lifeformId
-     * @returns {number[][]} - List of x, y, z positions e.g. [[-1, 0, 0], [-1, 1, 0], [-1, 2, 0]]
-     */
-    getUnitCoordinatesLifeformWithin(lifeformId: LifeformId): Coordinate[];
-}
-export default GetUnitCoordinatesLifeformWithinInterface;
+import { Coordinate, LifeformId } from "../../type/index";
+/**
+ * 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} lifeformId
+ * @returns {number[][]} - List of x, y, z positions e.g. [[-1, 0, 0], [-1, 1, 0], [-1, 2, 0]]
+ */
+declare const getUnitCoordinatesLifeformWithin: (lifeformId: LifeformId) => Coordinate[];
+export { getUnitCoordinatesLifeformWithin };

package/dist/api-type-def/normal/health/applyHealthChange.d.ts

@@ -1,12 +1,10 @@
-import { LifeformId, WhoDidDamage } from "../../../type/index";
-interface ApplyHealthChangeInterface {
-    /**
-     * @param {LifeformId} lifeformId
-     * @param {number} 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 { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoDidDamage] - Optional - If damage done by another player
-     * @param {boolean} [broadcastLifeformHurt]
-     * @returns {boolean} - Whether the entity was killed
-     */
-    applyHealthChange(lifeformId: LifeformId, changeAmount: number, whoDidDamage?: Readonly<WhoDidDamage>, broadcastLifeformHurt?: boolean): boolean;
-}
-export default ApplyHealthChangeInterface;
+import { LifeformId, WhoDidDamage } from "../../../type/index";
+/**
+ * @param {LifeformId} lifeformId
+ * @param {number} 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 { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoDidDamage] - Optional - If damage done by another player
+ * @param {boolean} [broadcastLifeformHurt]
+ * @returns {boolean} - Whether the entity was killed
+ */
+declare const applyHealthChange: (lifeformId: LifeformId, changeAmount: number, whoDidDamage?: Readonly<WhoDidDamage>, broadcastLifeformHurt?: boolean) => boolean;
+export { applyHealthChange };

package/dist/api-type-def/normal/health/applyMeleeHit.d.ts

@@ -1,20 +1,18 @@
-import { applyMeleeHitOverrides, Direcrion, LifeformBodyPart, LifeformId } from "../../../type/index";
-interface ApplyMeleeHitInterface {
-    /**
-     * Make it as if hittingEId hit hitEId
-     *
-     * @param {LifeformId} hittingEId
-     * @param {LifeformId} hitEId
-     * @param {number[]} dirFacing
-     * @param {PNull<LifeformBodyPart>} [bodyPartHit]
-     * @param { {
-     *     damage?: PNull<number>
-     *     heldItemName?: PNull<string>
-     *     horizontalKbMultiplier?: number
-     *     verticalKbMultiplier?: number
-     * } } [overrides]
-     * @returns {boolean} - hitEId was died by this calling
-     */
-    applyMeleeHit(hittingEId: LifeformId, hitEId: LifeformId, dirFacing: Readonly<Direcrion>, bodyPartHit?: LifeformBodyPart | null, overrides?: Readonly<applyMeleeHitOverrides>): boolean;
-}
-export default ApplyMeleeHitInterface;
+import { applyMeleeHitOverrides, Direcrion, LifeformBodyPart, LifeformId } from "../../../type/index";
+/**
+ * Make it as if hittingEId hit hitEId
+ *
+ * @param {LifeformId} hittingEId
+ * @param {LifeformId} hitEId
+ * @param {number[]} dirFacing
+ * @param {PNull<LifeformBodyPart>} [bodyPartHit]
+ * @param { {
+ *     damage?: PNull<number>
+ *     heldItemName?: PNull<string>
+ *     horizontalKbMultiplier?: number
+ *     verticalKbMultiplier?: number
+ * } } [overrides]
+ * @returns {boolean} - hitEId was died by this calling
+ */
+declare const applyMeleeHit: (hittingEId: LifeformId, hitEId: LifeformId, dirFacing: Readonly<Direcrion>, bodyPartHit?: LifeformBodyPart | null, overrides?: Readonly<applyMeleeHitOverrides>) => boolean;
+export { applyMeleeHit };

package/dist/api-type-def/normal/health/attemptApplyDamage.d.ts

@@ -1,31 +1,29 @@
-import { PlayerAttemptDamageOtherPlayerOpts } from "../../../type/index";
-interface AttemptApplyDamageInterface {
-    /**
-     * 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 {PlayerAttemptDamageOtherPlayerOpts} {
-     *     eId,
-     *     hitEId,
-     *     attemptedDmgAmt,
-     *     withItem,
-     *     bodyPartHit = undefined,
-     *     attackDir = undefined,
-     *     showCritParticles = false,
-     *     reduceVerticalKbVelocity = true,
-     *     horizontalKbMultiplier = 1,
-     *     verticalKbMultiplier = 1,
-     *     broadcastEntityHurt = true,
-     *     attackCooldownSettings = null,
-     *     hittingSoundOverride = null,
-     *     ignoreOtherEntitySettingCanAttack = false,
-     *     isTrueDamage = false,
-     *     damagerDbId = null,
-     * }
-     * @returns {boolean} - whether the attack damaged the lifeform
-     */
-    attemptApplyDamage(options: Readonly<PlayerAttemptDamageOtherPlayerOpts>): boolean;
-}
-export default AttemptApplyDamageInterface;
+import { PlayerAttemptDamageOtherPlayerOpts } from "../../../type/index";
+/**
+ * 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 {PlayerAttemptDamageOtherPlayerOpts} {
+ *     eId,
+ *     hitEId,
+ *     attemptedDmgAmt,
+ *     withItem,
+ *     bodyPartHit = undefined,
+ *     attackDir = undefined,
+ *     showCritParticles = false,
+ *     reduceVerticalKbVelocity = true,
+ *     horizontalKbMultiplier = 1,
+ *     verticalKbMultiplier = 1,
+ *     broadcastEntityHurt = true,
+ *     attackCooldownSettings = null,
+ *     hittingSoundOverride = null,
+ *     ignoreOtherEntitySettingCanAttack = false,
+ *     isTrueDamage = false,
+ *     damagerDbId = null,
+ * }
+ * @returns {boolean} - whether the attack damaged the lifeform
+ */
+declare const attemptApplyDamage: (options: Readonly<PlayerAttemptDamageOtherPlayerOpts>) => boolean;
+export { attemptApplyDamage };

package/dist/api-type-def/normal/health/getHealth.d.ts

@@ -1,15 +1,13 @@
-import { EntityId, Health } from "../../../type/index";
-interface GetHealthInterface {
-    /**
-     * Get the current health of an entity.
-     *
-     * @bulebrainbrand may be this function can use all entity...
-     * but offical docment is contradiction Playerid and EntityId
-     * well,pls test and report
-     *
-     * @param {EntityId} entityId
-     * @returns {number}
-     */
-    getHealth(entityId: EntityId): Health;
-}
-export default GetHealthInterface;
+import { EntityId, Health } from "../../../type/index";
+/**
+ * Get the current health of an entity.
+ *
+ * @bulebrainbrand may be this function can use all entity...
+ * but offical docment is contradiction Playerid and EntityId
+ * well,pls test and report
+ *
+ * @param {EntityId} entityId
+ * @returns {number}
+ */
+declare const getHealth: (entityId: EntityId) => Health;
+export { getHealth };

package/dist/api-type-def/normal/health/index.d.ts

@@ -1,8 +1,9 @@
-import GetHealthInterface from "./getHealth";
-import SetHealthinterface from "./setHealth";
-import AttemptApplyDamageInterface from "./attemptApplyDamage";
-import ApplyMeleeHitInterface from "./applyMeleeHit";
-import ApplyHealthChangeInterface from "./applyHealthChange";
-import killLifeformInterface from "./killLifeform";
-import IsAliveInterface from "./isAlive";
-export type HealthApis = GetHealthInterface & SetHealthinterface & AttemptApplyDamageInterface & ApplyMeleeHitInterface & ApplyHealthChangeInterface & killLifeformInterface & IsAliveInterface;
+export declare const HealthApis: {
+    getHealth: (entityId: import("../../..").EntityId) => import("../../..").Health;
+    setHealth: (entityId: import("../../..").EntityId, newHealth: import("../../..").Health | null, whoDidDamage?: Readonly<import("../../..").WhoDidDamage>, increaseMaxHealthIfNeeded?: boolean) => boolean;
+    attemptApplyDamage: (options: Readonly<import("../../..").PlayerAttemptDamageOtherPlayerOpts>) => boolean;
+    applyMeleeHit: (hittingEId: import("../../..").LifeformId, hitEId: import("../../..").LifeformId, dirFacing: Readonly<import("../../..").Direcrion>, bodyPartHit?: import("../../..").LifeformBodyPart | null, overrides?: Readonly<import("../../..").applyMeleeHitOverrides>) => boolean;
+    applyHealthChange: (lifeformId: import("../../..").LifeformId, changeAmount: number, whoDidDamage?: Readonly<import("../../..").WhoDidDamage>, broadcastLifeformHurt?: boolean) => boolean;
+    killLifeform: (lifeformId: import("../../..").LifeformId, whoKilled?: import("../../..").WhoKilled) => void;
+    isAlive: (lifeformId: import("../../..").LifeformId) => boolean;
+};

package/dist/api-type-def/normal/health/isAlive.d.ts

@@ -1,11 +1,9 @@
-import { LifeformId } from "../../../type/index";
-interface IsAliveInterface {
-    /**
-     * Whether a lifeform is alive or dead (or on the respawn screen, in a player's case).
-     *
-     * @param {LifeformId} lifeformId
-     * @returns {boolean}
-     */
-    isAlive(lifeformId: LifeformId): boolean;
-}
-export default IsAliveInterface;
+import { LifeformId } from "../../../type/index";
+/**
+ * Whether a lifeform is alive or dead (or on the respawn screen, in a player's case).
+ *
+ * @param {LifeformId} lifeformId
+ * @returns {boolean}
+ */
+declare const isAlive: (lifeformId: LifeformId) => boolean;
+export { isAlive };

package/dist/api-type-def/normal/health/killLifeform.d.ts

@@ -1,12 +1,10 @@
-import { LifeformId, WhoKilled } from "../../../type/index";
-interface killLifeformInterface {
-    /**
-     * Kill a lifeform.
-     *
-     * @param {LifeformId} lifeformId
-     * @param { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoKilled] - Optional
-     * @returns {void}
-     */
-    killLifeform(lifeformId: LifeformId, whoKilled?: WhoKilled): void;
-}
-export default killLifeformInterface;
+import { LifeformId, WhoKilled } from "../../../type/index";
+/**
+ * Kill a lifeform.
+ *
+ * @param {LifeformId} lifeformId
+ * @param { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoKilled] - Optional
+ * @returns {void}
+ */
+declare const killLifeform: (lifeformId: LifeformId, whoKilled?: WhoKilled) => void;
+export { killLifeform };

package/dist/api-type-def/normal/health/setHealth.d.ts

@@ -1,17 +1,15 @@
-import { EntityId, Health, WhoDidDamage } from "../../../type/index";
-interface SetHealthinterface {
-    /**
-     * 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.
-     *
-     * @bulebrainbrand i think this api cannot use other lifeformId
-     *
-     * @param {EntityId} entityId
-     * @param {PNull<number>} newHealth - Can be null to make the player not have health
-     * @param { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoDidDamage] - Optional
-     * @param {boolean} [increaseMaxHealthIfNeeded] - Optional
-     * @returns {boolean} - Whether this change in health killed the player
-     */
-    setHealth(entityId: EntityId, newHealth: Health | null, whoDidDamage?: Readonly<WhoDidDamage>, increaseMaxHealthIfNeeded?: boolean): boolean;
-}
-export default SetHealthinterface;
+import { EntityId, Health, WhoDidDamage } from "../../../type/index";
+/**
+ * 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.
+ *
+ * @bulebrainbrand i think this api cannot use other lifeformId
+ *
+ * @param {EntityId} entityId
+ * @param {PNull<number>} newHealth - Can be null to make the player not have health
+ * @param { LifeformId | { lifeformId: LifeformId; withItem: string } } [whoDidDamage] - Optional
+ * @param {boolean} [increaseMaxHealthIfNeeded] - Optional
+ * @returns {boolean} - Whether this change in health killed the player
+ */
+declare const setHealth: (entityId: EntityId, newHealth: Health | null, whoDidDamage?: Readonly<WhoDidDamage>, increaseMaxHealthIfNeeded?: boolean) => boolean;
+export { setHealth };

package/dist/api-type-def/normal/index.d.ts

@@ -1,13 +1,67 @@
-import GetUnitCoordinatesLifeformWithinInterface from "./getUnitCoordinatesLifeformWithin";
-import { ShopApis } from "./shops/index";
-import { ShieldApis } from "./shields/index";
-import { PositionApis } from "./positions/index";
-import { StandingOnApis } from "./standingOns/index";
-import { HealthApis } from "./health/index";
-import { KillstreakApis } from "./killstreak/index";
-import { MessageApis } from "./message/index";
-import { PlayerApis } from "./player/index";
-import { MargeObject } from "../../type/index";
-type AllNormalApiIntersection = PositionApis & PlayerApis & StandingOnApis & GetUnitCoordinatesLifeformWithinInterface & ShopApis & ShieldApis & HealthApis & KillstreakApis & MessageApis;
-export type NormalApi = MargeObject<AllNormalApiIntersection>;
-export {};
+export declare const NormalApis: {
+    readonly forceRespawn: (playerId: import("../../type/index").PlayerId, respawnPos?: Readonly<import("../../type/index").Coordinate>) => void;
+    readonly getEntityName: (entityId: import("../../type/index").EntityId) => string;
+    readonly getPlayerIds: () => import("../../type/index").PlayerId[];
+    readonly getNumPlayers: () => number;
+    readonly getPlayerPartyWhenJoined: (playerId: import("../../type/index").PlayerId) => import("../../type/index").Party | null;
+    readonly playerIsInGame: (playerId: import("../../type/index").PlayerId) => boolean;
+    readonly playerIsLoggedIn: (playerId: import("../../type/index").PlayerId) => boolean;
+    readonly getPlayerId: (playerName: string) => null | import("../../type/index").PlayerId;
+    readonly getPlayerDbId: (playerId: import("../../type/index").PlayerId) => import("../../type/index").PlayerDbId;
+    readonly getPlayerIdFromDbId: (dbId: import("../../type/index").PlayerDbId) => null | import("../../type/index").PlayerId;
+    readonly kickPlayer: (playerId: import("../../type/index").PlayerId, reason: string) => void;
+    readonly isMobile: (playerId: import("../../type/index").PlayerId) => boolean;
+    readonly broadcastMessage: (message: string | import("../../type/index").CustomTextStyling, style?: {
+        fontWeight?: number | string;
+        color?: string;
+    }) => void;
+    readonly sendMessage: {
+        (playerId: import("../../type/index").PlayerId, message: string, style: {
+            fontWeight?: number | string;
+            color?: string;
+        }): void;
+        (playerId: import("../../type/index").PlayerId, message: import("../../type/index").CustomTextStyling): void;
+    };
+    readonly sendFlyingMiddleMessage: (playerId: import("../../type/index").PlayerId, message: string | import("../../type/index").CustomTextStyling, distanceFromAction?: number, lifetimeMs?: number) => void;
+    readonly sendTopRightHelper: (playerId: import("../../type/index").PlayerId, icon: string, text: string, opts: {
+        duration?: number;
+        width?: number;
+        height?: number;
+        color?: import("../../type/index").StringColor;
+        iconSizeMult?: number;
+        textAndIconColor?: string;
+        fontSize?: string;
+    }) => void;
+    readonly getCurrentKillstreak: (playerId: import("../../type/index").PlayerId) => number;
+    readonly clearKillstreak: (playerId: import("../../type/index").PlayerId) => void;
+    readonly createItemDrop: (x: number, y: number, z: number, itemName: import("../../type/index").ItemName, amount?: number | null, margeItems?: boolean, attributes?: import("../../type/index").ItemAttributes, timeTillDespawn?: number, dropperId?: import("../../type/index").LifeformId | null, options?: never) => null | import("../../type/index").ItemEntityId;
+    readonly setCantPickUpItem: (playerId: import("../../type/index").PlayerId, itemId: import("../../type/index").ItemEntityId) => void;
+    readonly deleteItemDrop: (itemId: import("../../type/index").ItemEntityId) => void;
+    readonly getHealth: (entityId: import("../../type/index").EntityId) => import("../../type/index").Health;
+    readonly setHealth: (entityId: import("../../type/index").EntityId, newHealth: import("../../type/index").Health | null, whoDidDamage?: Readonly<import("../../type/index").WhoDidDamage>, increaseMaxHealthIfNeeded?: boolean) => boolean;
+    readonly attemptApplyDamage: (options: Readonly<import("../../type/index").PlayerAttemptDamageOtherPlayerOpts>) => boolean;
+    readonly applyMeleeHit: (hittingEId: import("../../type/index").LifeformId, hitEId: import("../../type/index").LifeformId, dirFacing: Readonly<import("../../type/index").Direcrion>, bodyPartHit?: import("../../type/index").LifeformBodyPart | null, overrides?: Readonly<import("../../type/index").applyMeleeHitOverrides>) => boolean;
+    readonly applyHealthChange: (lifeformId: import("../../type/index").LifeformId, changeAmount: number, whoDidDamage?: Readonly<import("../../type/index").WhoDidDamage>, broadcastLifeformHurt?: boolean) => boolean;
+    readonly killLifeform: (lifeformId: import("../../type/index").LifeformId, whoKilled?: import("../../type/index").WhoKilled) => void;
+    readonly isAlive: (lifeformId: import("../../type/index").LifeformId) => boolean;
+    readonly getBlockCoordinatesPlayerStandingOn: (playerId: import("../../type/index").PlayerId) => import("../../type/index").Coordinate[];
+    readonly getBlockTypesPlayerStandingOn: (playerId: import("../../type/index").PlayerId) => import("../../type/index").BlockName[];
+    readonly getPosition: (entityId: import("../../type/index").EntityId) => import("../../type/index").Coordinate;
+    readonly setPosition: {
+        (entityId: import("../../type/index").EntityId, x: number, y: number, z: number): void;
+        (entityId: import("../../type/index").EntityId, position: Readonly<import("../../type/index").Coordinate>): void;
+    };
+    readonly getShieldAmount: (entityId: import("../../type/index").EntityId) => import("../../type/index").ShieldAmount;
+    readonly setShieldAmount: (lifeformId: import("../../type/index").LifeformId, newShieldAmount: import("../../type/index").ShieldAmount) => void;
+    readonly showShopTutorial: (playerId: import("../../type/index").PlayerId) => void;
+    readonly createShopItem: (categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey, item: import("../../type/index").ShopItem) => void;
+    readonly updateShopItem: (categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey, changes: Partial<import("../../type/index").ShopItem>) => void;
+    readonly deleteShopItem: (categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey) => void;
+    readonly configureShopCategory: (categoryKey: import("../../type/index").ShopCategoryKey, config: import("../../type/index").ShopCategoryConfig) => void;
+    readonly createShopItemForPlayer: (playerId: import("../../type/index").PlayerId, categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey, item: import("../../type/index").ShopItem) => void;
+    readonly updateShopItemForPlayer: (playerId: import("../../type/index").PlayerId, categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey, changes: Partial<import("../../type/index").ShopItem>) => void;
+    readonly resetShopItemForPlayer: (playerId: import("../../type/index").PlayerId, categoryKey: import("../../type/index").ShopCategoryKey, itemKey: import("../../type/index").ShopItemKey) => void;
+    readonly configureShopCategoryForPlayer: (playerId: import("../../type/index").PlayerId, categoryKey: import("../../type/index").ShopCategoryKey, config: import("../../type/index").ShopCategoryConfig) => void;
+    readonly getUnitCoordinatesLifeformWithin: (lifeformId: import("../../type/index").LifeformId) => import("../../type/index").Coordinate[];
+    readonly playParticleEffect: (opts: import("../../type/index").TempParticleSystemOpts, clientPredictedBy?: import("../../type/index").PlayerId) => void;
+};

package/dist/api-type-def/normal/item/createItemDrop.d.ts

@@ -0,0 +1,20 @@
+import { ItemAttributes, ItemEntityId, ItemName, LifeformId } from "../../../type/index";
+/**
+ * Create a dropped item.
+ *
+ * ItemDropOptions is never cuz i can't find type define in offical docment
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {ItemName} itemName - Name of the item. Valid names can be found in blockMetadata.ts and itemMetadata.ts
+ * @param {number | null} [amount] - The amount of the item to include in the drop - so when the player picks up the item drop, they get this many of the item.
+ * @param {boolean} [mergeItems] - Whether to merge the item into a nearby item of same type, if one exists. Defaults to false.
+ * @param {ItemAttributes} [attributes] - Attributes of the item being dropped
+ * @param {number} [timeTillDespawn] - Time till the item automatically despawns in milliseconds. Max of 5 mins.
+ * @param {null | LifeformId } [dropperId] - Who dropped the item.
+ * @param {ItemDropOptions} [options] - Additional options, such as doPhysics and size.
+ * @returns {null | EntityId} - the id you can pass to setCantPickUpItem, or null if the item drop limit was reached
+ */
+declare const createItemDrop: (x: number, y: number, z: number, itemName: ItemName, amount?: number | null, margeItems?: boolean, attributes?: ItemAttributes, timeTillDespawn?: number, dropperId?: LifeformId | null, options?: never) => null | ItemEntityId;
+export { createItemDrop };

package/dist/api-type-def/normal/item/deleteItemDrop.d.ts

@@ -0,0 +1,3 @@
+import { ItemEntityId } from "../../../type/index";
+declare const deleteItemDrop: (itemId: ItemEntityId) => void;
+export { deleteItemDrop };

package/dist/api-type-def/normal/item/index.d.ts

@@ -0,0 +1,5 @@
+export declare const ItemApis: {
+    readonly createItemDrop: (x: number, y: number, z: number, itemName: import("../../..").ItemName, amount?: number | null, margeItems?: boolean, attributes?: import("../../..").ItemAttributes, timeTillDespawn?: number, dropperId?: import("../../..").LifeformId | null, options?: never) => null | import("../../..").ItemEntityId;
+    readonly setCantPickUpItem: (playerId: import("../../..").PlayerId, itemId: import("../../..").ItemEntityId) => void;
+    readonly deleteItemDrop: (itemId: import("../../..").ItemEntityId) => void;
+};

package/dist/api-type-def/normal/item/setCantPickUpItem.d.ts

@@ -0,0 +1,3 @@
+import { ItemEntityId, PlayerId } from "../../../type/index";
+declare const setCantPickUpItem: (playerId: PlayerId, itemId: ItemEntityId) => void;
+export { setCantPickUpItem };