simplified-mojang-api 0.0.20 → 0.0.22

package/dist/events/afterEventsSimplifiedManager.d.ts

@@ -15,6 +15,13 @@ declare class AfterEventsSimplified {
     private onProjectileHitBlockManager;
     private onHitEntityManager;
     private onEntityHurtManager;
+    private onHealthEntityChangeManager;
+    private onChangeDimensionManager;
+    private interactEntityManager;
+    private interactBlockManager;
+    private entitySpawnsManager;
+    private effectAddManager;
+    private placeBlockManager;
     /**
      * Eventos que se inicializan cuando la clase es llamada o inicializada.
      * @constructor
@@ -178,6 +185,114 @@ declare class AfterEventsSimplified {
      * ```
      */
     onHurtEntity(callback: (args: mc.EntityHurtAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando la vida de una entidad cambia de forma simplificada.
+     * @param {(args: mc.EntityHealthChangedAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 19-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onHealthEntityChange((args) => {
+     *    console.warn(`${args.entity.typeId} tenia ${args.oldValue} de vida y ahora tiene ${args.newValue}.`);
+     * });
+     * ```
+     */
+    onHealthEntityChange(callback: (args: mc.EntityHealthChangedAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador cambia de dimension de forma simplificada.
+     * @param {(args: mc.PlayerDimensionChangeAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onChangeDimension((args) => {
+     *     const ply = args.player;
+     *     const fromDime = args.fromDimension;
+     *     const toDime = args.toDimension;
+     *
+     *     console.warn(`${ply.name} estaba en el ${fromDime.id} y ahora esta en ${toDime.id}.`);
+     * });
+     * ```
+     */
+    onChangeDimension(callback: (args: mc.PlayerDimensionChangeAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador interactuo con una entidad de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithEntityAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onInteractEntity((args) => {
+     *     const ply = args.player;
+     *     const hitEntity = args.target;
+     *
+     *     console.warn(`${ply.name} interactuo con ${hitEntity.typeId}.`);
+     * });
+     * ```
+     */
+    onInteractEntity(callback: (args: mc.PlayerInteractWithEntityAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador interactuo con un bloque de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithBlockAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onInteractBlock((args) => {
+     *     const ply = args.player;
+     *     const block = args.block;
+     *
+     *     console.warn(`${ply.name} interactuo con el bloque ${block.typeId}.`);
+     * });
+     * ```
+     */
+    onInteractBlock(callback: (args: mc.PlayerInteractWithBlockAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando una entidad spawnea de forma simplificada.
+     * @param {(args: mc.EntitySpawnAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onEntitySpawns((args) => {
+     *     console.warn(`${args.entity.typeId} ha spawneado en el mundo`);
+     * });
+     * ```
+     */
+    onEntitySpawns(callback: (args: mc.EntitySpawnAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un efecto es añadido en una entidad o jugador de forma simplificada.
+     * @param {(args: mc.EffectAddAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onAddsEffect((args) => {
+     *     console.warn(`${args.entity.typeId} ahora tiene el efecto ${args.effect.displayName}.`);
+     * });
+     * ```
+     */
+    onAddsEffect(callback: (args: mc.EffectAddAfterEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un bloque es colocando de forma simplificada.
+     * @param {(args: mc.PlayerPlaceBlockAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onPlaceBlock((args) => {
+     *     console.warn(`${args.player.name} coloco el bloque ${args.block.typeId}.`);
+     * });
+     * ```
+     */
+    onPlaceBlock(callback: (args: mc.PlayerPlaceBlockAfterEvent) => void): void;
 }
 export declare const afterEventsSimplified: AfterEventsSimplified;
 export {};

package/dist/events/afterEventsSimplifiedManager.js

@@ -21,6 +21,13 @@ class AfterEventsSimplified {
         this.onProjectileHitBlockManager = new BaseEventManager(mc.world.afterEvents.projectileHitBlock, "AfterProyectileHitBlock");
         this.onHitEntityManager = new BaseEventManager(mc.world.afterEvents.entityHitEntity, "AfterHitEntity");
         this.onEntityHurtManager = new BaseEventManager(mc.world.afterEvents.entityHurt, "AfterHurtEntity");
+        this.onHealthEntityChangeManager = new BaseEventManager(mc.world.afterEvents.entityHealthChanged, "AfterHealthChangeEntity");
+        this.onChangeDimensionManager = new BaseEventManager(mc.world.afterEvents.playerDimensionChange, "AfterChangeDimension");
+        this.interactEntityManager = new BaseEventManager(mc.world.afterEvents.playerInteractWithEntity, "AfterInteractEntity");
+        this.interactBlockManager = new BaseEventManager(mc.world.afterEvents.playerInteractWithBlock, "AfterInteractBlock");
+        this.entitySpawnsManager = new BaseEventManager(mc.world.afterEvents.entitySpawn, "AfterEntitySpawns");
+        this.effectAddManager = new BaseEventManager(mc.world.afterEvents.effectAdd, "AfterEffectAdd");
+        this.placeBlockManager = new BaseEventManager(mc.world.afterEvents.playerPlaceBlock, "AfterPlaceBlock");
     }
     /**
      * Metodo auxiliar que ejecuta los eventos relacionado cuando una entidad muere de forma simplificada.
@@ -200,5 +207,128 @@ class AfterEventsSimplified {
     onHurtEntity(callback) {
         this.onEntityHurtManager.register(callback);
     }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando la vida de una entidad cambia de forma simplificada.
+     * @param {(args: mc.EntityHealthChangedAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 19-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onHealthEntityChange((args) => {
+     *    console.warn(`${args.entity.typeId} tenia ${args.oldValue} de vida y ahora tiene ${args.newValue}.`);
+     * });
+     * ```
+     */
+    onHealthEntityChange(callback) {
+        this.onHealthEntityChangeManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador cambia de dimension de forma simplificada.
+     * @param {(args: mc.PlayerDimensionChangeAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onChangeDimension((args) => {
+     *     const ply = args.player;
+     *     const fromDime = args.fromDimension;
+     *     const toDime = args.toDimension;
+     *
+     *     console.warn(`${ply.name} estaba en el ${fromDime.id} y ahora esta en ${toDime.id}.`);
+     * });
+     * ```
+     */
+    onChangeDimension(callback) {
+        this.onChangeDimensionManager.register(callback);
+    }
+    ;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador interactuo con una entidad de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithEntityAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onInteractEntity((args) => {
+     *     const ply = args.player;
+     *     const hitEntity = args.target;
+     *
+     *     console.warn(`${ply.name} interactuo con ${hitEntity.typeId}.`);
+     * });
+     * ```
+     */
+    onInteractEntity(callback) {
+        this.interactEntityManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador interactuo con un bloque de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithBlockAfterEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onInteractBlock((args) => {
+     *     const ply = args.player;
+     *     const block = args.block;
+     *
+     *     console.warn(`${ply.name} interactuo con el bloque ${block.typeId}.`);
+     * });
+     * ```
+     */
+    onInteractBlock(callback) {
+        this.interactBlockManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando una entidad spawnea de forma simplificada.
+     * @param {(args: mc.EntitySpawnAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onEntitySpawns((args) => {
+     *     console.warn(`${args.entity.typeId} ha spawneado en el mundo`);
+     * });
+     * ```
+     */
+    onEntitySpawns(callback) {
+        this.entitySpawnsManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un efecto es añadido en una entidad o jugador de forma simplificada.
+     * @param {(args: mc.EffectAddAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onAddsEffect((args) => {
+     *     console.warn(`${args.entity.typeId} ahora tiene el efecto ${args.effect.displayName}.`);
+     * });
+     * ```
+     */
+    onAddsEffect(callback) {
+        this.effectAddManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un bloque es colocando de forma simplificada.
+     * @param {(args: mc.PlayerPlaceBlockAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @afterEvent Metodo que detecta el evento despues de que suceda. Obteniendo la informacion sin permitir modificarla en su mayoria.
+     * @example
+     * ```ts
+     * afterEventsSimplified.onPlaceBlock((args) => {
+     *     console.warn(`${args.player.name} coloco el bloque ${args.block.typeId}.`);
+     * });
+     * ```
+     */
+    onPlaceBlock(callback) {
+        this.placeBlockManager.register(callback);
+    }
 }
 export const afterEventsSimplified = new AfterEventsSimplified();

package/dist/events/beforeEventsSimplifiedManager.d.ts

@@ -12,6 +12,9 @@ declare class BeforeEventsSimplified {
     private chatSendManager;
     private itemUseManager;
     private explosionManager;
+    private interactEntityManager;
+    private effectAddManager;
+    private placeBlockManager;
     /**
      * Eventos que se inicializan cuando la clase es llamada o inicializada.
      * @constructor
@@ -108,6 +111,55 @@ declare class BeforeEventsSimplified {
      * ```
      */
     onExplosion(callback: (args: mc.ExplosionBeforeEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador va a interactuar con una entidad de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithEntityBeforeEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onInteractEntity((args) => {
+     *     const ply = args.player;
+     *     const hitEntity = args.target;
+     *
+     *     console.warn(`${ply.name} esta interactuando con ${hitEntity.typeId}.`);
+     *
+     *     args.cancel = true; // ya no se puede.
+     * });
+     * ```
+     */
+    onInteractEntity(callback: (args: mc.PlayerInteractWithEntityBeforeEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un efecto esta apunto de darse a una entidad de forma simplificada.
+     * @param {(args: mc.EffectAddBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onEffectAdds((args) => {
+     *     console.warn(`${args.entity.typeId} tendra el efecto ${args.effect.displayName}.`);
+     *     args.cancel = true; // Ahora ya no sucede.
+     * });
+     * ```
+     */
+    onEffectAdds(callback: (args: mc.EffectAddBeforeEvent) => void): void;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador va a colocar un bloque de forma simplificada.
+     * @param {(args: mc.PlayerPlaceBlockBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onPlaceBlock((args) => {
+     *     console.warn(`${args.player.name} va a colocar el bloque ${args.block.typeId}.`);
+     *     args.cancel = true; // Ahora ya no puede colocarlo
+     * });
+     * ```
+     */
+    onPlaceBlock(callback: (args: mc.PlayerPlaceBlockBeforeEvent) => void): void;
     /**
      * Metodo auxiliar que registra y ejecuta los eventos relacionados cuando se quiere registrar un custom component de un bloque.
      * @param {string} nameComponent Nombre del componente en cuestion a registrar.

package/dist/events/beforeEventsSimplifiedManager.js

@@ -18,6 +18,9 @@ class BeforeEventsSimplified {
         this.chatSendManager = new BaseEventManager(mc.world.beforeEvents.chatSend, "BeforeChatSend");
         this.itemUseManager = new BaseEventManager(mc.world.beforeEvents.itemUse, "BeforeItemUse");
         this.explosionManager = new BaseEventManager(mc.world.beforeEvents.explosion, "BeforeExplodes");
+        this.interactEntityManager = new BaseEventManager(mc.world.beforeEvents.playerInteractWithEntity, "BeforeInteractEntity");
+        this.effectAddManager = new BaseEventManager(mc.world.beforeEvents.effectAdd, "BeforeAddEffect");
+        this.placeBlockManager = new BaseEventManager(mc.world.beforeEvents.playerPlaceBlock, "BeforePlayerPlaceBlock");
     }
     /**
      * Metodo auxiliar que ejecuta los eventos relacionados cuando el add-on se carga por primera vez
@@ -122,6 +125,62 @@ class BeforeEventsSimplified {
     onExplosion(callback) {
         this.explosionManager.register(callback);
     }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador va a interactuar con una entidad de forma simplificada.
+     * @param {(args: mc.PlayerInteractWithEntityBeforeEvent) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onInteractEntity((args) => {
+     *     const ply = args.player;
+     *     const hitEntity = args.target;
+     *
+     *     console.warn(`${ply.name} esta interactuando con ${hitEntity.typeId}.`);
+     *
+     *     args.cancel = true; // ya no se puede.
+     * });
+     * ```
+     */
+    onInteractEntity(callback) {
+        this.interactEntityManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un efecto esta apunto de darse a una entidad de forma simplificada.
+     * @param {(args: mc.EffectAddBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onEffectAdds((args) => {
+     *     console.warn(`${args.entity.typeId} tendra el efecto ${args.effect.displayName}.`);
+     *     args.cancel = true; // Ahora ya no sucede.
+     * });
+     * ```
+     */
+    onEffectAdds(callback) {
+        this.effectAddManager.register(callback);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador va a colocar un bloque de forma simplificada.
+     * @param {(args: mc.PlayerPlaceBlockBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 20-03-2026
+     * @public
+     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
+     * @example
+     * ```ts
+     * beforeEventsSimplified.onPlaceBlock((args) => {
+     *     console.warn(`${args.player.name} va a colocar el bloque ${args.block.typeId}.`);
+     *     args.cancel = true; // Ahora ya no puede colocarlo
+     * });
+     * ```
+     */
+    onPlaceBlock(callback) {
+        this.placeBlockManager.register(callback);
+    }
+    // Metodos no auxiliares
     /**
      * Metodo auxiliar que registra y ejecuta los eventos relacionados cuando se quiere registrar un custom component de un bloque.
      * @param {string} nameComponent Nombre del componente en cuestion a registrar.

package/dist/events/customToolsManager.d.ts

@@ -15,7 +15,6 @@ declare class CustomEventsSimplified {
      * @param {(mc.ItemStack[] | string[])} listOfItems La lista de items a validar para este sistema.
      * @author HaJuegos - 15-03-2026
      * @public
-     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
      * @example
      * ```ts
      * customEventsManager.fastItemsSystem(['totem']); // Ahora el totem es conciderado un fast item para cambiar a la mano secundaria con un click.
@@ -49,6 +48,22 @@ declare class CustomEventsSimplified {
      * ```
      */
     plyHasItems(plySource: mc.Player, itemsToDetect: string | string[] | vanilla.MinecraftItemTypes | vanilla.MinecraftItemTypes[]): boolean;
+    /**
+     * Metodo auxiliar que simplifica loa logica al detectar el uso de un totem en un jugaodor, ejecutando los eventos relacionados.
+     * @param {(ply: mc.Player) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 19-03-2026
+     * @public
+     * @example
+     * ```ts
+     * // Este evento solo se va a ejecutar cuando un jugador usa un totem.
+     * customEventsManager.playerUseTotemSystem((args) => {
+     *     const ply = args.player;
+     *
+     *     console.warn(`${ply.name} ha usado un totem.`);
+     * });
+     * ```
+     */
+    onPlayerUseTotem(callback: (player: mc.Player) => void): void;
 }
 export declare const customEventsManager: CustomEventsSimplified;
 export {};

package/dist/events/customToolsManager.js

@@ -1,6 +1,7 @@
 import * as mc from '@minecraft/server';
 import { beforeEventsSimplified } from './beforeEventsSimplifiedManager';
 import { worldToolsSimplified } from './worldToolsSimplifiedManager';
+import { afterEventsSimplified } from './afterEventsSimplifiedManager';
 /**
  * Clase que contiene todos los metodos de mecanicas universales usadas en sus add-ons.
  * @author HaJuegos - 15-03-2026
@@ -17,7 +18,6 @@ class CustomEventsSimplified {
      * @param {(mc.ItemStack[] | string[])} listOfItems La lista de items a validar para este sistema.
      * @author HaJuegos - 15-03-2026
      * @public
-     * @beforeEvent Metodo que detecta el evento antes de que suceda. Permitiendo cancelar o personalizar el evento antes de que se vea en el juego.
      * @example
      * ```ts
      * customEventsManager.fastItemsSystem(['totem']); // Ahora el totem es conciderado un fast item para cambiar a la mano secundaria con un click.
@@ -135,5 +135,30 @@ class CustomEventsSimplified {
         }
         return false;
     }
+    /**
+     * Metodo auxiliar que simplifica loa logica al detectar el uso de un totem en un jugaodor, ejecutando los eventos relacionados.
+     * @param {(ply: mc.Player) => void} callback Los eventos relacionados a ejecutar.
+     * @author HaJuegos - 19-03-2026
+     * @public
+     * @example
+     * ```ts
+     * // Este evento solo se va a ejecutar cuando un jugador usa un totem.
+     * customEventsManager.playerUseTotemSystem((args) => {
+     *     const ply = args.player;
+     *
+     *     console.warn(`${ply.name} ha usado un totem.`);
+     * });
+     * ```
+     */
+    onPlayerUseTotem(callback) {
+        afterEventsSimplified.onHealthEntityChange((args) => {
+            const entity = args.entity;
+            const newValue = args.newValue;
+            const oldValue = args.oldValue;
+            if (entity instanceof mc.Player && oldValue <= 0 && newValue >= 1) {
+                callback(entity);
+            }
+        });
+    }
 }
 export const customEventsManager = new CustomEventsSimplified();

package/dist/events/worldToolsSimplifiedManager.d.ts

@@ -91,7 +91,7 @@ declare class WorldToolsSimplified {
     /**
      * Metodo auxiliar que envia un mensaje global al mundo en formato string o rawmessage.
      * @public
-     * @param {(string | mc.RawMessage)} message Mensaje o RawMessage en concreto a enviar.
+     * @param {string | mc.RawMessage | (string | mc.RawMessage)[]} message Mensaje o RawMessage en concreto a enviar.
      * @author HaJuegos - 12-03-2026
      * @example
      * ```ts
@@ -102,7 +102,7 @@ declare class WorldToolsSimplified {
      * worldToolsSimplified.sendMessageGlobal({ rawtext: 'chat.test.message' });
      * ```
      */
-    sendMessageGlobal(message: string | mc.RawMessage): void;
+    sendMessageGlobal(message: string | mc.RawMessage | (string | mc.RawMessage)[]): void;
     /**
      * Metodo auxiliar que maneja la logica de los eventos cuando se ejecuta el comando scriptevent.
      * @param {((args: mc.ScriptEventCommandMessageAfterEvent) => void)} callback La logica del evento en concreto.

package/dist/events/worldToolsSimplifiedManager.js

@@ -115,7 +115,7 @@ class WorldToolsSimplified {
     /**
      * Metodo auxiliar que envia un mensaje global al mundo en formato string o rawmessage.
      * @public
-     * @param {(string | mc.RawMessage)} message Mensaje o RawMessage en concreto a enviar.
+     * @param {string | mc.RawMessage | (string | mc.RawMessage)[]} message Mensaje o RawMessage en concreto a enviar.
      * @author HaJuegos - 12-03-2026
      * @example
      * ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "simplified-mojang-api",
-    "version": "0.0.20",
+    "version": "0.0.22",
     "description": "About Public repository to simplify the event logic of Mojang's Script API, for informal or professional use",
     "type": "module",
     "main": "dist/index.js",