interface event {
    use common.{block-pos, game-mode, hand, position, click-type};
    use item-stack.{item-stack};
    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};

    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<string>,
        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<string>
    }

    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 custom-click-action-event-data {
        player: player,
        id: string,
        payload: option<list<u8>>,
    }

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

    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,
        cause: string,
        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 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 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 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 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
    }

    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,
        custom-click-action-event,
        server-command-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,
        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,
        weather-change-event,
        thunder-change-event,
        world-load-event,
        world-unload-event,
        inventory-open-event,
        inventory-drag-event,
        craft-item-event,
        furnace-smelt-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),
        bedrock-form-response-event(bedrock-form-response-event-data),
        custom-click-action-event(custom-click-action-event-data),
        server-command-event(server-command-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),
        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),
        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),
        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),
    }
}