simplified-mojang-api 0.0.21 → 0.0.23

package/dist/events/afterEventsSimplifiedManager.d.ts

@@ -16,6 +16,13 @@ declare class AfterEventsSimplified {
     private onHitEntityManager;
     private onEntityHurtManager;
     private onHealthEntityChangeManager;
+    private onChangeDimensionManager;
+    private interactEntityManager;
+    private interactBlockManager;
+    private entitySpawnsManager;
+    private effectAddManager;
+    private placeBlockManager;
+    private breakBlockManager;
     /**
      * Eventos que se inicializan cuando la clase es llamada o inicializada.
      * @constructor
@@ -193,6 +200,114 @@ declare class AfterEventsSimplified {
      * ```
      */
     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;
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un bloque es roto de forma simplificada.
+     * @param {(args: mc.PlayerBreakBlockAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 23-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.onBreakBlock((args) => {
+     *     console.warn(`${args.player.name} rompio el bloque ${args.block.typeId}.`);
+     * });
+     * ```
+     */
+    onBreakBlock(callback: (args: mc.PlayerBreakBlockAfterEvent) => void): void;
 }
 export declare const afterEventsSimplified: AfterEventsSimplified;
 export {};

package/dist/events/afterEventsSimplifiedManager.js

@@ -22,6 +22,13 @@ class AfterEventsSimplified {
         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");
+        this.breakBlockManager = new BaseEventManager(mc.world.afterEvents.playerBreakBlock, "AfterBreakBlock");
     }
     /**
      * Metodo auxiliar que ejecuta los eventos relacionado cuando una entidad muere de forma simplificada.
@@ -217,5 +224,128 @@ class AfterEventsSimplified {
     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);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un bloque es roto de forma simplificada.
+     * @param {(args: mc.PlayerBreakBlockAfterEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 23-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.onBreakBlock((args) => {
+     *     console.warn(`${args.player.name} rompio el bloque ${args.block.typeId}.`);
+     * });
+     * ```
+     */
+    onBreakBlock(callback) {
+        this.breakBlockManager.register(callback);
+    }
 }
 export const afterEventsSimplified = new AfterEventsSimplified();

package/dist/events/beforeEventsSimplifiedManager.d.ts

@@ -12,6 +12,10 @@ declare class BeforeEventsSimplified {
     private chatSendManager;
     private itemUseManager;
     private explosionManager;
+    private interactEntityManager;
+    private effectAddManager;
+    private placeBlockManager;
+    private breakBlockManager;
     /**
      * Eventos que se inicializan cuando la clase es llamada o inicializada.
      * @constructor
@@ -108,6 +112,70 @@ 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 ejecuta los eventos relacionados cuando un jugador va a romper un bloque de forma simplificada.
+     * @param {(args: mc.PlayerBreakBlockBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 23-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.onBreakBlock((args) => {
+     *     console.warn(`${args.player.name} va a romper el bloque ${args.block.typeId}.`);
+     *     args.cancel = true; // Ahora ya no puede romperlo
+     * });
+     * ```
+     */
+    onBreakBlock(callback: (args: mc.PlayerBreakBlockBeforeEvent) => 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,10 @@ 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");
+        this.breakBlockManager = new BaseEventManager(mc.world.beforeEvents.playerBreakBlock, "BeforePlayerBreakBlock");
     }
     /**
      * Metodo auxiliar que ejecuta los eventos relacionados cuando el add-on se carga por primera vez
@@ -122,6 +126,79 @@ 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);
+    }
+    /**
+     * Metodo auxiliar que ejecuta los eventos relacionados cuando un jugador va a romper un bloque de forma simplificada.
+     * @param {(args: mc.PlayerBreakBlockBeforeEvent) => void} callback Los eventos relacionados.
+     * @author HaJuegos - 23-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.onBreakBlock((args) => {
+     *     console.warn(`${args.player.name} va a romper el bloque ${args.block.typeId}.`);
+     *     args.cancel = true; // Ahora ya no puede romperlo
+     * });
+     * ```
+     */
+    onBreakBlock(callback) {
+        this.breakBlockManager.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/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.21",
+    "version": "0.0.23",
     "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",