package pumpkin:plugin@0.1.0;

interface bedrock-packets {
  use uuid.{ uuid };
  record s-actor-event {
    entity-runtime-id: s64,
    event-type: string,
    event-data: s32,
    fire-at-position: option<tuple<f64, f64, f64>>,
  }
  record s-animate {
    action: string,
    runtime-entity-id: s64,
    data: f32,
    swing-source: option<string>,
  }
  record s-block-pick-request {
    block-pos: tuple<s32, s32, s32>,
    add-block-nbt: bool,
    hotbar-slot: u8,
  }
  record s-client-cache-blob-status {
    miss-hashes: list<s64>,
    hit-hashes: list<s64>,
  }
  record s-client-cache-status {
    cache-supported: bool,
  }
  record s-command-request {
    command: string,
    command-type: string,
    command-uuid: uuid,
    request-id: string,
    player-actor-unique-id: s64,
    is-internal-source: bool,
    version: string,
  }
  record s-container-close {
    container-id: u8,
    container-type: u8,
    server-initiated: bool,
  }
  record s-emote {
    runtime-entity-id: s64,
    emote-length: s32,
    emote-id: string,
    xuid: string,
    platform-id: string,
    %flags: u8,
  }
  record s-emote-list {
    runtime-entity-id: s64,
    emote-pieces: list<uuid>,
  }
  record s-interaction {
    action: string,
    target-runtime-id: s64,
    position: option<tuple<f64, f64, f64>>,
  }
  record s-inventory-transaction {
    legacy-request-id: s32,
    legacy-set-item-slots: list<string>,
    has-value: bool,
    actions: list<string>,
    transaction-type: s32,
    transaction-data: string,
  }
  record s-item-stack-request {
    requests: list<string>,
  }
  record s-loading-screen {
    status: s32,
    id: option<s32>,
  }
  record s-login {
    protocol-version: s32,
    jwt: list<u8>,
    raw-token: list<u8>,
  }
  record s-mob-equipment {
    entity-runtime-id: s64,
    item: string,
    inventory-slot: u8,
    hotbar-slot: u8,
    window-id: u8,
  }
  record s-modal-form-response {
    form-id: s32,
    form-data: option<string>,
    cancel-reason: option<u8>,
  }
  record s-packet-violation-warning {
    violation-type: s32,
    severity: s32,
    packet-id: s32,
    context: string,
  }
  record s-player-action {
    runtime-id: s64,
    action: string,
    block-pos: tuple<s32, s32, s32>,
    result-pos: tuple<s32, s32, s32>,
    face: s32,
  }
  record s-player-auth-input {
    pitch: f32,
    yaw: f32,
    position: tuple<f64, f64, f64>,
    move-vec: string,
    head-yaw: f32,
    input-data: string,
    input-mode: s32,
    play-mode: s32,
    interaction-model: s32,
    interact-pitch: f32,
    interact-yaw: f32,
    tick: s64,
    delta: tuple<f64, f64, f64>,
    block-actions: option<list<string>>,
    item-interaction: option<string>,
    item-stack-request: option<string>,
    vehicle-rotation: option<string>,
    vehicle-unique-id: option<s64>,
    analog-move: string,
    camera-orientation: tuple<f64, f64, f64>,
    raw-move: string,
  }
  record s-player-hotbar {
    selected-slot: s32,
    container-id: u8,
    select-slot: bool,
  }
  record s-request-ability {
    ability: s32,
    value: string,
  }
  record s-request-chunk-radius {
    chunk-radius: s32,
    max-radius: u8,
  }
  record s-request-network-settings {
    protocol-version: s32,
  }
  record s-resource-pack-response {
    response: u8,
    download-size: s32,
    pack-ids: list<string>,
  }
  record s-respawn {
    position: tuple<f64, f64, f64>,
    state: string,
    player-runtime-id: s64,
  }
  record s-set-local-player-as-initialized {
    runtime-entity-id: s64,
  }
  record s-set-player-inventory-options {
    left-inventory-tab: s32,
    right-inventory-tab: s32,
    filtering: bool,
    inventory-layout: s32,
    crafting-layout: s32,
  }
  record s-text {
    needs-translation: bool,
    r-type: string,
    source-name: string,
    message: string,
    parameters: list<string>,
    xuid: string,
    platform-chat-id: string,
    filtered-message: option<string>,
  }
  record c-add-actor {
    entity-unique-id: s64,
    entity-runtime-id: s64,
    entity-type: string,
    position: tuple<f64, f64, f64>,
    velocity: tuple<f64, f64, f64>,
    pitch: f32,
    yaw: f32,
    head-yaw: f32,
    body-yaw: f32,
    attributes: list<string>,
    metadata: string,
    synced-properties: string,
    links: list<string>,
  }
  record c-add-item-actor {
    entity-unique-id: s64,
    entity-runtime-id: s64,
    item: string,
    position: tuple<f64, f64, f64>,
    velocity: tuple<f64, f64, f64>,
    metadata: string,
    from-fishing: bool,
  }
  record c-add-player {
    uuid: uuid,
    username: string,
    entity-runtime-id: s64,
    platform-chat-id: string,
    position: tuple<f64, f64, f64>,
    velocity: tuple<f64, f64, f64>,
    pitch: f32,
    yaw: f32,
    head-yaw: f32,
    held-item: string,
    game-mode: s32,
    metadata: string,
    properties: string,
    ability-data: string,
    links: list<string>,
    device-id: string,
    build-platform: string,
  }
  record c-available-commands {
    enum-values: list<string>,
    chained-subcommand-values: list<string>,
    suffixes: list<string>,
    enums: list<string>,
    chained-subcommands: list<string>,
    commands: list<string>,
    soft-enums: list<string>,
    constraints: list<string>,
  }
  record c-block-actor-data {
    position: tuple<s32, s32, s32>,
    data: string,
  }
  record c-block-event {
    position: tuple<s32, s32, s32>,
    event-type: s32,
    event-data: s32,
  }
  record c-boss-event {
    boss-entity-id: s64,
    action: string,
  }
  record c-change-dimension {
    dimension: s32,
    position: tuple<f64, f64, f64>,
    respawn: bool,
    loading-screen-id: option<s32>,
  }
  record c-chunk-radius-update {
    chunk-radius: s32,
  }
  record c-client-cache-miss-response {
    blobs: list<string>,
  }
  record c-container-open {
    container-id: u8,
    container-type: u8,
    position: tuple<s32, s32, s32>,
    target-entity-id: s64,
  }
  record c-correct-player-move {
    prediction-type: u8,
    pos: tuple<f64, f64, f64>,
    pos-delta: tuple<f64, f64, f64>,
    rotation: string,
    vehicle-angular-velocity: option<f32>,
    on-ground: bool,
    tick: s64,
  }
  record c-crafting-data {
    recipes: list<string>,
    clean-recipes: bool,
  }
  record c-creative-content {
    groups: list<string>,
    entries: list<string>,
  }
  record c-disconnect-player {
    reason: s32,
    skip-message: bool,
    message: string,
    filtered-message: string,
  }
  record c-gamerules-changed {
    rule-data: string,
  }
  record c-inventory-content {
    container-id: s32,
    slots: list<string>,
    full-container-name: string,
    storage-item: string,
  }
  record c-inventory-slot {
    window-id: s32,
    inventory-slot: s32,
    container-name: option<string>,
    storage: option<string>,
    item: string,
  }
  record c-item-registry {
    items: list<string>,
  }
  record c-item-stack-response {
    responses: list<string>,
  }
  record c-level-chunk {
    dimension: s32,
    cache-enabled: bool,
    chunk: string,
    block-actors: list<string>,
  }
  record c-level-event {
    event-id: s32,
    position: tuple<f64, f64, f64>,
    data: s32,
  }
  record c-level-sound-event {
    sound-id: string,
    position: tuple<f64, f64, f64>,
    extra-data: s32,
    entity-type: string,
    is-baby-mob: bool,
    is-global: bool,
    actor-unique-id: s64,
    fire-at-position: option<tuple<f64, f64, f64>>,
  }
  record c-mob-effect {
    runtime-entity-id: s64,
    event-id: u8,
    effect-id: s32,
    amplifier: s32,
    particles: bool,
    duration: s32,
    tick: s64,
    ambient: bool,
  }
  record c-mob-equipment {
    entity-runtime-id: s64,
    item: string,
    inventory-slot: u8,
    hotbar-slot: u8,
    window-id: u8,
  }
  record c-modal-form-request {
    form-id: s32,
    form-data: string,
  }
  record c-move-actor-absolute {
    entity-runtime-id: s64,
    %flags: u8,
    position: tuple<f64, f64, f64>,
    pitch: u8,
    yaw: u8,
    head-yaw: u8,
  }
  record c-move-actor-delta {
    entity-runtime-id: s64,
    %flags: s32,
    x: f32,
    y: f32,
    z: f32,
    pitch: u8,
    yaw: u8,
    head-yaw: u8,
  }
  record c-move-player {
    player-runtime-id: s64,
    position: tuple<f64, f64, f64>,
    pitch: f32,
    yaw: f32,
    head-yaw: f32,
    mode: u8,
    on-ground: bool,
    riding-runtime-id: s64,
    teleport-cause: s32,
    teleport-source-entity-type: s32,
    tick: s64,
  }
  record c-network-chunk-publisher-update {
    pos-for-view: tuple<s32, s32, s32>,
    new-radius: s32,
    server-build-chunk-list: list<string>,
  }
  record c-network-settings {
    compression-threshold: s32,
    compression-method: s32,
    client-throttle-enabled: bool,
    client-throttle-threshold: u8,
    client-throttle-scalar: f32,
  }
  enum c-play-status {
    login-success,
    outdated-client,
    outdated-server,
    player-spawn,
    invalid-tenant,
    edition-mismatch-edu-to-vanilla,
    edition-mismatch-vanilla-to-edu,
    server-full-sub-client,
    editor-mismatch-editor-to-vanilla,
    editor-mismatch-vanilla-to-editor,
  }
  record c-player-hotbar {
    selected-slot: s32,
    container-id: u8,
    should-select-block: bool,
  }
  record c-player-list {
    action: u8,
    entries: list<string>,
  }
  record c-remove-actor {
    entity-unique-id: s64,
  }
  record c-resource-pack-stack-packet {
    resource-pack-required: bool,
    resource-packs: list<string>,
    game-version: string,
    experiments: string,
    include-editor-packs: bool,
  }
  record c-resource-packs-info {
    resource-pack-required: bool,
    has-addon-packs: bool,
    has-scripts: bool,
    is-vibrant-visuals-force-disabled: bool,
    world-template-id: uuid,
    world-template-version: string,
    resource-packs: list<string>,
  }
  record c-respawn {
    position: tuple<f64, f64, f64>,
    state: string,
    player-runtime-id: s64,
  }
  record c-set-display-objective {
    display-slot: string,
    objective-name: string,
    display-name: string,
    criteria-name: string,
    sort-order: s32,
  }
  record c-set-score {
    action: s32,
    entries: list<string>,
  }
  record c-remove-objective {
    objective-name: string,
  }
  record c-set-actor-data {
    actor-runtime-id: s64,
    metadata: string,
    synced-properties: string,
    tick: s64,
  }
  record c-set-actor-link {
    link: string,
  }
  record c-set-actor-motion {
    target-runtime-id: s64,
    motion: tuple<f64, f64, f64>,
    tick: s64,
  }
  record c-set-difficulty {
    difficulty: s32,
  }
  record c-set-health {
    health: s32,
  }
  record c-set-player-gamemode {
    gamemode: string,
  }
  record c-set-spawn-position {
    spawn-type: s32,
    position: tuple<s32, s32, s32>,
    dimension: s32,
    spawn-position: tuple<s32, s32, s32>,
  }
  record c-set-time {
    time: s32,
  }
  record c-set-title {
    action-type: s32,
    text: string,
    fade-in-duration: s32,
    remain-duration: s32,
    fade-out-duration: s32,
    xuid: string,
    platform-online-id: string,
    filtered-message: string,
  }
  record c-show-credits {
    player-runtime-id: s64,
    status: s32,
  }
  record c-start-game {
    entity-id: s64,
    runtime-entity-id: s64,
    player-gamemode: string,
    position: tuple<f64, f64, f64>,
    pitch: f32,
    yaw: f32,
    level-settings: string,
    level-id: string,
    level-name: string,
    premium-world-template-id: string,
    is-trial: bool,
    rewind-history-size: s32,
    server-authoritative-block-breaking: bool,
    current-level-time: s64,
    enchantment-seed: s32,
    block-properties-size: s32,
    multiplayer-correlation-id: string,
    enable-itemstack-net-manager: bool,
    server-version: string,
    compound-id: u8,
    compound-len: s32,
    compound-end: u8,
    block-registry-checksum: s64,
    world-template-id: uuid,
    enable-clientside-generation: bool,
    blocknetwork-ids-are-hashed: bool,
    server-auth-sounds: bool,
    server-join-information: option<string>,
    telemetry: string,
  }
  record c-take-item-actor {
    item-runtime-id: s64,
    actor-runtime-id: s64,
  }
  record c-transfer {
    address: string,
    port: s32,
    reload-world: bool,
  }
  record c-update-abilities {
    target-player-raw-id: s64,
    player-permission: u8,
    command-permission: u8,
    layers: list<string>,
  }
  record c-update-attributes {
    runtime-id: s64,
    attributes: list<string>,
    player-tick: s64,
  }
  record c-update-block {
    position: tuple<s32, s32, s32>,
    block-runtime-id: s32,
    %flags: s32,
    layer: s32,
  }
  variant serverbound-packet {
    s-actor-event(s-actor-event),
    s-animate(s-animate),
    s-block-pick-request(s-block-pick-request),
    s-client-cache-blob-status(s-client-cache-blob-status),
    s-client-cache-status(s-client-cache-status),
    s-command-request(s-command-request),
    s-container-close(s-container-close),
    s-emote(s-emote),
    s-emote-list(s-emote-list),
    s-interaction(s-interaction),
    s-inventory-transaction(s-inventory-transaction),
    s-item-stack-request(s-item-stack-request),
    s-loading-screen(s-loading-screen),
    s-login(s-login),
    s-mob-equipment(s-mob-equipment),
    s-modal-form-response(s-modal-form-response),
    s-packet-violation-warning(s-packet-violation-warning),
    s-player-action(s-player-action),
    s-player-auth-input(s-player-auth-input),
    s-player-hotbar(s-player-hotbar),
    s-request-ability(s-request-ability),
    s-request-chunk-radius(s-request-chunk-radius),
    s-request-network-settings(s-request-network-settings),
    s-resource-pack-response(s-resource-pack-response),
    s-respawn(s-respawn),
    s-set-local-player-as-initialized(s-set-local-player-as-initialized),
    s-set-player-inventory-options(s-set-player-inventory-options),
    s-text(s-text),
    unknown,
  }
  variant clientbound-packet {
    c-add-actor(c-add-actor),
    c-add-item-actor(c-add-item-actor),
    c-add-player(c-add-player),
    c-available-commands(c-available-commands),
    c-biome-definition-list,
    c-block-actor-data(c-block-actor-data),
    c-block-event(c-block-event),
    c-boss-event(c-boss-event),
    c-change-dimension(c-change-dimension),
    c-chunk-radius-update(c-chunk-radius-update),
    c-client-cache-miss-response(c-client-cache-miss-response),
    c-container-open(c-container-open),
    c-correct-player-move(c-correct-player-move),
    c-crafting-data(c-crafting-data),
    c-creative-content(c-creative-content),
    c-disconnect-player(c-disconnect-player),
    c-gamerules-changed(c-gamerules-changed),
    c-inventory-content(c-inventory-content),
    c-inventory-slot(c-inventory-slot),
    c-item-registry(c-item-registry),
    c-item-stack-response(c-item-stack-response),
    c-level-chunk(c-level-chunk),
    c-level-event(c-level-event),
    c-level-sound-event(c-level-sound-event),
    c-mob-effect(c-mob-effect),
    c-mob-equipment(c-mob-equipment),
    c-modal-form-request(c-modal-form-request),
    c-move-actor-absolute(c-move-actor-absolute),
    c-move-actor-delta(c-move-actor-delta),
    c-move-player(c-move-player),
    c-network-chunk-publisher-update(c-network-chunk-publisher-update),
    c-network-settings(c-network-settings),
    c-play-status(c-play-status),
    c-player-hotbar(c-player-hotbar),
    c-player-list(c-player-list),
    c-remove-actor(c-remove-actor),
    c-resource-pack-stack-packet(c-resource-pack-stack-packet),
    c-resource-packs-info(c-resource-packs-info),
    c-respawn(c-respawn),
    c-set-display-objective(c-set-display-objective),
    c-set-score(c-set-score),
    c-remove-objective(c-remove-objective),
    c-set-actor-data(c-set-actor-data),
    c-set-actor-link(c-set-actor-link),
    c-set-actor-motion(c-set-actor-motion),
    c-set-difficulty(c-set-difficulty),
    c-set-health(c-set-health),
    c-set-player-gamemode(c-set-player-gamemode),
    c-set-spawn-position(c-set-spawn-position),
    c-set-time(c-set-time),
    c-set-title(c-set-title),
    c-show-credits(c-show-credits),
    c-start-game(c-start-game),
    c-take-item-actor(c-take-item-actor),
    c-transfer(c-transfer),
    c-update-abilities(c-update-abilities),
    c-update-attributes(c-update-attributes),
    c-update-block(c-update-block),
    unknown,
  }
}