interface event {
    use common.{block-pos, game-mode, hand, position, click-type};
    use item-stack.{item-stack};
    use enchantments.{enchantment};
    use damage-types.{damage-type};
    use screens.{screen};
    use player.{player};
    use text.{text-component};
    use %world.{%world};
    use java-packets.{serverbound-packet as java-serverbound-packet, clientbound-packet as java-clientbound-packet};
    use bedrock-packets.{serverbound-packet as bedrock-serverbound-packet, clientbound-packet as bedrock-clientbound-packet};
    use uuid.{uuid};
    use java-dialogs.{dialog};

    variant serverbound-packet {
        java(java-serverbound-packet),
        bedrock(bedrock-serverbound-packet),
        unknown,
    }

    variant clientbound-packet {
        java(java-clientbound-packet),
        bedrock(bedrock-clientbound-packet),
        unknown,
    }

    enum event-priority {
        highest,
        high,
        normal,
        low,
        lowest,
    }

    record player-join-event-data {
        player: player,
        join-message: text-component,
        cancelled: bool
    }

    record player-leave-event-data {
        player: player,
        leave-message: text-component,
        cancelled: bool
    }

    record player-login-event-data {
        player: player,
        kick-message: text-component,
        cancelled: bool
    }

    record player-chat-event-data {
        player: player,
        message: string,
        recipients: list<player>,
        cancelled: bool
    }

    record player-command-send-event-data {
        player: player,
        command: string,
        cancelled: bool
    }

    record player-permission-check-event-data {
        player: player,
        permission: string,
        permission-result: bool
    }

    record player-move-event-data {
        player: player,
        from-position: position,
        to-position: position,
        cancelled: bool
    }

    record player-teleport-event-data {
        player: player,
        from-position: position,
        to-position: position,
        cancelled: bool
    }

    record player-change-world-event-data {
        player: player,
        previous-world: %world,
        new-world: %world,
        position: position,
        yaw: f32,
        pitch: f32,
        cancelled: bool
    }

    record player-respawn-event-data {
        player: player,
        previous-world: %world,
        respawned-world: %world,
        position: position,
        yaw: f32,
        pitch: f32,
        alive: bool
    }

    record player-exp-change-event-data {
        player: player,
        amount: s32
    }

    record player-item-held-event-data {
        player: player,
        previous-slot: u8,
        new-slot: u8,
        cancelled: bool
    }

    record player-changed-main-hand-event-data {
        player: player,
        main-hand: hand
    }

    record player-gamemode-change-event-data {
        player: player,
        previous-gamemode: game-mode,
        new-gamemode: game-mode,
        cancelled: bool
    }

    record player-custom-payload-event-data {
        player: player,
        channel: string,
        data: list<u8>
    }

    enum player-fish-state {
        fishing,
        caught-fish,
        caught-entity,
        in-ground,
        failed-attempt,
        reel-in,
        bite,
    }

    record player-fish-event-data {
        player: player,
        caught-uuid: option<uuid>,
        caught-type: string,
        hook-uuid: uuid,
        state: player-fish-state,
        hand: hand,
        exp-to-drop: s32,
        cancelled: bool
    }

    record player-egg-throw-event-data {
        player: player,
        egg-uuid: uuid,
        hatching: bool,
        num-hatches: u8,
        hatching-type: string,
        cancelled: bool
    }

    enum entity-interaction-action {
        interact,
        attack,
        interact-at,
    }

    enum interact-action {
        left-click-block,
        left-click-air,
        right-click-air,
        right-click-block,
    }

    record player-interact-event-data {
        player: player,
        action: interact-action,
        clicked-pos: option<block-pos>,
        block: string,
        cancelled: bool
    }

    record player-toggle-sneak-event-data {
        player: player,
        is-sneaking: bool,
        cancelled: bool
    }

    record player-toggle-flight-event-data {
        player: player,
        is-flying: bool,
        cancelled: bool
    }

    record player-toggle-sprint-event-data {
        player: player,
        is-sprinting: bool,
        cancelled: bool
    }

    record player-interact-unknown-entity-event-data {
        player: player,
        entity-id: s32,
        action: entity-interaction-action,
        cancelled: bool
    }

    record inventory-click-event-data {
        player: player,
        window-type: option<screen>,
        click-type: click-type,
        slot: s16,
        raw-slot: s16,
        clicked-item: option<item-stack>,
        cursor: option<item-stack>,
        hotbar-button: s32,
        cancelled: bool
    }

    record inventory-close-event-data {
        player: player,
        window-type: option<screen>
    }

    record block-redstone-event-data {
        target-world: %world,
        state-id: u16,
        block-pos: block-pos,
        old-current: s32,
        new-current: s32,
        cancelled: bool
    }

    record block-break-event-data {
        player: option<player>,
        block: string,
        block-pos: block-pos,
        exp: u32,
        should-drop: bool,
        cancelled: bool
    }

    record block-burn-event-data {
        igniting-block: string,
        block: string,
        cancelled: bool
    }

    record block-can-build-event-data {
        block-to-build: string,
        buildable: bool,
        player: player,
        block: string,
        cancelled: bool
    }

    record block-grow-event-data {
        target-world: %world,
        old-block: string,
        old-state-id: u16,
        new-block: string,
        new-state-id: u16,
        block-pos: block-pos,
        cancelled: bool
    }

    record block-place-event-data {
        player: player,
        block-placed: string,
        block-placed-against: string,
        block-pos: block-pos,
        can-build: bool,
        cancelled: bool
    }

    record bedrock-form-response-event-data {
        player: player,
        form-id: u32,
        response-data: option<string>,
    }

    record dialog-click-action-event-data {
        player: player,
        id: string,
        payload: option<list<u8>>,
        cancelled: bool,
    }

    record dialog-show-event-data {
        player: player,
        dialog: dialog,
        cancelled: bool,
    }

    record dialog-clear-event-data {
        player: player,
        cancelled: bool,
    }

    record server-command-event-data {
        command: string,
        cancelled: bool
    }

    record server-list-ping-address {
        host: string,
        port: u16
    }

    record server-list-ping-event-data {
        hostname: string,
        address: server-list-ping-address,
        motd: text-component,
        max-players: u32,
        num-players: u32,
        favicon: option<string>
    }

    enum server-load-type {
        startup,
        reload,
    }

    record server-load-event-data {
        load-type: server-load-type
    }

    record spawn-change-event-data {
        target-world: %world,
        previous-position: block-pos,
        previous-yaw: f32,
        previous-pitch: f32,
        new-position: block-pos,
        new-yaw: f32,
        new-pitch: f32
    }

    record server-broadcast-event-data {
        message: text-component,
        sender: text-component,
        cancelled: bool
    }

    record server-tick-start-event-data {
        tick: s32
    }

    record server-tick-end-event-data {
        tick: s32,
        duration-nanos: s64
    }

    record packet-received-event-data {
        player: player,
        packet: serverbound-packet,
        packet-id: s32,
        raw-payload: list<u8>,
        cancelled: bool
    }

    record packet-sent-event-data {
        player: player,
        packet: clientbound-packet,
        packet-id: s32,
        raw-payload: list<u8>,
        cancelled: bool
    }

    record player-interact-entity-event-data {
        player: player,
        entity-id: s32,
        action: entity-interaction-action,
        sneaking: bool,
        cancelled: bool
    }

    record chunk-load-event-data {
        target-world: %world,
        chunk-x: s32,
        chunk-z: s32,
        cancelled: bool
    }

    record chunk-save-event-data {
        target-world: %world,
        chunk-x: s32,
        chunk-z: s32,
        cancelled: bool
    }

    record chunk-send-event-data {
        target-world: %world,
        chunk-x: s32,
        chunk-z: s32,
        cancelled: bool
    }

    record entity-damage-event-data {
        entity-id: s32,
        damage: f32,
        damage-type: damage-type,
        cancelled: bool
    }

    record entity-death-event-data {
        entity-id: s32,
        dropped-exp: s32
    }

    record player-death-event-data {
        player: player,
        death-message: text-component,
        dropped-exp: s32,
        keep-inventory: bool,
        cancelled: bool
    }

    record entity-spawn-event-data {
        entity-id: s32,
        entity-type: string,
        position: position,
        target-world: %world,
        cancelled: bool
    }

    record entity-combust-event-data {
        entity-id: s32,
        duration-secs: f32,
        cancelled: bool
    }

    record entity-regain-health-event-data {
        entity-id: s32,
        amount: f32,
        cancelled: bool
    }

    record entity-air-change-event-data {
        entity-id: s32,
        amount: s32,
        cancelled: bool
    }

    record entity-breed-event-data {
        father-id: s32,
        mother-id: s32,
        child-id: s32,
        cancelled: bool
    }

    record entity-dismount-event-data {
        entity-id: s32,
        dismounted-id: s32,
        cancelled: bool
    }

    record entity-dye-event-data {
        entity-id: s32,
        color: string,
        player: option<player>,
        cancelled: bool
    }

    record entity-enter-love-mode-event-data {
        entity-id: s32,
        human-entity-id: option<s32>,
        ticks-in-love: s32,
        cancelled: bool
    }

    record entity-explode-event-data {
        entity-id: s32,
        position: position,
        yield-rate: f32,
        cancelled: bool
    }

    record entity-mount-event-data {
        entity-id: s32,
        mounted-id: s32,
        cancelled: bool
    }

    record entity-pickup-item-event-data {
        entity-id: s32,
        item-name: string,
        count: u8,
        cancelled: bool
    }

    record entity-portal-event-data {
        entity-id: s32,
        portal-pos: block-pos,
        cancelled: bool
    }

    record entity-resurrect-event-data {
        entity-id: s32,
        cancelled: bool
    }

    record entity-shoot-bow-event-data {
        entity-id: s32,
        weapon-name: string,
        force: f32,
        cancelled: bool
    }

    record entity-tame-event-data {
        entity-id: s32,
        owner: player,
        cancelled: bool
    }

    record entity-target-event-data {
        entity-id: s32,
        target-id: option<s32>,
        cancelled: bool
    }

    record entity-teleport-event-data {
        entity-id: s32,
        from-position: position,
        to-position: position,
        cancelled: bool
    }

    record entity-toggle-glide-event-data {
        entity-id: s32,
        is-gliding: bool,
        cancelled: bool
    }

    record entity-transform-event-data {
        entity-id: s32,
        new-entity-id: s32,
        transform-reason: string,
        cancelled: bool
    }

    record creature-spawn-event-data {
        entity-id: s32,
        entity-type: string,
        position: position,
        target-world: %world,
        spawn-reason: string,
        cancelled: bool
    }

    record ender-dragon-change-phase-event-data {
        entity-id: s32,
        current-phase: string,
        new-phase: string,
        cancelled: bool
    }

    record entity-break-door-event-data {
        entity-id: s32,
        block-pos: block-pos,
        cancelled: bool
    }

    record entity-change-block-event-data {
        entity-id: s32,
        block-pos: block-pos,
        new-block: string,
        cancelled: bool
    }

    record entity-damage-by-block-event-data {
        entity-id: s32,
        damager-pos: option<block-pos>,
        damage: f32,
        cause: string,
        cancelled: bool
    }

    record entity-damage-by-entity-event-data {
        entity-id: s32,
        damager-id: s32,
        damage: f32,
        cause: string,
        cancelled: bool
    }

    record entity-drop-item-event-data {
        entity-id: s32,
        item-name: string,
        count: u8,
        cancelled: bool
    }

    record entity-enter-block-event-data {
        entity-id: s32,
        block-pos: block-pos,
        cancelled: bool
    }

    record entity-exhaustion-event-data {
        entity-id: s32,
        exhaustion: f32,
        cancelled: bool
    }

    record entity-interact-event-data {
        entity-id: s32,
        block-pos: block-pos,
        cancelled: bool
    }

    record entity-knockback-event-data {
        entity-id: s32,
        hit-by-id: option<s32>,
        knockback: position,
        cancelled: bool
    }

    record entity-place-event-data {
        entity-id: s32,
        block-pos: block-pos,
        block-name: string,
        cancelled: bool
    }

    record entity-pose-change-event-data {
        entity-id: s32,
        pose: string,
        cancelled: bool
    }

    record entity-potion-effect-event-data {
        entity-id: s32,
        effect-name: string,
        duration: s32,
        amplifier: u8,
        cancelled: bool
    }

    record entity-spell-cast-event-data {
        entity-id: s32,
        spell: string,
        cancelled: bool
    }

    record entity-target-living-entity-event-data {
        entity-id: s32,
        target-id: option<s32>,
        reason: string,
        cancelled: bool
    }

    record entity-toggle-swim-event-data {
        entity-id: s32,
        is-swimming: bool,
        cancelled: bool
    }

    record explosion-prime-event-data {
        entity-id: s32,
        radius: f32,
        fire: bool,
        cancelled: bool
    }

    record firework-explode-event-data {
        entity-id: s32,
        cancelled: bool
    }

    record food-level-change-event-data {
        entity-id: s32,
        food-level: u8,
        cancelled: bool
    }

    record item-despawn-event-data {
        entity-id: s32,
        cancelled: bool
    }

    record item-merge-event-data {
        entity-id: s32,
        target-id: s32,
        cancelled: bool
    }

    record item-spawn-event-data {
        entity-id: s32,
        position: position,
        item-name: string,
        cancelled: bool
    }

    record piglin-barter-event-data {
        entity-id: s32,
        input-item: item-stack,
        outcome: list<item-stack>,
        cancelled: bool
    }

    record projectile-hit-event-data {
        entity-id: s32,
        hit-position: position,
        hit-entity-id: option<s32>,
        cancelled: bool
    }

    record projectile-launch-event-data {
        entity-id: s32,
        shooter-id: option<s32>,
        cancelled: bool
    }

    record sheep-dye-wool-event-data {
        entity-id: s32,
        dye-color: u8,
        player-id: option<s32>,
        cancelled: bool
    }

    record sheep-regrow-wool-event-data {
        entity-id: s32,
        cancelled: bool
    }

    record slime-split-event-data {
        entity-id: s32,
        count: s32,
        cancelled: bool
    }

    record strider-temperature-change-event-data {
        entity-id: s32,
        is-shivering: bool,
        cancelled: bool
    }

    record villager-acquire-trade-event-data {
        entity-id: s32,
        recipe-index: s32,
        cancelled: bool
    }

    record villager-career-change-event-data {
        entity-id: s32,
        profession: string,
        reason: string,
        cancelled: bool
    }

    record villager-replenish-trade-event-data {
        entity-id: s32,
        restock-quantity: s32,
        cancelled: bool
    }

    record warden-anger-change-event-data {
        entity-id: s32,
        target-id: s32,
        old-anger: s32,
        new-anger: s32,
        cancelled: bool
    }

    record area-effect-cloud-apply-event-data {
        entity-id: s32,
        affected-entities: list<s32>,
        cancelled: bool
    }

    record arrow-body-count-change-event-data {
        entity-id: s32,
        old-amount: u32,
        new-amount: u32,
        cancelled: bool
    }

    record bat-toggle-sleep-event-data {
        entity-id: s32,
        is-awake: bool,
        cancelled: bool
    }

    record creeper-power-event-data {
        entity-id: s32,
        lightning-id: option<s32>,
        cause: string,
        cancelled: bool
    }

    record entity-combust-by-block-event-data {
        entity-id: s32,
        combuster: block-pos,
        duration: f32,
        cancelled: bool
    }

    record entity-combust-by-entity-event-data {
        entity-id: s32,
        combuster-id: s32,
        duration: f32,
        cancelled: bool
    }

    record entity-knockback-by-entity-event-data {
        entity-id: s32,
        hit-by-id: s32,
        force: f64,
        x: f64,
        z: f64,
        cancelled: bool
    }

    record entity-portal-enter-event-data {
        entity-id: s32,
        location: block-pos,
        cancelled: bool
    }

    record entity-portal-exit-event-data {
        entity-id: s32,
        from-pos: block-pos,
        to-pos: option<block-pos>,
        cancelled: bool
    }

    record entity-remove-event-data {
        entity-id: s32,
        cause: string,
        cancelled: bool
    }

    record entity-target-block-event-data {
        entity-id: s32,
        block-pos: block-pos,
        cancelled: bool
    }

    record entity-unleash-event-data {
        entity-id: s32,
        reason: string,
        cancelled: bool
    }

    record exp-bottle-event-data {
        entity-id: s32,
        experience: s32,
        location: block-pos,
        show-effect: bool,
        cancelled: bool
    }

    record horse-jump-event-data {
        entity-id: s32,
        power: f32,
        cancelled: bool
    }

    record lingering-potion-splash-event-data {
        entity-id: s32,
        location: block-pos,
        potion-item: string,
        cancelled: bool
    }

    record pig-zap-event-data {
        entity-id: s32,
        lightning-id: s32,
        pig-zombie-id: s32,
        cancelled: bool
    }

    record pig-zombie-anger-event-data {
        entity-id: s32,
        target-id: option<s32>,
        new-anger: s32,
        cancelled: bool
    }

    record potion-splash-event-data {
        entity-id: s32,
        location: block-pos,
        potion-item: string,
        affected-entities: list<s32>,
        cancelled: bool
    }

    record spawner-spawn-event-data {
        entity-id: s32,
        spawner-pos: block-pos,
        cancelled: bool
    }

    record trial-spawner-spawn-event-data {
        entity-id: s32,
        spawner-pos: block-pos,
        cancelled: bool
    }

    record villager-reputation-change-event-data {
        entity-id: s32,
        target-id: s32,
        reputation-change: s32,
        cancelled: bool
    }

    record player-item-consume-event-data {
        player: player,
        item-name: string,
        cancelled: bool
    }

    record player-item-damage-event-data {
        player: player,
        item-name: string,
        damage: s32,
        cancelled: bool
    }

    record player-drop-item-event-data {
        player: player,
        item-name: string,
        count: u8,
        cancelled: bool
    }

    record player-bed-enter-event-data {
        player: player,
        bed-pos: block-pos,
        cancelled: bool
    }

    record player-bed-leave-event-data {
        player: player,
        bed-pos: block-pos
    }

    record player-bucket-empty-event-data {
        player: player,
        block-pos: block-pos,
        bucket: string,
        cancelled: bool
    }

    record player-bucket-fill-event-data {
        player: player,
        block-pos: block-pos,
        bucket: string,
        cancelled: bool
    }

    record async-player-chat-event-data {
        player: player,
        message: string,
        format: text-component,
        cancelled: bool
    }

    record async-player-pre-login-event-data {
        player-name: string,
        player-uuid: string,
        ip-address: string,
        kick-message: text-component,
        cancelled: bool
    }

    record player-advancement-done-event-data {
        player: player,
        advancement-id: string,
        cancelled: bool
    }

    record player-animation-event-data {
        player: player,
        animation-type: string,
        cancelled: bool
    }

    record player-armor-stand-manipulate-event-data {
        player: player,
        armor-stand-id: s32,
        slot: u8,
        cancelled: bool
    }

    record player-bucket-entity-event-data {
        player: player,
        entity-id: s32,
        bucket-item: string,
        cancelled: bool
    }

    record player-changed-world-event-data {
        player: player,
        from-world: %world,
        to-world: %world,
        cancelled: bool
    }

    record player-channel-event-data {
        player: player,
        channel: string,
        cancelled: bool
    }

    record player-command-preprocess-event-data {
        player: player,
        command: string,
        cancelled: bool
    }

    record player-edit-book-event-data {
        player: player,
        slot: u32,
        pages: list<string>,
        title: option<string>,
        signing: bool,
        cancelled: bool
    }

    record player-elytra-boost-event-data {
        player: player,
        firework-id: s32,
        cancelled: bool
    }

    record player-exp-cooldown-change-event-data {
        player: player,
        new-cooldown: s32,
        cancelled: bool
    }

    record player-harvest-block-event-data {
        player: player,
        block-pos: block-pos,
        harvested-items: list<item-stack>,
        cancelled: bool
    }

    record player-hide-entity-event-data {
        player: player,
        entity-id: s32,
        cancelled: bool
    }

    record player-item-break-event-data {
        player: player,
        item-name: string
    }

    record player-item-mend-event-data {
        player: player,
        item-name: string,
        repair-amount: s32,
        exp-consumed: s32,
        cancelled: bool
    }

    record player-kick-event-data {
        player: player,
        reason: string,
        cancelled: bool
    }

    record player-leash-entity-event-data {
        player: player,
        entity-id: s32,
        holder-id: s32,
        cancelled: bool
    }

    record player-level-change-event-data {
        player: player,
        old-level: s32,
        new-level: s32
    }

    record player-locale-change-event-data {
        player: player,
        new-locale: string,
        cancelled: bool
    }

    record player-name-entity-event-data {
        player: player,
        entity-id: s32,
        name: text-component,
        cancelled: bool
    }

    record player-open-sign-event-data {
        player: player,
        block-pos: block-pos,
        is-front: bool,
        cancelled: bool
    }

    record player-portal-event-data {
        player: player,
        from-pos: block-pos,
        to-pos: option<block-pos>,
        cancelled: bool
    }

    record player-pre-login-event-data {
        player-name: string,
        player-uuid: string,
        ip-address: string,
        kick-message: text-component,
        cancelled: bool
    }

    record player-riptide-event-data {
        player: player,
        item-name: string,
        cancelled: bool
    }

    record player-shear-entity-event-data {
        player: player,
        entity-id: s32,
        hand: u8,
        cancelled: bool
    }

    record player-show-entity-event-data {
        player: player,
        entity-id: s32,
        cancelled: bool
    }

    record player-spawn-change-event-data {
        player: player,
        new-spawn: option<block-pos>,
        forced: bool,
        cancelled: bool
    }

    record player-statistic-increment-event-data {
        player: player,
        statistic-id: string,
        amount: s32,
        cancelled: bool
    }

    record player-swap-hands-event-data {
        player: player,
        cancelled: bool
    }

    record player-take-lectern-book-event-data {
        player: player,
        block-pos: block-pos,
        book: item-stack,
        cancelled: bool
    }

    record player-unleash-entity-event-data {
        player: player,
        entity-id: s32,
        cancelled: bool
    }

    record player-velocity-event-data {
        player: player,
        velocity: position,
        cancelled: bool
    }

    record player-input-event-data {
        player: player,
        input: string,
        cancelled: bool
    }

    record player-interact-at-entity-event-data {
        player: player,
        entity-id: s32,
        clicked-x: f64,
        clicked-y: f64,
        clicked-z: f64,
        hand: u8,
        cancelled: bool
    }

    record player-links-send-event-data {
        player: player,
        links: list<string>,
        cancelled: bool
    }

    record player-pickup-arrow-event-data {
        player: player,
        arrow-id: s32,
        cancelled: bool
    }

    record player-recipe-book-click-event-data {
        player: player,
        recipe-id: string,
        make-all: bool,
        cancelled: bool
    }

    record player-recipe-book-settings-change-event-data {
        player: player,
        book-type: string,
        is-open: bool,
        is-filtering: bool,
        cancelled: bool
    }

    record player-recipe-discover-event-data {
        player: player,
        recipe-id: string,
        cancelled: bool
    }

    record player-register-channel-event-data {
        player: player,
        channel: string,
        cancelled: bool
    }

    record player-resource-pack-status-event-data {
        player: player,
        pack-id: string,
        status: string,
        cancelled: bool
    }

    record player-spawn-location-event-data {
        player: player,
        spawn-pos: position,
        cancelled: bool
    }

    record player-unregister-channel-event-data {
        player: player,
        channel: string,
        cancelled: bool
    }

    record raid-finish-event-data {
        victory: bool,
        cancelled: bool
    }

    record raid-spawn-wave-event-data {
        wave: u32,
        pos: block-pos,
        cancelled: bool
    }

    record raid-stop-event-data {
        reason: string,
        cancelled: bool
    }

    record raid-trigger-event-data {
        pos: block-pos,
        cancelled: bool
    }

    record block-damage-event-data {
        player: player,
        block-pos: block-pos,
        insta-break: bool,
        cancelled: bool
    }

    record block-ignite-event-data {
        block-pos: block-pos,
        cancelled: bool
    }

    record block-from-to-event-data {
        from-pos: block-pos,
        to-pos: block-pos,
        cancelled: bool
    }

    record block-form-event-data {
        block-pos: block-pos,
        cancelled: bool
    }

    record block-fade-event-data {
        block-pos: block-pos,
        cancelled: bool
    }

    record block-dispense-event-data {
        block-pos: block-pos,
        item-name: string,
        cancelled: bool
    }

    record block-explode-event-data {
        block-pos: block-pos,
        yield-rate: f32,
        cancelled: bool
    }

    record block-physics-event-data {
        block-pos: block-pos,
        changed-pos: block-pos,
        cancelled: bool
    }

    record block-piston-extend-event-data {
        block-pos: block-pos,
        direction: string,
        cancelled: bool
    }

    record block-piston-retract-event-data {
        block-pos: block-pos,
        direction: string,
        cancelled: bool
    }

    record note-play-event-data {
        block-pos: block-pos,
        instrument: string,
        note: u8,
        cancelled: bool
    }

    record sign-change-event-data {
        player: player,
        block-pos: block-pos,
        lines: list<string>,
        cancelled: bool
    }

    record sponge-absorb-event-data {
        block-pos: block-pos,
        cancelled: bool
    }

    record tnt-prime-event-data {
        block-pos: block-pos,
        prime-reason: string,
        cancelled: bool
    }

    record map-initialize-event-data {
        map-id: s32
    }

    record hanging-break-event-data {
        entity-id: s32,
        remover-entity-id: option<s32>,
        cancelled: bool
    }

    record hanging-break-by-entity-event-data {
        entity-id: s32,
        remover-entity-id: s32,
        cancelled: bool
    }

    record hanging-place-event-data {
        entity-id: s32,
        player: option<player>,
        block-pos: block-pos,
        block-face: string,
        cancelled: bool
    }

    record bell-resonate-event-data {
        block-pos: block-pos,
        target-world: %world,
        cancelled: bool
    }

    record bell-ring-event-data {
        block-pos: block-pos,
        target-world: %world,
        entity-id: option<s32>,
        direction: option<string>,
        cancelled: bool
    }

    record block-brush-event-data {
        block-pos: block-pos,
        target-world: %world,
        player: player,
        item: item-stack,
        cancelled: bool
    }

    record block-cook-event-data {
        block-pos: block-pos,
        target-world: %world,
        source: item-stack,
        %result: item-stack,
        cancelled: bool
    }

    record block-damage-abort-event-data {
        player: player,
        block-pos: block-pos,
        target-world: %world,
        item-in-hand: item-stack
    }

    record block-dispense-armor-event-data {
        block-pos: block-pos,
        target-world: %world,
        target-entity-id: s32,
        item: item-stack,
        cancelled: bool
    }

    record block-dispense-loot-event-data {
        block-pos: block-pos,
        target-world: %world,
        items: list<item-stack>,
        cancelled: bool
    }

    record block-drop-item-event-data {
        block-pos: block-pos,
        target-world: %world,
        player: option<player>,
        items: list<item-stack>,
        cancelled: bool
    }

    record block-exp-event-data {
        block-pos: block-pos,
        target-world: %world,
        exp: s32
    }

    record block-fertilize-event-data {
        block-pos: block-pos,
        target-world: %world,
        player: option<player>,
        changed-blocks: list<tuple<block-pos, u16>>,
        cancelled: bool
    }

    record block-multi-place-event-data {
        player: player,
        target-world: %world,
        placed-blocks: list<tuple<block-pos, u16>>,
        cancelled: bool
    }

    record block-receive-game-event-data {
        block-pos: block-pos,
        target-world: %world,
        game-event: string,
        source-entity-id: option<s32>,
        cancelled: bool
    }

    record block-shear-entity-event-data {
        block-pos: block-pos,
        target-world: %world,
        target-entity-id: s32,
        item: item-stack,
        cancelled: bool
    }

    record block-spread-event-data {
        source-pos: block-pos,
        target-pos: block-pos,
        target-world: %world,
        new-state-id: u16,
        cancelled: bool
    }

    record brewing-start-event-data {
        block-pos: block-pos,
        target-world: %world,
        brewing-time: s32,
        cancelled: bool
    }

    record campfire-start-event-data {
        block-pos: block-pos,
        target-world: %world,
        item: item-stack,
        slot: u8,
        cooking-time: s32,
        cancelled: bool
    }

    record cauldron-level-change-event-data {
        block-pos: block-pos,
        target-world: %world,
        old-level: s32,
        new-level: s32,
        reason: string,
        entity-id: option<s32>,
        cancelled: bool
    }

    record crafter-craft-event-data {
        block-pos: block-pos,
        target-world: %world,
        %result: item-stack,
        cancelled: bool
    }

    record entity-block-form-event-data {
        entity-id: s32,
        block-pos: block-pos,
        target-world: %world,
        new-state-id: u16,
        cancelled: bool
    }

    record fluid-level-change-event-data {
        block-pos: block-pos,
        target-world: %world,
        new-state-id: u16,
        cancelled: bool
    }

    record inventory-block-start-event-data {
        block-pos: block-pos,
        target-world: %world
    }

    record leaves-decay-event-data {
        block-pos: block-pos,
        target-world: %world,
        cancelled: bool
    }

    record moisture-change-event-data {
        block-pos: block-pos,
        target-world: %world,
        new-moisture: s32,
        cancelled: bool
    }

    record sculk-bloom-event-data {
        block-pos: block-pos,
        target-world: %world,
        charge: s32,
        cancelled: bool
    }

    record vault-display-item-event-data {
        block-pos: block-pos,
        target-world: %world,
        item: item-stack,
        cancelled: bool
    }

    record weather-change-event-data {
        target-world: %world,
        to-weather-state: bool,
        cancelled: bool
    }

    record thunder-change-event-data {
        target-world: %world,
        to-thunder-state: bool,
        cancelled: bool
    }

    record world-load-event-data {
        target-world: %world
    }

    record world-unload-event-data {
        target-world: %world,
        cancelled: bool
    }

    record async-structure-generate-event-data {
        world-name: string,
        structure-name: string,
        pos: block-pos,
        cancelled: bool
    }

    record async-structure-spawn-event-data {
        world-name: string,
        structure-name: string,
        pos: block-pos,
        cancelled: bool
    }

    record chunk-populate-event-data {
        chunk-x: s32,
        chunk-z: s32,
        cancelled: bool
    }

    record chunk-unload-event-data {
        chunk-x: s32,
        chunk-z: s32,
        cancelled: bool
    }

    record entities-load-event-data {
        chunk-x: s32,
        chunk-z: s32,
        entity-count: u32,
        cancelled: bool
    }

    record entities-unload-event-data {
        chunk-x: s32,
        chunk-z: s32,
        entity-count: u32,
        cancelled: bool
    }

    record generic-game-event-data {
        event-id: string,
        pos: position,
        cancelled: bool
    }

    record loot-generate-event-data {
        loot-table: string,
        cancelled: bool
    }

    record portal-create-event-data {
        pos: block-pos,
        portal-type: string,
        cancelled: bool
    }

    record structure-grow-event-data {
        pos: block-pos,
        species: string,
        bone-meal: bool,
        cancelled: bool
    }

    record time-skip-event-data {
        skip-amount: s64,
        cancelled: bool
    }

    record world-init-event-data {
        target-world: %world
    }

    record world-save-event-data {
        world-name: string,
        cancelled: bool
    }

    record inventory-open-event-data {
        player: player,
        cancelled: bool
    }

    record inventory-drag-event-data {
        player: player,
        cancelled: bool
    }

    record craft-item-event-data {
        player: player,
        recipe-id: string,
        cancelled: bool
    }

    record furnace-smelt-event-data {
        block-pos: block-pos,
        source-item: string,
        result-item: string,
        cancelled: bool
    }

    record brew-event-data {
        block-pos: block-pos,
        fuel-level: u8,
        cancelled: bool
    }

    record brewing-stand-fuel-event-data {
        block-pos: block-pos,
        fuel-power: u16,
        cancelled: bool
    }

    record furnace-burn-event-data {
        block-pos: block-pos,
        fuel-item: string,
        burn-time: u32,
        cancelled: bool
    }

    record furnace-extract-event-data {
        player: player,
        block-pos: block-pos,
        item-id: string,
        item-amount: u32,
        exp-gained: f32
    }

    record furnace-start-smelt-event-data {
        block-pos: block-pos,
        source-item: string,
        cooking-time: u32,
        cancelled: bool
    }

    record hopper-inventory-search-event-data {
        block-pos: block-pos,
        search-pos: block-pos,
        cancelled: bool
    }

    record inventory-creative-event-data {
        player: player,
        slot: s16,
        item-id: string,
        item-count: u8,
        cancelled: bool
    }

    record inventory-interact-event-data {
        player: player,
        cancelled: bool
    }

    record inventory-move-item-event-data {
        source-pos: block-pos,
        target-pos: block-pos,
        item-id: string,
        item-amount: u32,
        cancelled: bool
    }

    record inventory-pickup-item-event-data {
        block-pos: block-pos,
        item-entity-id: s32,
        item-id: string,
        cancelled: bool
    }

    record prepare-anvil-event-data {
        player: player,
        rename-text: string,
        repair-cost: u32
    }

    record prepare-grindstone-event-data {
        player: player,
        result-item: option<string>
    }

    record prepare-inventory-result-event-data {
        player: player,
        result-item: option<string>
    }

    record prepare-item-craft-event-data {
        player: player,
        recipe-id: string,
        cancelled: bool
    }

    record prepare-smithing-event-data {
        player: player,
        result-item: option<string>
    }

    record smith-item-event-data {
        player: player,
        recipe-id: string,
        cancelled: bool
    }

    record trade-select-event-data {
        player: player,
        slot-index: u8,
        cancelled: bool
    }

    record vehicle-block-collision-event-data {
        vehicle-id: s32,
        block-pos: block-pos,
        cancelled: bool
    }

    record vehicle-collision-event-data {
        vehicle-id: s32,
        cancelled: bool
    }

    record vehicle-create-event-data {
        vehicle-id: s32,
        cancelled: bool
    }

    record vehicle-damage-event-data {
        vehicle-id: s32,
        damage: f32,
        attacker-id: option<s32>,
        cancelled: bool
    }

    record vehicle-destroy-event-data {
        vehicle-id: s32,
        attacker-id: option<s32>,
        cancelled: bool
    }

    record vehicle-enter-event-data {
        vehicle-id: s32,
        entered-id: s32,
        cancelled: bool
    }

    record vehicle-entity-collision-event-data {
        vehicle-id: s32,
        collided-entity-id: s32,
        cancelled: bool
    }

    record vehicle-exit-event-data {
        vehicle-id: s32,
        exited-id: s32,
        cancelled: bool
    }

    record vehicle-move-event-data {
        vehicle-id: s32,
        from-position: position,
        to-position: position,
        cancelled: bool
    }

    record vehicle-update-event-data {
        vehicle-id: s32,
        cancelled: bool
    }

    record enchantment-offer {
        cost: s32,
        enchantment-id: s32,
        enchantment-level: s32
    }

    record prepare-item-enchant-event-data {
        player: player,
        item: item-stack,
        offers: list<enchantment-offer>,
        bookshelf-count: s32,
        cancelled: bool
    }

    record enchantment-value {
        enchantment: enchantment,
        level: u32
    }

    record enchant-item-event-data {
        player: player,
        item: item-stack,
        %option: s32,
        cost: s32,
        enchantments-to-add: list<enchantment-value>,
        cancelled: bool
    }

    record lightning-strike-event-data {
        position: position,
        is-effect: bool,
        cancelled: bool
    }

    enum event-type {
        player-join-event,
        player-leave-event,
        player-login-event,
        player-chat-event,
        player-command-send-event,
        player-permission-check-event,
        player-move-event,
        player-teleport-event,
        player-change-world-event,
        player-respawn-event,
        player-exp-change-event,
        player-item-held-event,
        player-changed-main-hand-event,
        player-gamemode-change-event,
        player-custom-payload-event,
        player-fish-event,
        player-egg-throw-event,
        player-interact-unknown-entity-event,
        player-interact-entity-event,
        player-interact-event,
        player-toggle-sneak-event,
        player-toggle-flight-event,
        player-toggle-sprint-event,
        inventory-click-event,
        inventory-close-event,
        block-redstone-event,
        block-break-event,
        block-burn-event,
        block-can-build-event,
        block-grow-event,
        block-place-event,
        bedrock-form-response-event,
        dialog-click-action-event,
        dialog-show-event,
        dialog-clear-event,
        server-command-event,
        server-list-ping-event,
        server-load-event,
        spawn-change-event,
        server-broadcast-event,
        server-tick-start-event,
        server-tick-end-event,
        packet-received-event,
        packet-sent-event,
        chunk-load-event,
        chunk-save-event,
        chunk-send-event,
        entity-damage-event,
        entity-death-event,
        player-death-event,
        entity-spawn-event,
        entity-combust-event,
        entity-regain-health-event,
        entity-air-change-event,
        entity-breed-event,
        entity-dismount-event,
        entity-dye-event,
        entity-enter-love-mode-event,
        entity-explode-event,
        entity-mount-event,
        entity-pickup-item-event,
        entity-portal-event,
        entity-resurrect-event,
        entity-shoot-bow-event,
        entity-tame-event,
        entity-target-event,
        entity-teleport-event,
        entity-toggle-glide-event,
        entity-transform-event,
        player-item-consume-event,
        player-item-damage-event,
        player-drop-item-event,
        player-bed-enter-event,
        player-bed-leave-event,
        player-bucket-empty-event,
        player-bucket-fill-event,
        block-damage-event,
        block-ignite-event,
        block-from-to-event,
        block-form-event,
        block-fade-event,
        block-dispense-event,
        block-explode-event,
        block-physics-event,
        block-piston-extend-event,
        block-piston-retract-event,
        note-play-event,
        sign-change-event,
        sponge-absorb-event,
        tnt-prime-event,
        weather-change-event,
        thunder-change-event,
        world-load-event,
        world-unload-event,
        async-structure-generate-event,
        async-structure-spawn-event,
        chunk-populate-event,
        chunk-unload-event,
        entities-load-event,
        entities-unload-event,
        generic-game-event,
        loot-generate-event,
        portal-create-event,
        structure-grow-event,
        time-skip-event,
        world-init-event,
        world-save-event,
        inventory-open-event,
        inventory-drag-event,
        craft-item-event,
        furnace-smelt-event,
        brew-event,
        brewing-stand-fuel-event,
        furnace-burn-event,
        furnace-extract-event,
        furnace-start-smelt-event,
        hopper-inventory-search-event,
        inventory-creative-event,
        inventory-interact-event,
        inventory-move-item-event,
        inventory-pickup-item-event,
        prepare-anvil-event,
        prepare-grindstone-event,
        prepare-inventory-result-event,
        prepare-item-craft-event,
        prepare-smithing-event,
        smith-item-event,
        trade-select-event,
        vehicle-block-collision-event,
        vehicle-collision-event,
        vehicle-create-event,
        vehicle-damage-event,
        vehicle-destroy-event,
        vehicle-enter-event,
        vehicle-entity-collision-event,
        vehicle-exit-event,
        vehicle-move-event,
        vehicle-update-event,
        prepare-item-enchant-event,
        enchant-item-event,
        map-initialize-event,
        hanging-break-event,
        hanging-break-by-entity-event,
        hanging-place-event,
        bell-resonate-event,
        bell-ring-event,
        block-brush-event,
        block-cook-event,
        block-damage-abort-event,
        block-dispense-armor-event,
        block-dispense-loot-event,
        block-drop-item-event,
        block-exp-event,
        block-fertilize-event,
        block-multi-place-event,
        block-receive-game-event,
        block-shear-entity-event,
        block-spread-event,
        brewing-start-event,
        campfire-start-event,
        cauldron-level-change-event,
        crafter-craft-event,
        entity-block-form-event,
        fluid-level-change-event,
        inventory-block-start-event,
        leaves-decay-event,
        moisture-change-event,
        sculk-bloom-event,
        vault-display-item-event,
        creature-spawn-event,
        ender-dragon-change-phase-event,
        entity-break-door-event,
        entity-change-block-event,
        entity-damage-by-block-event,
        entity-damage-by-entity-event,
        entity-drop-item-event,
        entity-enter-block-event,
        entity-exhaustion-event,
        entity-interact-event,
        entity-knockback-event,
        entity-place-event,
        entity-pose-change-event,
        entity-potion-effect-event,
        entity-spell-cast-event,
        entity-target-living-entity-event,
        entity-toggle-swim-event,
        explosion-prime-event,
        firework-explode-event,
        food-level-change-event,
        item-despawn-event,
        item-merge-event,
        item-spawn-event,
        piglin-barter-event,
        projectile-hit-event,
        projectile-launch-event,
        sheep-dye-wool-event,
        sheep-regrow-wool-event,
        slime-split-event,
        strider-temperature-change-event,
        villager-acquire-trade-event,
        villager-career-change-event,
        villager-replenish-trade-event,
        warden-anger-change-event,
        area-effect-cloud-apply-event,
        arrow-body-count-change-event,
        bat-toggle-sleep-event,
        creeper-power-event,
        entity-combust-by-block-event,
        entity-combust-by-entity-event,
        entity-knockback-by-entity-event,
        entity-portal-enter-event,
        entity-portal-exit-event,
        entity-remove-event,
        entity-target-block-event,
        entity-unleash-event,
        exp-bottle-event,
        horse-jump-event,
        lingering-potion-splash-event,
        pig-zap-event,
        pig-zombie-anger-event,
        potion-splash-event,
        spawner-spawn-event,
        trial-spawner-spawn-event,
        villager-reputation-change-event,
        async-player-chat-event,
        async-player-pre-login-event,
        player-advancement-done-event,
        player-animation-event,
        player-armor-stand-manipulate-event,
        player-bucket-entity-event,
        player-changed-world-event,
        player-channel-event,
        player-command-preprocess-event,
        player-edit-book-event,
        player-elytra-boost-event,
        player-exp-cooldown-change-event,
        player-harvest-block-event,
        player-hide-entity-event,
        player-item-break-event,
        player-item-mend-event,
        player-kick-event,
        player-leash-entity-event,
        player-level-change-event,
        player-locale-change-event,
        player-name-entity-event,
        player-open-sign-event,
        player-portal-event,
        player-pre-login-event,
        player-riptide-event,
        player-shear-entity-event,
        player-show-entity-event,
        player-spawn-change-event,
        player-statistic-increment-event,
        player-swap-hands-event,
        player-take-lectern-book-event,
        player-unleash-entity-event,
        player-velocity-event,
        player-input-event,
        player-interact-at-entity-event,
        player-links-send-event,
        player-pickup-arrow-event,
        player-recipe-book-click-event,
        player-recipe-book-settings-change-event,
        player-recipe-discover-event,
        player-register-channel-event,
        player-resource-pack-status-event,
        player-spawn-location-event,
        player-unregister-channel-event,
        raid-finish-event,
        raid-spawn-wave-event,
        raid-stop-event,
        raid-trigger-event,
        lightning-strike-event,
    }

    variant event {
        player-join-event(player-join-event-data),
        player-leave-event(player-leave-event-data),
        player-login-event(player-login-event-data),
        player-chat-event(player-chat-event-data),
        player-command-send-event(player-command-send-event-data),
        player-permission-check-event(player-permission-check-event-data),
        player-move-event(player-move-event-data),
        player-teleport-event(player-teleport-event-data),
        player-change-world-event(player-change-world-event-data),
        player-respawn-event(player-respawn-event-data),
        player-exp-change-event(player-exp-change-event-data),
        player-item-held-event(player-item-held-event-data),
        player-changed-main-hand-event(player-changed-main-hand-event-data),
        player-gamemode-change-event(player-gamemode-change-event-data),
        player-custom-payload-event(player-custom-payload-event-data),
        player-fish-event(player-fish-event-data),
        player-egg-throw-event(player-egg-throw-event-data),
        player-interact-unknown-entity-event(player-interact-unknown-entity-event-data),
        player-interact-entity-event(player-interact-entity-event-data),
        player-interact-event(player-interact-event-data),
        player-toggle-sneak-event(player-toggle-sneak-event-data),
        player-toggle-flight-event(player-toggle-flight-event-data),
        player-toggle-sprint-event(player-toggle-sprint-event-data),
        inventory-click-event(inventory-click-event-data),
        inventory-close-event(inventory-close-event-data),
        block-redstone-event(block-redstone-event-data),
        block-break-event(block-break-event-data),
        block-burn-event(block-burn-event-data),
        block-can-build-event(block-can-build-event-data),
        block-grow-event(block-grow-event-data),
        block-place-event(block-place-event-data),
        dialog-click-action-event(dialog-click-action-event-data),
        dialog-show-event(dialog-show-event-data),
        dialog-clear-event(dialog-clear-event-data),
        bedrock-form-response-event(bedrock-form-response-event-data),
        server-command-event(server-command-event-data),
        server-list-ping-event(server-list-ping-event-data),
        server-load-event(server-load-event-data),
        spawn-change-event(spawn-change-event-data),
        server-broadcast-event(server-broadcast-event-data),
        server-tick-start-event(server-tick-start-event-data),
        server-tick-end-event(server-tick-end-event-data),
        packet-received-event(packet-received-event-data),
        packet-sent-event(packet-sent-event-data),
        chunk-load-event(chunk-load-event-data),
        chunk-save-event(chunk-save-event-data),
        chunk-send-event(chunk-send-event-data),
        entity-damage-event(entity-damage-event-data),
        entity-death-event(entity-death-event-data),
        player-death-event(player-death-event-data),
        entity-spawn-event(entity-spawn-event-data),
        entity-combust-event(entity-combust-event-data),
        entity-regain-health-event(entity-regain-health-event-data),
        entity-air-change-event(entity-air-change-event-data),
        entity-breed-event(entity-breed-event-data),
        entity-dismount-event(entity-dismount-event-data),
        entity-dye-event(entity-dye-event-data),
        entity-enter-love-mode-event(entity-enter-love-mode-event-data),
        entity-explode-event(entity-explode-event-data),
        entity-mount-event(entity-mount-event-data),
        entity-pickup-item-event(entity-pickup-item-event-data),
        entity-portal-event(entity-portal-event-data),
        entity-resurrect-event(entity-resurrect-event-data),
        entity-shoot-bow-event(entity-shoot-bow-event-data),
        entity-tame-event(entity-tame-event-data),
        entity-target-event(entity-target-event-data),
        entity-teleport-event(entity-teleport-event-data),
        entity-toggle-glide-event(entity-toggle-glide-event-data),
        entity-transform-event(entity-transform-event-data),
        player-item-consume-event(player-item-consume-event-data),
        player-item-damage-event(player-item-damage-event-data),
        player-drop-item-event(player-drop-item-event-data),
        player-bed-enter-event(player-bed-enter-event-data),
        player-bed-leave-event(player-bed-leave-event-data),
        player-bucket-empty-event(player-bucket-empty-event-data),
        player-bucket-fill-event(player-bucket-fill-event-data),
        block-damage-event(block-damage-event-data),
        block-ignite-event(block-ignite-event-data),
        block-from-to-event(block-from-to-event-data),
        block-form-event(block-form-event-data),
        block-fade-event(block-fade-event-data),
        block-dispense-event(block-dispense-event-data),
        block-explode-event(block-explode-event-data),
        block-physics-event(block-physics-event-data),
        block-piston-extend-event(block-piston-extend-event-data),
        block-piston-retract-event(block-piston-retract-event-data),
        note-play-event(note-play-event-data),
        sign-change-event(sign-change-event-data),
        sponge-absorb-event(sponge-absorb-event-data),
        tnt-prime-event(tnt-prime-event-data),
        weather-change-event(weather-change-event-data),
        thunder-change-event(thunder-change-event-data),
        world-load-event(world-load-event-data),
        world-unload-event(world-unload-event-data),
        async-structure-generate-event(async-structure-generate-event-data),
        async-structure-spawn-event(async-structure-spawn-event-data),
        chunk-populate-event(chunk-populate-event-data),
        chunk-unload-event(chunk-unload-event-data),
        entities-load-event(entities-load-event-data),
        entities-unload-event(entities-unload-event-data),
        generic-game-event(generic-game-event-data),
        loot-generate-event(loot-generate-event-data),
        portal-create-event(portal-create-event-data),
        structure-grow-event(structure-grow-event-data),
        time-skip-event(time-skip-event-data),
        world-init-event(world-init-event-data),
        world-save-event(world-save-event-data),
        inventory-open-event(inventory-open-event-data),
        inventory-drag-event(inventory-drag-event-data),
        craft-item-event(craft-item-event-data),
        furnace-smelt-event(furnace-smelt-event-data),
        brew-event(brew-event-data),
        brewing-stand-fuel-event(brewing-stand-fuel-event-data),
        furnace-burn-event(furnace-burn-event-data),
        furnace-extract-event(furnace-extract-event-data),
        furnace-start-smelt-event(furnace-start-smelt-event-data),
        hopper-inventory-search-event(hopper-inventory-search-event-data),
        inventory-creative-event(inventory-creative-event-data),
        inventory-interact-event(inventory-interact-event-data),
        inventory-move-item-event(inventory-move-item-event-data),
        inventory-pickup-item-event(inventory-pickup-item-event-data),
        prepare-anvil-event(prepare-anvil-event-data),
        prepare-grindstone-event(prepare-grindstone-event-data),
        prepare-inventory-result-event(prepare-inventory-result-event-data),
        prepare-item-craft-event(prepare-item-craft-event-data),
        prepare-smithing-event(prepare-smithing-event-data),
        smith-item-event(smith-item-event-data),
        trade-select-event(trade-select-event-data),
        vehicle-block-collision-event(vehicle-block-collision-event-data),
        vehicle-collision-event(vehicle-collision-event-data),
        vehicle-create-event(vehicle-create-event-data),
        vehicle-damage-event(vehicle-damage-event-data),
        vehicle-destroy-event(vehicle-destroy-event-data),
        vehicle-enter-event(vehicle-enter-event-data),
        vehicle-entity-collision-event(vehicle-entity-collision-event-data),
        vehicle-exit-event(vehicle-exit-event-data),
        vehicle-move-event(vehicle-move-event-data),
        vehicle-update-event(vehicle-update-event-data),
        prepare-item-enchant-event(prepare-item-enchant-event-data),
        enchant-item-event(enchant-item-event-data),
        map-initialize-event(map-initialize-event-data),
        hanging-break-event(hanging-break-event-data),
        hanging-break-by-entity-event(hanging-break-by-entity-event-data),
        hanging-place-event(hanging-place-event-data),
        bell-resonate-event(bell-resonate-event-data),
        bell-ring-event(bell-ring-event-data),
        block-brush-event(block-brush-event-data),
        block-cook-event(block-cook-event-data),
        block-damage-abort-event(block-damage-abort-event-data),
        block-dispense-armor-event(block-dispense-armor-event-data),
        block-dispense-loot-event(block-dispense-loot-event-data),
        block-drop-item-event(block-drop-item-event-data),
        block-exp-event(block-exp-event-data),
        block-fertilize-event(block-fertilize-event-data),
        block-multi-place-event(block-multi-place-event-data),
        block-receive-game-event(block-receive-game-event-data),
        block-shear-entity-event(block-shear-entity-event-data),
        block-spread-event(block-spread-event-data),
        brewing-start-event(brewing-start-event-data),
        campfire-start-event(campfire-start-event-data),
        cauldron-level-change-event(cauldron-level-change-event-data),
        crafter-craft-event(crafter-craft-event-data),
        entity-block-form-event(entity-block-form-event-data),
        fluid-level-change-event(fluid-level-change-event-data),
        inventory-block-start-event(inventory-block-start-event-data),
        leaves-decay-event(leaves-decay-event-data),
        moisture-change-event(moisture-change-event-data),
        sculk-bloom-event(sculk-bloom-event-data),
        vault-display-item-event(vault-display-item-event-data),
        creature-spawn-event(creature-spawn-event-data),
        ender-dragon-change-phase-event(ender-dragon-change-phase-event-data),
        entity-break-door-event(entity-break-door-event-data),
        entity-change-block-event(entity-change-block-event-data),
        entity-damage-by-block-event(entity-damage-by-block-event-data),
        entity-damage-by-entity-event(entity-damage-by-entity-event-data),
        entity-drop-item-event(entity-drop-item-event-data),
        entity-enter-block-event(entity-enter-block-event-data),
        entity-exhaustion-event(entity-exhaustion-event-data),
        entity-interact-event(entity-interact-event-data),
        entity-knockback-event(entity-knockback-event-data),
        entity-place-event(entity-place-event-data),
        entity-pose-change-event(entity-pose-change-event-data),
        entity-potion-effect-event(entity-potion-effect-event-data),
        entity-spell-cast-event(entity-spell-cast-event-data),
        entity-target-living-entity-event(entity-target-living-entity-event-data),
        entity-toggle-swim-event(entity-toggle-swim-event-data),
        explosion-prime-event(explosion-prime-event-data),
        firework-explode-event(firework-explode-event-data),
        food-level-change-event(food-level-change-event-data),
        item-despawn-event(item-despawn-event-data),
        item-merge-event(item-merge-event-data),
        item-spawn-event(item-spawn-event-data),
        piglin-barter-event(piglin-barter-event-data),
        projectile-hit-event(projectile-hit-event-data),
        projectile-launch-event(projectile-launch-event-data),
        sheep-dye-wool-event(sheep-dye-wool-event-data),
        sheep-regrow-wool-event(sheep-regrow-wool-event-data),
        slime-split-event(slime-split-event-data),
        strider-temperature-change-event(strider-temperature-change-event-data),
        villager-acquire-trade-event(villager-acquire-trade-event-data),
        villager-career-change-event(villager-career-change-event-data),
        villager-replenish-trade-event(villager-replenish-trade-event-data),
        warden-anger-change-event(warden-anger-change-event-data),
        area-effect-cloud-apply-event(area-effect-cloud-apply-event-data),
        arrow-body-count-change-event(arrow-body-count-change-event-data),
        bat-toggle-sleep-event(bat-toggle-sleep-event-data),
        creeper-power-event(creeper-power-event-data),
        entity-combust-by-block-event(entity-combust-by-block-event-data),
        entity-combust-by-entity-event(entity-combust-by-entity-event-data),
        entity-knockback-by-entity-event(entity-knockback-by-entity-event-data),
        entity-portal-enter-event(entity-portal-enter-event-data),
        entity-portal-exit-event(entity-portal-exit-event-data),
        entity-remove-event(entity-remove-event-data),
        entity-target-block-event(entity-target-block-event-data),
        entity-unleash-event(entity-unleash-event-data),
        exp-bottle-event(exp-bottle-event-data),
        horse-jump-event(horse-jump-event-data),
        lingering-potion-splash-event(lingering-potion-splash-event-data),
        pig-zap-event(pig-zap-event-data),
        pig-zombie-anger-event(pig-zombie-anger-event-data),
        potion-splash-event(potion-splash-event-data),
        spawner-spawn-event(spawner-spawn-event-data),
        trial-spawner-spawn-event(trial-spawner-spawn-event-data),
        villager-reputation-change-event(villager-reputation-change-event-data),
        async-player-chat-event(async-player-chat-event-data),
        async-player-pre-login-event(async-player-pre-login-event-data),
        player-advancement-done-event(player-advancement-done-event-data),
        player-animation-event(player-animation-event-data),
        player-armor-stand-manipulate-event(player-armor-stand-manipulate-event-data),
        player-bucket-entity-event(player-bucket-entity-event-data),
        player-changed-world-event(player-changed-world-event-data),
        player-channel-event(player-channel-event-data),
        player-command-preprocess-event(player-command-preprocess-event-data),
        player-edit-book-event(player-edit-book-event-data),
        player-elytra-boost-event(player-elytra-boost-event-data),
        player-exp-cooldown-change-event(player-exp-cooldown-change-event-data),
        player-harvest-block-event(player-harvest-block-event-data),
        player-hide-entity-event(player-hide-entity-event-data),
        player-item-break-event(player-item-break-event-data),
        player-item-mend-event(player-item-mend-event-data),
        player-kick-event(player-kick-event-data),
        player-leash-entity-event(player-leash-entity-event-data),
        player-level-change-event(player-level-change-event-data),
        player-locale-change-event(player-locale-change-event-data),
        player-name-entity-event(player-name-entity-event-data),
        player-open-sign-event(player-open-sign-event-data),
        player-portal-event(player-portal-event-data),
        player-pre-login-event(player-pre-login-event-data),
        player-riptide-event(player-riptide-event-data),
        player-shear-entity-event(player-shear-entity-event-data),
        player-show-entity-event(player-show-entity-event-data),
        player-spawn-change-event(player-spawn-change-event-data),
        player-statistic-increment-event(player-statistic-increment-event-data),
        player-swap-hands-event(player-swap-hands-event-data),
        player-take-lectern-book-event(player-take-lectern-book-event-data),
        player-unleash-entity-event(player-unleash-entity-event-data),
        player-velocity-event(player-velocity-event-data),
        player-input-event(player-input-event-data),
        player-interact-at-entity-event(player-interact-at-entity-event-data),
        player-links-send-event(player-links-send-event-data),
        player-pickup-arrow-event(player-pickup-arrow-event-data),
        player-recipe-book-click-event(player-recipe-book-click-event-data),
        player-recipe-book-settings-change-event(player-recipe-book-settings-change-event-data),
        player-recipe-discover-event(player-recipe-discover-event-data),
        player-register-channel-event(player-register-channel-event-data),
        player-resource-pack-status-event(player-resource-pack-status-event-data),
        player-spawn-location-event(player-spawn-location-event-data),
        player-unregister-channel-event(player-unregister-channel-event-data),
        raid-finish-event(raid-finish-event-data),
        raid-spawn-wave-event(raid-spawn-wave-event-data),
        raid-stop-event(raid-stop-event-data),
        raid-trigger-event(raid-trigger-event-data),
        lightning-strike-event(lightning-strike-event-data),
    }
}