import * as mc from "@minecraft/server";
/**
 * Clase principal que maneja los eventos after de forma simplificada para mejor manejo de errores.
 * @class AfterEventsSimplified
 * @author HaJuegos - 11-03-2026
 */
declare class AfterEventsSimplified {
    private entityDieManager;
    private playerSpawnManager;
    private worldLoadManager;
    private chatSendManager;
    private itemUseManager;
    private explosionManager;
    private onProjectileHitEntityManager;
    private onProjectileHitBlockManager;
    private onHitEntityManager;
    private onEntityHurtManager;
    private onHealthEntityChangeManager;
    private onChangeDimensionManager;
    private interactEntityManager;
    private interactBlockManager;
    private entitySpawnsManager;
    private effectAddManager;
    private placeBlockManager;
    private breakBlockManager;
    private dataEventsManager;
    private changeInvManager;
    private onGetItem;
    private onDropItem;
    private playerJoinsManager;
    private playerLeavesManager;
    private entityLoadWorld;
    private entityHealh;
    private entityRemove;
    /**
     * Eventos que se inicializan cuando la clase es llamada o inicializada.
     * @constructor
     */
    constructor();
    /**
     * Método auxiliar que ejecuta los eventos relacionado cuando una entidad muere de forma simplificada.
     * @param {(args: mc.EntityDieAfterEvent) => void} callback Los argumentos del evento y su lógica.
     * @returns {void}
     * @author HaJuegos - 11-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onEntityDie((args) => {
     *     const entity = args.deadEntity;
     *     const source = args.damageSource;
     *
     *     console.warn(`La entidad ${entity.typeId} murió en ${entity.location} debido a ${source.cause}.`);
     * });
     * ```
     */
    onEntityDie(callback: (args: mc.EntityDieAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionado cuando un jugador respawnea de forma simplificada.
     * @param {(args: mc.PlayerSpawnAfterEvent) => void} callback Los argumentos del evento y su lógica.
     * @returns {void}
     * @author HaJuegos - 11-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onPlayerSpawns((args) => {
     *     const ply = args.player;
     *     const firstSpawn = args.initialSpawn;
     *
     *     console.warn(`El Jugador ${ply.name} spawneó en ${ply.location}. (Primera aparicion: ${firstSpawn})`);
     * });
     * ```
     */
    onPlayerSpawns(callback: (args: mc.PlayerSpawnAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un mundo se terminó de cargar de forma simplificada.
     * @param {(args: mc.WorldLoadAfterEvent) => void} callback Los argumentos del evento y su lógica.
     * @returns {void}
     * @author HaJuegos - 11-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onWorldReady(() => {
     *     console.warn(`El mundo se ha cargado correctamente`);
     * });
     * ```
     */
    onWorldReady(callback: (args: mc.WorldLoadAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando se recibe un mensaje en el chat de forma simplificada.
     * @param {(args: mc.ChatSendAfterEvent) => void} callback Los argumentos y lógica a ejecutar en el evento.
     * @returns {void}
     * @author HaJuegos - 14-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onSendMessageChat((args) => {
     *     console.warn(`El usuario ${args.sender.name} envio el mensaje ${args.message}`);
     * });
     * ```
     */
    onSendMessageChat(callback: (args: mc.ChatSendAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando ya se usa el item de forma simplificada.
     * @param {(args: mc.ItemUseAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 15-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onUseItem((args) => {
     *     const ply = args.source;
     *     const item = args.itemStack;
     *
     *     console.warn(`El Jugador ${ply.name} uso el item ${item.typeId}`);
     * });
     * ```
     */
    onUseItem(callback: (args: mc.ItemUseAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando algo explotó de forma simplificada.
     * @param {(args: mc.ExplosionAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 17-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onExplodes((args) => {
     *     const source = args.source;
     *
     *     if (source && source.typeId == 'minecraft:creeper') {
     *        console.warn(`Un creeper explotó.`);
     *     }
     * });
     * ```
     */
    onExplodes(callback: (args: mc.ExplosionAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un proyectil golpea una entidad de forma simplificada.
     * @param {(args: mc.ProjectileHitEntityAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 18-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onProjectileHitEntity((args) => {
     *     const sourceEntity = args.source;
     *     const hitEntity = args.getEntityHit().entity;
     *
     *     console.warn(`${source?.typeId} ha golpeado a ${hitEntity.typeId}.`);
     * });
     * ```
     */
    onProjectileHitEntity(callback: (args: mc.ProjectileHitEntityAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un proyectil golpea un bloque de forma simplificada.
     * @param {(args: mc.ProjectileHitBlockAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 18-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onProjectileHitBlock((args) => {
     *     const sourceEntity = args.source;
     *     const hitBlock = args.getBlockHit().entity;
     *
     *     console.warn(`${source.typeId} ha golpeado al bloque ${hitBlock.typeId}.`);
     * });
     * ```
     */
    onProjectileHitBlock(callback: (args: mc.ProjectileHitBlockAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando se golpea una entidad de forma simplificada.
     * @param {(args: mc.EntityHitEntityAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 18-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onHitEntity((args) => {
     *    const sourceEntity = args.damagingEntity;
     *    const hitEntity = args.hitEntity;
     *
     *    console.warn(`${sourceEntity.typeId} ha golpeado a ${hitEntity.typeId}`);
     * });
     * ```
     */
    onHitEntity(callback: (args: mc.EntityHitEntityAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando se lastima una entidad de forma simplificada.
     * @param {(args: mc.EntityHurtAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 18-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onHurtEntity((args) => {
     *    const source = args.damageSource;
     *    const sourceEntity = source.damagingEntity;
     *    const cause = source.cause;
     *    const hitEntity = args.hurtEntity;
     *
     *    console.warn(`${sourceEntity.typeId} ha lastimado a ${hitEntity.typeId} mediante ${cause}`);
     * });
     * ```
     */
    onHurtEntity(callback: (args: mc.EntityHurtAfterEvent) => void): void;
    /**
     * Método 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.
     * @returns {void}
     * @author HaJuegos - 19-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @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;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un jugador cambia de dimensión de forma simplificada.
     * @param {(args: mc.PlayerDimensionChangeAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @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 está en ${toDime.id}.`);
     * });
     * ```
     */
    onChangeDimension(callback: (args: mc.PlayerDimensionChangeAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un jugador interactuó con una entidad de forma simplificada.
     * @param {(args: mc.PlayerInteractWithEntityAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onInteractEntity((args) => {
     *     const ply = args.player;
     *     const hitEntity = args.target;
     *
     *     console.warn(`${ply.name} interactuó con ${hitEntity.typeId}.`);
     * });
     * ```
     */
    onInteractEntity(callback: (args: mc.PlayerInteractWithEntityAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un jugador interactuó con un bloque de forma simplificada.
     * @param {(args: mc.PlayerInteractWithBlockAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onInteractBlock((args) => {
     *     const ply = args.player;
     *     const block = args.block;
     *
     *     console.warn(`${ply.name} interactuó con el bloque ${block.typeId}.`);
     * });
     * ```
     */
    onInteractBlock(callback: (args: mc.PlayerInteractWithBlockAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad spawnea de forma simplificada.
     * @param {(args: mc.EntitySpawnAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onEntitySpawns((args) => {
     *     console.warn(`${args.entity.typeId} ha spawneado en el mundo`);
     * });
     * ```
     */
    onEntitySpawns(callback: (args: mc.EntitySpawnAfterEvent) => void): void;
    /**
     * Método 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.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onAddsEffect((args) => {
     *     console.warn(`${args.entity.typeId} ahora tiene el efecto ${args.effect.displayName}.`);
     * });
     * ```
     */
    onAddsEffect(callback: (args: mc.EffectAddAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un bloque es colocado de forma simplificada.
     * @param {(args: mc.PlayerPlaceBlockAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 20-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onPlaceBlock((args) => {
     *     console.warn(`${args.player.name} coloco el bloque ${args.block.typeId}.`);
     * });
     * ```
     */
    onPlaceBlock(callback: (args: mc.PlayerPlaceBlockAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un bloque es roto de forma simplificada.
     * @param {(args: mc.PlayerBreakBlockAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 23-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onBreakBlock((args) => {
     *     console.warn(`${args.player.name} rompio el bloque ${args.block.typeId}.`);
     * });
     * ```
     */
    onBreakBlock(callback: (args: mc.PlayerBreakBlockAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad ejecuta uno o varios de sus eventos de su JSON para cambiar componentes, o también por comandos como /event. De forma más simple, sirve como un log de cuales component groups cambió la entidad en ese instante.
     * @param {(args: mc.DataDrivenEntityTriggerAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 26-03-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.getEntityEvents((args) => {
     *     const entity = args.entity;
     *     const events = args.getModifiers();
     *
     *     if (entity.typeId == 'minecraft:player' && entity instanceof mc.Player) {
     *        console.warn(`${entity.name} ha cambiado de componentes: ${JSON.stringify(events)}`);
     *     }
     * });
     * ```
     */
    getEntityEvents(callback: (args: mc.DataDrivenEntityTriggerAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un item se remueve o añade a un inventario de un jugador de forma simplificada.
     * @param {(args: mc.PlayerInventoryItemChangeAfterEvent) => void} callback Los eventos relacionados a ejecutar.
     * @returns {void}
     * @author HaJuegos - 01-04-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onPlyInvChange((args) => {
     *     const previusItem = args.beforeItemStack;
     *     const newItem = args.itemStack;
     *     const ply = args.player;
     *     const slotI = args.slot;
     *     const invType = args.inventoryType;
     *
     *     console.warn(`${ply.name} previamente tenía el item ${previusItem.typeId} en el slot ${slotI} en el inventario ${invType}; Y ahora tiene el item ${newItem.typeId} en su lugar`);
     * });
     * ```
     */
    onPlyInvChange(callback: (args: mc.PlayerInventoryItemChangeAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad obtiene items de forma simplificada.
     * @param {(args: mc.EntityItemPickupAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 19-06-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onGetItemEntity((args) => {
     *      const item = args.items;
     *      const entity = args.entity;
     *
     *      console.log(`${entity.typeId} ha agarrado los items ${JSON.stringify(item)}.`);
     * });
     * ```
     */
    onGetItemEntity(callback: (args: mc.EntityItemPickupAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad dropea items de forma simplificada.
     * @param {(args: mc.EntityItemDropAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 19-06-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onDropItemEntity((args) => {
     *      const item = args.items;
     *      const entity = args.entity;
     *
     *      console.log(`${entity.typeId} ha dropeado los items ${JSON.stringify(item)}.`);
     * });
     * ```
     */
    onDropItemEntity(callback: (args: mc.EntityItemDropAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un jugador se une al mundo de forma simplificada.
     * @param {(args: mc.PlayerJoinAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 21-06-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onPlayerJoinsWorld((args) => {
     *      const name = args.playerName;
     *
     *      console.log(`${name} entró al mundo.`);
     * });
     * ```
     */
    onPlayerJoinsWorld(callback: (args: mc.PlayerJoinAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando un jugador se va del mundo de forma simplificada.
     * @param {(args: mc.PlayerLeaveAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 21-06-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onPlayerLeavesWorld((args) => {
     *      const name = args.playerName;
     *
     *      console.log(`${name} salió del mundo.`);
     * });
     * ```
     */
    onPlayerLeavesWorld(callback: (args: mc.PlayerLeaveAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad se carga en el mundo de forma simplificada.
     * @param {(args: mc.EntityLoadAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 21-07-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onEntityLoadInWorld((args) => {
     *      const typeId = args.entity;
     *
     *      console.log(`${typeId} se cargó en el mundo previamente.`);
     * });
     * ```
     */
    onEntityLoadInWorld(callback: (args: mc.EntityLoadAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad se curó de diferentes formas de forma simplificada.
     * @param {(args: mc.EntityHealBeforeEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @author HaJuegos - 19-06-2026
     * @public
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onEntityHeals((args) => {
     *      const sourceHealh = args.healSource;
     *      const entity = args.healedEntity;
     *
     *      console.log(`${entity.typeId} se regeneró por vía ${sourceHealh.cause}.`);
     * });
     * ```
     */
    onEntityHeals(callback: (args: mc.EntityHealAfterEvent) => void): void;
    /**
     * Método auxiliar que ejecuta los eventos relacionados cuando una entidad es removida del mundo detectando solo su ID de forma simplificada.
     * @param {(args: mc.EntityRemoveAfterEvent) => void} callback Los eventos relacionados.
     * @returns {void}
     * @public
     * @author HaJuegos - 06-08-2026
     * @afterEvent Método que detecta el evento después de que suceda. Obteniendo la información sin permitir modificarla en su mayoría.
     * @example
     * ```ts
     * afterEventsSimplified.onEntityRemove((args) => {
     *      const typeID = args.typeId;
     *      const entityID = args.removedEntityId;
     *
     *      console.log(`${typeId} fue eliminado del mundo, su id era ${entityID}.`);
     * });
     * ```
     */
    onEntityRemove(callback: (args: mc.EntityRemoveAfterEvent) => void): void;
}
export declare const afterEventsSimplified: AfterEventsSimplified;
export {};
//# sourceMappingURL=afterEventsSimplifiedManager.d.ts.map