[🎉] Added 1.19

1 files changed, 5078 insertions, 0 deletions

diff --git a/src/v1_19.rs b/src/v1_19.rs
new file mode 100644
index 0000000..ae5cb3a
--- /dev/null
+++ b/src/v1_19.rs
@@ -0,0 +1,5078 @@
+use crate::{types::*, uuid::*, *};
+use alloc::fmt;
+use alloc::{
+    borrow::ToOwned,
+    // boxed::Box,
+    string::{String, ToString},
+    vec::Vec,
+};
+use fmt::Debug;
+
+#[cfg(all(test, feature = "std"))]
+use crate::protocol::TestRandom;
+
+define_protocol!(759, Packet759, RawPacket759, RawPacket759Body, Packet759Kind => {
+    // handshaking
+    Handshake, 0x00, Handshaking, ServerBound => HandshakeSpec {
+        version: VarInt,
+        server_address: String,
+        server_port: u16,
+        next_state: HandshakeNextState
+    },
+
+    // status
+    StatusRequest, 0x00, Status, ServerBound => StatusRequestSpec {},
+    StatusPing, 0x01, Status, ServerBound => StatusPingSpec {
+        payload: i64
+    },
+    StatusResponse, 0x00, Status, ClientBound => StatusResponseSpec {
+        response: super::status::StatusSpec
+    },
+    StatusPong, 0x01, Status, ClientBound => StatusPongSpec {
+        payload: i64
+    },
+
+    // login
+    LoginDisconnect, 0x00, Login, ClientBound => LoginDisconnectSpec {
+        message: Chat
+    },
+    LoginEncryptionRequest, 0x01, Login, ClientBound => LoginEncryptionRequestSpec {
+        server_id: String,
+        public_key: CountedArray<u8, VarInt>,
+        verify_token: CountedArray<u8, VarInt>
+    },
+    LoginSuccess, 0x02, Login, ClientBound => LoginSuccessSpec {
+        uuid: UUID4,
+        username: String
+    },
+    LoginSetCompression, 0x03, Login, ClientBound => LoginSetCompressionSpec {
+        threshold: VarInt
+    },
+    LoginPluginRequest, 0x04, Login, ClientBound => LoginPluginRequestSpec {
+        message_id: VarInt,
+        channel: String,
+        data: RemainingBytes
+    },
+    LoginStart, 0x00, Login, ServerBound => LoginStartSpec {
+        name: String
+    },
+    LoginEncryptionResponse, 0x01, Login, ServerBound => LoginEncryptionResponseSpec {
+        shared_secret: CountedArray<u8, VarInt>,
+        verify_token: CountedArray<u8, VarInt>
+    },
+    LoginPluginResponse, 0x02, Login, ServerBound => LoginPluginResponseSpec {
+        message_id: VarInt,
+        successful: bool,
+        data: RemainingBytes
+    },
+
+    // play
+    // client bound
+    PlaySpawnEntity, 0x00, Play, ClientBound => PlaySpawnEntitySpec {
+        entity_id: VarInt,
+        object_uuid: UUID4,
+        entity_type: VarInt,
+        position: Vec3<f64>,
+        pitch: Angle,
+        yaw: Angle,
+        data: i32,
+        velocity: Vec3<i16>
+    },
+    PlaySpawnExperienceOrb, 0x01, Play, ClientBound => PlaySpawnExperienceOrbSpec {
+        entity_id: VarInt,
+        position: Vec3<f64>,
+        count: i16
+    },
+    PlaySpawnLivingEntity, 0x02, Play, ClientBound => PlaySpawnLivingEntitySpec {
+        entity_id: VarInt,
+        entity_uuid: UUID4,
+        entity_type: VarInt,
+        location: EntityLocation<f64, Angle>,
+        head_pitch: Angle,
+        velocity: Vec3<i16>
+    },
+    PlaySpawnPainting, 0x03, Play, ClientBound => PlaySpawnPaintingSpec {
+        entity_id: VarInt,
+        entity_uuid: UUID4,
+        motive: VarInt,
+        location: IntPosition,
+        direction: CardinalDirection
+    },
+    PlaySpawnPlayer, 0x04, Play, ClientBound => PlaySpawnPlayerSpec {
+        entity_id: VarInt,
+        uuid: UUID4,
+        location: EntityLocation<f64, Angle>
+    },
+    PlaySculkVibrationSignal, 0x05, Play, ClientBound => PlaySculkVibrationSignalSpec {
+        source_position: IntPosition,
+        destination: SculkDestinationIdentifier,
+        arrival_ticks: VarInt
+    },
+    PlayEntityAnimation, 0x06, Play, ClientBound => PlayEntityAnimationSpec {
+        entity_id: VarInt,
+        animation: EntityAnimationKind
+    },
+    PlayStatistics, 0x07, Play, ClientBound => PlayStatisticsSpec {
+        entries: CountedArray<Statistic, VarInt>
+    },
+    PlayAcknowledgePlayerDigging, 0x08, Play, ClientBound => PlayAcknowledgePlayerDiggingSpec {
+        location: IntPosition,
+        block: VarInt,
+        status: DiggingStatus,
+        successful: bool
+    },
+    PlayBlockBreakAnimation, 0x09, Play, ClientBound => PlayBlockBreakAnimationSpec {
+        entity_id: VarInt,
+        location: IntPosition,
+        destroy_stage: i8
+    },
+    PlayBlockEntityData, 0x0A, Play, ClientBound => PlayBlockEntityDataSpec {
+        location: IntPosition,
+        action: BlockEntityDataAction,
+        nbt_data: NamedNbtTag
+    },
+    PlayBlockAction, 0x0B, Play, ClientBound => PlayBlockActionSpec {
+        location: IntPosition,
+        action_id: u8,
+        action_payload: u8,
+        block_type: VarInt
+    },
+    PlayBlockChange, 0x0C, Play, ClientBound => PlayBlockChangeSpec {
+        location: IntPosition,
+        block_id: VarInt
+    },
+    PlayBossBar, 0x0D, Play, ClientBound => PlayBossBarSpec {
+        uuid: UUID4,
+        action: BossBarAction
+    },
+    PlayServerDifficulty, 0x0E, Play, ClientBound => PlayServerDifficultySpec {
+        difficulty: Difficulty,
+        locked: bool
+    },
+    PlayServerChatMessage, 0x0F, Play, ClientBound => PlayServerChatMessageSpec {
+        message: Chat,
+        position: ChatPosition,
+        sender: UUID4
+    },
+    PlayClearTitles, 0x10, Play, ClientBound => PlayClearTitlesSpec {
+        reset: bool
+    },
+    PlayTabComplete, 0x11, Play, ClientBound => PlayTabCompleteSpec {
+        id: VarInt,
+        start: VarInt,
+        length: VarInt,
+        matches: CountedArray<TabCompleteMatch, VarInt>
+    },
+    PlayDeclareCommands, 0x12, Play, ClientBound => PlayDeclareCommandsSpec {
+        nodes: CountedArray<CommandNodeSpec, VarInt>,
+        root_index: VarInt
+    },
+    PlayServerCloseWindow, 0x13, Play, ClientBound => PlayServerCloseWindowSpec {
+        window_id: u8
+    },
+    PlayWindowItems, 0x14, Play, ClientBound => PlayWindowItemsSpec {
+        window_id: u8,
+        state_id: VarInt,
+        slots: CountedArray<Slot, VarInt>,
+        carried_item: Slot
+    },
+    PlayWindowProperty, 0x15, Play, ClientBound => PlayWindowPropertySpec {
+        window_id: u8,
+        property: i16,
+        value: i16
+    },
+    PlaySetSlot, 0x16, Play, ClientBound => PlaySetSlotSpec {
+        window_id: u8,
+        slot: i16,
+        slot_data: Slot
+    },
+    PlaySetCooldown, 0x17, Play, ClientBound => PlaySetCooldownSpec {
+        item_id: VarInt,
+        cooldown_ticks: VarInt
+    },
+    PlayServerPluginMessage, 0x18, Play, ClientBound => PlayServerPluginMessageSpec {
+        channel: String,
+        data: RemainingBytes
+    },
+    PlayNamedSoundEffect, 0x19, Play, ClientBound => PlayNamedSoundEffectSpec {
+        sound_name: String,
+        sound_category: SoundCategory,
+        position: Vec3<FixedInt>,
+        volume: f32,
+        pitch: f32
+    },
+    PlayDisconnect, 0x1A, Play, ClientBound => PlayDisconnectSpec {
+        reason: Chat
+    },
+    PlayEntityStatus, 0x1B, Play, ClientBound => PlayEntityStatusSpec {
+        entity_id: i32,
+        raw_status: u8 // todo deal with the gigantic table
+    },
+    PlayExplosion, 0x1C, Play, ClientBound => PlayExplosionSpec {
+        position: Vec3<f32>,
+        strength: f32,
+        records: CountedArray<Vec3<i8>, VarInt>,
+        player_motion: Vec3<f32>
+    },
+    PlayUnloadChunk, 0x1D, Play, ClientBound => PlayUnloadChunkSpec {
+        position: ChunkPosition<i32>
+    },
+    PlayChangeGameState, 0x1E, Play, ClientBound => PlayChangeGameStateSpec {
+        reason: GameChangeReason
+    },
+    PlayOpenHorseWindow, 0x1F, Play, ClientBound => PlayOpenHorseWindowSpec {
+        window_id: u8,
+        number_of_slots: VarInt,
+        entity_id: i32
+    },
+    PlayInitializeWorldBorder, 0x20, Play, ClientBound => PlayInitializeWorldBorderSpec {
+        x: f64,
+        z: f64,
+        old_diameter: f64,
+        new_diameter: f64,
+        speed: VarLong,
+        portal_teleport_boundary: VarInt,
+        warning_blocks: VarInt,
+        warning_time: VarInt
+    },
+    PlayServerKeepAlive, 0x21, Play, ClientBound => PlayServerKeepAliveSpec {
+        id: i64
+    },
+    PlayChunkData, 0x22, Play, ClientBound => PlayChunkDataWrapper {
+        x: i32,
+        z: i32,
+        primary_bit_mask: CountedArray<i64, VarInt>,
+        heightmaps: NamedNbtTag,
+        biomes: CountedArray<VarInt, VarInt>,
+        data: CountedArray<u8, VarInt>,
+        block_entities: CountedArray<NamedNbtTag, VarInt>
+    },
+    PlayEffect, 0x23, Play, ClientBound => PlayEffectSpec {
+        effect_id: EffectKind,
+        location: IntPosition,
+        data: i32,
+        disable_relative_volume: bool
+    },
+    PlayParticle, 0x24, Play, ClientBound => PlayParticleSpec {
+        particle_id: i32,
+        long_distance: bool,
+        position: Vec3<f64>,
+        offset: Vec3<f32>,
+        particle_data: i32,
+        data: RemainingBytes // todo
+    },
+    PlayUpdateLight, 0x25, Play, ClientBound => PlayUpdateLightSpec {
+        chunk: ChunkPosition<VarInt>,
+        trust_edges: bool,
+        sky_light_mask: CountedArray<i64, VarInt>,
+        block_light_mask: CountedArray<i64, VarInt>,
+        empty_sky_light_mask: CountedArray<i64, VarInt>,
+        empty_block_light_mask: CountedArray<i64, VarInt>,
+        sky_lights: CountedArray<CountedArray<i8, VarInt>, VarInt>,
+        block_lights: CountedArray<CountedArray<i8, VarInt>, VarInt>
+    },
+    PlayJoinGame, 0x26, Play, ClientBound => PlayJoinGameSpec {
+        entity_id: i32,
+        is_hardcore: bool,
+        gamemode: GameMode,
+        previous_gamemode: PreviousGameMode,
+        worlds: CountedArray<String, VarInt>,
+        dimension_codec: NamedNbtTag,
+        dimension: NamedNbtTag,
+        world_name: String,
+        hashed_seed: i64,
+        max_players: VarInt,
+        view_distance: VarInt,
+        reduced_debug_info: bool,
+        enable_respawn_screen: bool,
+        is_debug: bool,
+        is_flat: bool
+    },
+    PlayMapData, 0x27, Play, ClientBound => PlayMapDataSpec {
+        map_id: VarInt,
+        scale: i8,
+        locked: bool,
+        tracking_position: bool,
+        icons: CountedArray<MapIconSpec, VarInt>,
+        columns: MapColumns
+    },
+    PlayTradeList, 0x28, Play, ClientBound => PlayTradeListSpec {
+        window_id: VarInt,
+        trades: CountedArray<TradeSpec, i8>,
+        villager_level: VarInt,
+        experience: VarInt,
+        regular_villager: bool,
+        can_restock: bool
+    },
+    PlayEntityPosition, 0x29, Play, ClientBound => PlayEntityPositionSpec {
+        entity_id: VarInt,
+        delta: Vec3<i16>,
+        on_ground: bool
+    },
+    PlayEntityPositionAndRotation, 0x2A, Play, ClientBound => PlayEntityPositionAndRotationSpec {
+        entity_id: VarInt,
+        delta: EntityLocation<i16, Angle>,
+        on_ground: bool
+    },
+    PlayEntityRotation, 0x2B, Play, ClientBound => PlayEntityRotationSpec {
+        entity_id: VarInt,
+        rotation: EntityRotation<Angle>,
+        on_ground: bool
+    },
+    PlayServerVehicleMove, 0x2C, Play, ClientBound => PlayEntityVehicleMoveSpec {
+        location: EntityLocation<f64, f32>
+    },
+    PlayOpenBook, 0x2D, Play, ClientBound => PlayOpenBookSpec {
+        hand: Hand
+    },
+    PlayOpenWindow, 0x2E, Play, ClientBound => PlayOpenWindowSpec {
+        id: VarInt,
+        kind: WindowType,
+        title: Chat
+    },
+    PlayOpenSignEditor, 0x2F, Play, ClientBound => PlayOpenSignEditorSpec {
+        location: IntPosition
+    },
+    PlayPing, 0x30, Play, ClientBound => PlayPingSpec {
+        id: i32
+    },
+    PlayCraftRecipeResponse, 0x31, Play, ClientBound => PlayCraftRecipeResponseSpec {
+        window_id: u8, // TODO: should be i8?
+        recipe: String
+    },
+    PlayServerPlayerAbilities, 0x32, Play, ClientBound => PlayServerPlayerAbilitiesSpec {
+        flags: PlayerAbilityFlags,
+        flying_speed: f32,
+        field_of_view_modifier: f32
+    },
+    PlayEndCombatEvent, 0x33, Play, ClientBound => PlayEndCombatEventSpec {
+        duration_ticks: VarInt,
+        entity_id: i32
+    },
+    PlayEnterCombatEvent, 0x34, Play, ClientBound => PlayEnterCombatEventSpec {},
+    PlayDeathCombatEvent, 0x35, Play, ClientBound => PlayDeathCombatEventSpec {
+        player_id: VarInt,
+        entity_id: i32,
+        message: Chat
+    },
+    PlayPlayerInfo, 0x36, Play, ClientBound => PlayPlayerInfoSpec {
+        actions: PlayerInfoActionList
+    },
+    PlayFacePlayer, 0x37, Play, ClientBound => PlayFacePlayerSpec {
+        face_kind: FacePlayerKind,
+        target: Vec3<f64>,
+        entity: Option<FacePlayerEntityTarget>
+    },
+    PlayServerPlayerPositionAndLook, 0x38, Play, ClientBound => PlayServerPlayerPositionAndLookSpec {
+        location: EntityLocation<f64, f32>,
+        flags: PositionAndLookFlags,
+        teleport_id: VarInt,
+        dismount_vehicle: bool
+    },
+    PlayUnlockRecipes, 0x39, Play, ClientBound => PlayUnlockRecipesSpec {
+        action: RecipeUnlockAction,
+        crafting_book_open: bool,
+        crafting_book_active: bool,
+        smelting_book_open: bool,
+        smelting_book_active: bool,
+        blast_furnace_recipe_book_open: bool,
+        blast_furnace_recipe_book_active: bool,
+        smoke_recipe_book_open: bool,
+        smoke_recipe_book_active: bool,
+        recipe_ids: CountedArray<String, VarInt>,
+        other_recipe_ids: RemainingBytes // todo
+    },
+    PlayDestroyEntities, 0x3A, Play, ClientBound => PlayDestroyEntitySpec {
+        entity_ids: CountedArray<VarInt, VarInt>
+    },
+    PlayRemoveEntityEffect, 0x3B, Play, ClientBound => PlayRemoveEntityEffectSpec {
+        entity_id: VarInt,
+        effect: EntityEffectKind
+    },
+    PlayResourcePackSend, 0x3C, Play, ClientBound => PlayResourcePackSendSpec {
+        url: String,
+        hash: String,
+        forced: bool,
+        forced_message: Chat
+    },
+    PlayRespawn, 0x3D, Play, ClientBound => PlayRespawnSpec {
+        dimension: NamedNbtTag,
+        world_name: String,
+        hashed_seed: i64,
+        gamemode: GameMode,
+        previous_gamemode: GameMode,
+        is_debug: bool,
+        is_flat: bool,
+        copy_metadata: bool
+    },
+    PlayEntityHeadLook, 0x3E, Play, ClientBound => PlayEntityHeadLookSpec {
+        entity_id: VarInt,
+        head_yaw: Angle
+    },
+    PlayMultiBlockChange, 0x3F, Play, ClientBound => PlayMultiBlockChangeSpec {
+        chunk: ChunkSectionPosition,
+        not_trust_edges: bool,
+        blocks: CountedArray<MultiBlockChangeRecord, VarInt>
+    },
+    PlaySelectAdvancementTab, 0x40, Play, ClientBound => PlaySelectAdvancementTabSpec {
+        identifier: Option<String>
+    },
+    PlayActionBar, 0x41, Play, ClientBound => PlayActionBarSpec {
+        text: Chat
+    },
+    PlayWorldBorderCenter, 0x42, Play, ClientBound => PlayWorldBorderCenterSpec {
+        x: f64,
+        z: f64
+    },
+    PlayWorldBorderLerpSize, 0x43, Play, ClientBound => PlayWorldBorderLerpSizeSpec {
+        old_diameter: f64,
+        new_diameter: f64,
+        speed: VarLong
+    },
+    PlayWorldBorderSize, 0x44, Play, ClientBound => PlayWorldBorderSizeSpec {
+        diameter: f64
+    },
+    PlayWorldBorderWarningDelay, 0x45, Play, ClientBound => PlayWorldBorderWarningDelaySpec {
+        warning_time: VarInt
+    },
+    PlayWorldBorderWarningReach, 0x46, Play, ClientBound => PlayWorldBorderWarningReachSpec {
+        warning_blocks: VarInt
+    },
+    PlayCamera, 0x47, Play, ClientBound => PlayCameraSpec {
+        camera_id: VarInt
+    },
+    PlayServerHeldItemChange, 0x48, Play, ClientBound => PlayServerHeldItemChangeSpec {
+        slot: i8
+    },
+    PlayUpdateViewPosition, 0x49, Play, ClientBound => PlayUpdateViewPositionSpec {
+        chunk: ChunkPosition<VarInt>
+    },
+    PlayUpdateViewDistance, 0x4A, Play, ClientBound => PlayUpdateViewDistanceSpec {
+        view_distance: VarInt
+    },
+    PlaySpawnPosition, 0x4B, Play, ClientBound => PlaySpawnPositionSpec {
+        location: IntPosition,
+        angle: f32
+    },
+    PlayDisplayScoreboard, 0x4C, Play, ClientBound => PlayDisplayScoreboardSpec {
+        position: ScoreboardPosition,
+        score_name: String
+    },
+    PlayEntityMetadata, 0x4D, Play, ClientBound => PlayEntityMetadataSpec {
+        entity_id: VarInt,
+        metadata: EntityMetadata
+    },
+    PlayAttachEntity, 0x4E, Play, ClientBound => PlayAttachEntitySpec {
+        attached_entity_id: i32,
+        holding_entity_id: i32
+    },
+    PlayEntityVelocity, 0x4F, Play, ClientBound => PlayEntityVelocitySpec {
+        entity_id: VarInt,
+        velocity: Vec3<i16>
+    },
+    PlayEntityEquipment, 0x50, Play, ClientBound => PlayEntityEquiptmentSpec {
+        entity_id: VarInt,
+        equipment: EntityEquipmentArray
+    },
+    PlaySetExperience, 0x51, Play, ClientBound => PlaySetExperienceSpec {
+        experience_bar: f32,
+        level: VarInt,
+        total_experience: VarInt
+    },
+    PlayUpdatehealth, 0x52, Play, ClientBound => PlayUpdateHealthSpec {
+        health: f32,
+        food: VarInt,
+        saturation: f32
+    },
+    PlayScoreboardObjective, 0x53, Play, ClientBound => PlayScoreboardObjectiveSpec {
+        objective_name: String,
+        action: ScoreboardObjectiveAction
+    },
+    PlaySetPassengers, 0x54, Play, ClientBound => PlaySetPassengersSpec {
+        entity_id: VarInt,
+        passenger_entitiy_ids: CountedArray<VarInt, VarInt>
+    },
+    PlayTeams, 0x55, Play, ClientBound => PlayTeamsSpec {
+        team_name: String,
+        action: TeamAction
+    },
+    PlayUpdateScore, 0x56, Play, ClientBound => PlayUpdateScoreSpec {
+        entity_name: TeamMember,
+        update: UpdateScoreSpec
+    },
+    PlaySetTitleSubTitle, 0x57, Play, ClientBound => PlaySetTitleSubTitleSpec {
+        text: Chat
+    },
+    PlayTimeUpdate, 0x58, Play, ClientBound => PlayTimeUpdateSpec {
+        world_age: i64,
+        time_of_day: i64
+    },
+    PlaySetTitleText, 0x59, Play, ClientBound => PlaySetTitleTextSpec {
+        text: Chat
+    },
+    PlaySetTitleTimes, 0x5A, Play, ClientBound => PlaySetTitleTimesSpec {
+        fade_in: i32,
+        stay: i32,
+        fade_out: i32
+    },
+    PlayEntitySoundEffect, 0x5B, Play, ClientBound => PlayEntitySoundEffectSpec {
+        sound_id: VarInt,
+        sound_category: SoundCategory,
+        entity_id: VarInt,
+        volume: f32,
+        pitch: f32
+    },
+    PlaySoundEffect, 0x5C, Play, ClientBound => PlaySoundEffectSpec {
+        sound_id: VarInt,
+        sound_category: SoundCategory,
+        position: Vec3<FixedInt>,
+        volume: f32,
+        pitch: f32
+    },
+    PlayStopSound, 0x5D, Play, ClientBound => PlayStopSoundSpec {
+        spec: StopSoundSpec
+    },
+    PlayerPlayerListHeaderAndFooter, 0x5E, Play, ClientBound => PlayPlayerListHeaderAndFooterSpec {
+        header: Chat,
+        footer: Chat
+    },
+    PlayNbtQueryResponse, 0x5F, Play, ClientBound => PlayNbtQueryResponseSpec {
+        transaction_id: VarInt,
+        nbt: NamedNbtTag
+    },
+    PlayCollectItem, 0x60, Play, ClientBound => PlayCollectItemSpec {
+        collected_entity_id: VarInt,
+        collector_entity_id: VarInt,
+        pickup_item_count: VarInt
+    },
+    PlayEntityTeleport, 0x61, Play, ClientBound => PlayEntityTeleportSpec {
+        entity_id: VarInt,
+        location: EntityLocation<f64, Angle>,
+        on_ground: bool
+    },
+    PlayAdvancements, 0x62, Play, ClientBound => PlayAdvancementsSpec {
+        reset: bool,
+        mappings: CountedArray<AdvancementMappingEntrySpec, VarInt>,
+        identifiers: CountedArray<String, VarInt>,
+        progress: CountedArray<AdvancementProgressEntrySpec, VarInt>
+    },
+    PlayEntityProperties, 0x63, Play, ClientBound => PlayEntityPropertiesSpec {
+        entity_id: VarInt,
+        properties: CountedArray<EntityPropertySpec, VarInt>
+    },
+    PlayEntityEffect, 0x64, Play, ClientBound => PlayEntityEffectSpec {
+        entity_id: VarInt,
+        effect_id: EntityEffectKind,
+        amplifier: i8,
+        duration_ticks: VarInt,
+        flags: EntityEffectFlags
+    },
+    PlayDeclareRecipes, 0x65, Play, ClientBound => PlayDeclareRecipesSpec {
+        recipes: CountedArray<RecipeSpec, VarInt>
+    },
+    PlayTags, 0x66, Play, ClientBound => PlayTagsSpec {
+        tags: CountedArray<TypedTagList, VarInt>
+    },
+
+    // play server bound
+    PlayTeleportConfirm, 0x00, Play, ServerBound => PlayTeleportConfirmSpec {
+        teleport_id: VarInt
+    },
+    PlayQueryBlockNbt, 0x01, Play, ServerBound => PlayQueryBlockNbtSpec {
+        transaction_id: VarInt,
+        location: IntPosition
+    },
+    PlaySetDifficulty, 0x02, Play, ServerBound => PlaySetDifficultySpec {
+        new_difficulty: Difficulty
+    },
+    PlayClientChatMessage, 0x03, Play, ServerBound => PlayClientChatMessageSpec {
+        message: String
+    },
+    PlayClientStatus, 0x04, Play, ServerBound => PlayClientStatusSpec {
+        action: ClientStatusAction
+    },
+    PlayClientSettings, 0x05, Play, ServerBound => PlayClientSettingsSpec {
+        locale: String,
+        view_distance: i8,
+        chat_mode: ClientChatMode,
+        chat_colors: bool,
+        displayed_skin_parts: ClientDisplayedSkinParts,
+        main_hand: ClientMainHand,
+        disable_text_filtering: bool
+    },
+    PlayClientTabComplete, 0x06, Play, ServerBound => PlayClientTabCompleteSpec {
+        transaction_id: VarInt,
+        text: String
+    },
+    PlayClickWindowButton, 0x07, Play, ServerBound => PlayClickWindowButtonSpec {
+        window_id: i8,
+        button_id: i8
+    },
+    PlayClickWindow, 0x08, Play, ServerBound => PlayClickWindowSpec {
+        window_id: u8, // TODO: should be u8?
+        state_id: VarInt,
+        slot: i16,
+        button: i8,
+        mode: InventoryOperationMode,
+        slots: CountedArray<SlotAtSpec, VarInt>,
+        clicked_item: Slot
+    },
+    PlayClientCloseWindow, 0x09, Play, ServerBound => PlayClientCloseWindowSpec {
+        window_id: u8
+    },
+    PlayClientPluginMessage, 0x0A, Play, ServerBound => PlayClientPluginMessageSpec {
+        channel: String,
+        data: RemainingBytes
+    },
+    PlayEditBook, 0x0B, Play, ServerBound => PlayEditBookSpec {
+        hand: Hand,
+        pages: CountedArray<String, VarInt>,
+        title: Option<String>
+    },
+    PlayQueryEntityNbt, 0x0C, Play, ServerBound => PlayQueryEntityNbtSpec {
+        transaction_id: VarInt,
+        entity_id: VarInt
+    },
+    PlayInteractEntity, 0x0D, Play, ServerBound => PlayInteractEntitySpec {
+        entity_id: VarInt,
+        kind: InteractKind,
+        sneaking: bool
+    },
+    PlayGenerateStructure, 0x0E, Play, ServerBound => PlayGenerateStructureSpec {
+        location: IntPosition,
+        levels: VarInt,
+        keep_jigsaws: bool
+    },
+    PlayClientKeepAlive, 0x0F, Play, ServerBound => PlayClientKeepAliveSpec {
+        id: i64
+    },
+    PlayLockDifficulty, 0x10, Play, ServerBound => PlayLockDifficultySpec {
+        locked: bool
+    },
+    PlayPlayerPosition, 0x11, Play, ServerBound => PlayPlayerPositionSpec {
+        feet_position: Vec3<f64>,
+        on_ground: bool
+    },
+    PlayClientPlayerPositionAndRotation, 0x12, Play, ServerBound => PlayClientPlayerPositionAndRotationSpec {
+        feet_location: EntityLocation<f64, f32>,
+        on_ground: bool
+    },
+    PlayPlayerRotation, 0x13, Play, ServerBound => PlayPlayerRotationSpec {
+        rotation: EntityRotation<f32>,
+        on_ground: bool
+    },
+    PlayPlayerMovement, 0x14, Play, ServerBound => PlayPlayerMovementSpec {
+        on_ground: bool
+    },
+    PlayClientVehicleMove, 0x15, Play, ServerBound => PlayClientVehicleMoveSpec {
+        location: EntityLocation<f64, f32>
+    },
+    PlaySteerBoat, 0x16, Play, ServerBound => PlaySteerBoatSpec {
+        left_paddle_turning: bool,
+        right_paddle_turning: bool
+    },
+    PlayPickItem, 0x17, Play, ServerBound => PlayPickItemSpec {
+        slot_idx: VarInt
+    },
+    PlayCraftRecipeRequest, 0x18, Play, ServerBound => PlayCraftRecipeRequestSpec {
+        window_id: i8,
+        recipe: String,
+        make_all: bool
+    },
+    PlayClientPlayerAbilities, 0x19, Play, ServerBound => PlayClientPlayerAbilitiesSpec {
+        flags: ClientPlayerAbilities
+    },
+    PlayPlayerDigging, 0x1A, Play, ServerBound => PlayPlayerDiggingSpec {
+        status: PlayerDiggingStatus,
+        location: IntPosition,
+        face: DiggingFace
+    },
+    PlayEntityAction, 0x1B, Play, ServerBound => PlayEntityActionSpec {
+        entity_id: VarInt,
+        action: EntityActionKind,
+        jump_boot: VarInt
+    },
+    PlaySteerVehicle, 0x1C, Play, ServerBound => PlaySteerVehicleSpec {
+        sideways: f32,
+        forward: f32,
+        flags: SteerVehicleFlags
+    },
+    PlayPong, 0x1D, Play, ServerBound => PlayPongSpec {
+        id: i32
+    },
+    PlaySetRecipeBookState, 0x1E, Play, ServerBound => PlaySetRecipeBookStateSpec {
+        book_id: RecipeBookType,
+        open: bool,
+        filtered: bool
+    },
+    PlaySetDisplayedRecipe, 0x1F, Play, ServerBound => PlaySetDisplayedRecipeSpec {
+        recipe_id: String
+    },
+    PlayNameItem, 0x20, Play, ServerBound => PlayNameItemSpec {
+        name: String
+    },
+    PlayResourcePackStatus, 0x21, Play, ServerBound => PlayResourcePackStatusSpec {
+        status: ResourcePackStatus
+    },
+    PlayAdvancementTab, 0x22, Play, ServerBound => PlayAdvancementTabSpec {
+        action: AdvancementTabAction
+    },
+    PlaySelectTrade, 0x23, Play, ServerBound => PlaySelectTradeSpec {
+        selected_slot: VarInt
+    },
+    PlaySetBeaconEffect, 0x24, Play, ServerBound => PlaySetBeaconEffectSpec {
+        primary_effect: VarInt,
+        secondary_effect: VarInt
+    },
+    PlayClientHeldItemChange, 0x25, Play, ServerBound => PlayClientHeldItemChangeSpec {
+        slot: i16
+    },
+    PlayUpdateCommandBlock, 0x26, Play, ServerBound => PlayUpdateCommandBlockSpec {
+        location: IntPosition,
+        command: String,
+        mode: CommandBlockMode,
+        flags: CommandBlockFlags
+    },
+    PlayUpdateCommandBlockMinecart, 0x27, Play, ServerBound => PlayUpdateCommandBlockMinecartSpec {
+        entity_id: VarInt,
+        command: String,
+        track_output: bool
+    },
+    PlayCreativeInventoryAction, 0x28, Play, ServerBound => PlayCreativeInventoryActionSpec {
+        slot: i16,
+        clicked_item: Slot
+    },
+    PlayUpdateJigsawBlock, 0x29, Play, ServerBound => PlayUpdateJigsawBlockSpec {
+        location: IntPosition,
+        attachment_type: String,
+        target_pool: String,
+        final_state: String
+    },
+    PlayUpdateStructureBlock, 0x2A, Play, ServerBound => PlayUpdateStructureBlockSpec {
+        location: IntPosition,
+        action: UpdateStructureBlockAction,
+        mode: UpdateStructureBlockMode,
+        name: String,
+        offset: Vec3<i8>,
+        size: Vec3<i8>,
+        mirror: UpdateStructureBlockMirror,
+        rotation: UpdateStructureBlockRotation,
+        metadata: String,
+        integrity: f32,
+        seed: VarLong,
+        flags: UpdateStructureBlockFlags
+    },
+    PlayUpdateSign, 0x2B, Play, ServerBound => PlayUpdateSignSpec {
+        location: IntPosition,
+        line1: String,
+        line2: String,
+        line3: String,
+        line4: String
+    },
+    PlayClientAnimation, 0x2C, Play, ServerBound => PlayClientAnimationSpec {
+        hand: Hand
+    },
+    PlaySpectate, 0x2D, Play, ServerBound => PlaySpectateSpec {
+        target: UUID4
+    },
+    PlayBlockPlacement, 0x2E, Play, ServerBound => PlayBlockPlacementSpec {
+        hand: Hand,
+        location: IntPosition,
+        face: DiggingFace,
+        cursor_position: Vec3<f32>,
+        inside_block: bool
+    },
+    PlayUseItem, 0x2F, Play, ServerBound => PlayUseItemSpec {
+        hand: Hand
+    }
+});
+
+// helper types
+
+// handshake enum
+proto_byte_enum!(HandshakeNextState,
+    0x01 :: Status,
+    0x02 :: Login
+);
+
+proto_byte_enum!(CardinalDirection,
+    0x00 :: South,
+    0x01 :: West,
+    0x02 :: North,
+    0x03:: East
+);
+
+proto_byte_enum!(EntityAnimationKind,
+    0x00 :: SwingMainArm,
+    0x01 :: TakeDamage,
+    0x02 :: LeaveBed,
+    0x03 :: SwingOffHand,
+    0x04 :: CriticalEffect,
+    0x05 :: MagicCriticalEffect
+);
+
+proto_varint_enum!(StatisticCategory,
+    0x00 :: Mined(VarInt),
+    0x01 :: Crafted(VarInt),
+    0x02 :: Used(VarInt),
+    0x03 :: Broken(VarInt),
+    0x04 :: PickedUp(VarInt),
+    0x05 :: Dropped(VarInt),
+    0x06 :: Killed(VarInt),
+    0x07 :: KilledBy(VarInt),
+    0x08 :: Custom(StatisticKind)
+);
+
+proto_varint_enum!(StatisticKind,
+    0x00 :: LeaveGame,
+    0x01 :: PlayOneMinute,
+    0x02 :: TimeSinceDeath,
+    0x03 :: SneakTime,
+    0x04 :: WealkOneCm,
+    0x05 :: CrouchOneCm,
+    0x06 :: SprintOneCm,
+    0x07 :: SwimOneCm,
+    0x08 :: FallOneCm,
+    0x09 :: ClimbOneCm,
+    0x0A :: FlyOneCm,
+    0x0B :: DiveOneCm,
+    0x0C :: MinecartOneCm,
+    0x0D :: BoatOneCm,
+    0x0E :: PigOneCm,
+    0x0F :: HorseOneCm,
+    0x10 :: AviateOneCm,
+    0x11 :: Jumps,
+    0x12 :: Drops,
+    0x13 :: DamageDealt,
+    0x14 :: DamageTaken,
+    0x15 :: Deaths,
+    0x16 :: MobKills,
+    0x17 :: AnimalsBread,
+    0x18 :: PlayerKills,
+    0x19 :: FishCaught,
+    0x1A :: TalkedToVillager,
+    0x1B :: TradedWithVillager,
+    0x1C :: EatCakeSlice,
+    0x1D :: FillCauldron,
+    0x1E :: UseCauldron,
+    0x1F :: CleanArmor,
+    0x20 :: CleanBanner,
+    0x21 :: InteractWithBrewingStand,
+    0x22 :: InteractWithBeaccon,
+    0x23 :: InspectDropper,
+    0x24 :: InspectHopper,
+    0x25 :: InspectDispenser,
+    0x26 :: PlayNoteBlock,
+    0x27 :: TuneNoteBlock,
+    0x28 :: PotFlower,
+    0x29 :: TriggerTrappedChest,
+    0x2A :: OpenEnderChest,
+    0x2B :: EnchantItem,
+    0x2C :: PlayRecord,
+    0x2D :: InteractWithFurnace,
+    0x2E :: InteractWithCraftingTable,
+    0x2F :: OpenChest,
+    0x30 :: SleepInBed,
+    0x31 :: OpenShulkerBox
+);
+
+proto_struct!(Statistic {
+    kind: StatisticCategory,
+    value: VarInt
+});
+
+proto_byte_enum!(DiggingStatus,
+    0x00 :: Started,
+    0x01 :: Cancelled,
+    0x02 :: Finished
+);
+
+proto_byte_enum!(BlockEntityDataAction,
+    0x01 :: SetMobSpawnerData,
+    0x02 :: SetCommandBlockText,
+    0x03 :: SetBeaconLevelAndPower,
+    0x04 :: SetMobHeadRotationAndSkin,
+    0x05 :: DeclareConduit,
+    0x06 :: SetBannerColorAndPatterns,
+    0x07 :: SetStructureTileEntityData,
+    0x08 :: SetEndGatewayDestination,
+    0x09 :: SetSignText,
+    0x0B :: DeclareBed,
+    0x0C :: SetJigsawBlockData,
+    0x0D :: SetCampfireItems,
+    0x0E :: BeehiveInformation
+);
+
+proto_byte_enum!(Difficulty,
+    0x00 :: Peaceful,
+    0x01 :: Easy,
+    0x02 :: Normal,
+    0x03 :: Hard
+);
+
+proto_byte_enum!(ChatPosition,
+    0x00 :: ChatBox,
+    0x01 :: SystemMessage,
+    0x02 :: Hotbar
+);
+
+proto_str_enum!(SculkDestinationIdentifier,
+    "block" :: Block(IntPosition),
+    "entity" :: Entity(VarInt)
+);
+
+proto_int_enum!(EffectKind,
+    1000 :: DispenserDispenses,
+    1001 :: DispenserFails,
+    1002 :: DispenserShoots,
+    1003 :: EnderEyeLaunched,
+    1004 :: FireworkShot,
+    1005 :: IronDoorOpened,
+    1006 :: WoodenDoorOpened,
+    1007 :: WoodenTrapdoorOpened,
+    1008 :: FenceGateOpened,
+    1009 :: FireExtinguished,
+    1010 :: PlayRecord,
+    1011 :: IronDoorClosed,
+    1012 :: WoodenDoorClosed,
+    1013 :: WoodenTrapdoorClosed,
+    1014 :: FenceGateClosed,
+    1015 :: GhastWarns,
+    1016 :: GhastShoots,
+    1017 :: EnderDragonShoots,
+    1018 :: BlazeShoots,
+    1019 :: ZombieAttacksWoodDoor,
+    1020 :: ZombieAttacksIronDoor,
+    1021 :: ZombieBreaksWoodDoor,
+    1022 :: WitherBreaksBlock,
+    1023 :: WitherSpawned,
+    1024 :: WitherShoots,
+    1025 :: BatTakesOff,
+    1026 :: ZombieInfects,
+    1027 :: ZombieVillagerConverted,
+    1028 :: EnderDragonDeath,
+    1029 :: AnvilDestroyed,
+    1030 :: AnvilUsed,
+    1031 :: AnvilLanded,
+    1032 :: PortalTravel,
+    1033 :: ChorusFlowerGrown,
+    1034 :: ChorusFlowerDied,
+    1035 :: BrewingStandBrewed,
+    1036 :: IronTrapdoorOpened,
+    1037 :: IronTrapdoorClosed,
+    1038 :: EndPortalCreatedInOverworld,
+    1039 :: PhantomBites,
+    1040 :: ZombieConvertsToDrowned,
+    1041 :: HuskConvertsToZombieByDrowning,
+    1042 :: GrindstoneUsed,
+    1043 :: BookPageTurned,
+    // particles:
+    1500 :: ComposterComposts,
+    1501 :: LavaConvertsBlock,
+    1502 :: RedstoneTorchBurnsOut,
+    1503 :: EnderEyePlaced,
+    2000 :: Spawns10SmokeParticles,
+    2001 :: BlockBreak,
+    2002 :: SplashPotion,
+    2003 :: EyeOfEnderBreak,
+    2004 :: MobSpawn,
+    2005 :: Bonemeal,
+    2006 :: DragonBreath,
+    2007 :: InstantSplashPotion,
+    2008 :: EnderDragonDestroysBlock,
+    2009 :: WetSpongeVaporizes,
+    3000 :: EndGatewaySpawn,
+    3001 :: EnderDragonGrowl,
+    3002 :: ElectricSpark,
+    3003 :: CopperApplyWax,
+    3004 :: CopperRemoveWax,
+    3005 :: CopperScrapeOxidation
+);
+
+proto_str_enum!(TagType,
+    "minecraft:block" :: Block,
+    "minecraft:item" :: Item,
+    "minecraft:fluid" :: Fluid,
+    "minecraft:entity_type" :: EntityType,
+    "minecraft:game_event" :: GameEvent
+);
+
+proto_struct!(TypedTagList {
+    tag_type: TagType,
+    tags: CountedArray<TagSpec, VarInt>
+});
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub struct BlockChangeHorizontalPosition {
+    pub rel_x: u8,
+    pub rel_z: u8,
+}
+
+impl Serialize for BlockChangeHorizontalPosition {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        to.serialize_byte((self.rel_x & 0xF) << 4 | (self.rel_z & 0xF))
+    }
+}
+
+impl Deserialize for BlockChangeHorizontalPosition {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        Ok(
+            u8::mc_deserialize(data)?.map(move |b| BlockChangeHorizontalPosition {
+                rel_x: (b >> 4) & 0xF,
+                rel_z: b & 0xF,
+            }),
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for BlockChangeHorizontalPosition {
+    fn test_gen_random() -> Self {
+        BlockChangeHorizontalPosition {
+            rel_x: rand::random::<u8>() % 16,
+            rel_z: rand::random::<u8>() % 16,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Copy)]
+pub struct ChunkSectionPosition {
+    pub x: i32,
+    pub y: i32,
+    pub z: i32,
+}
+
+impl Serialize for ChunkSectionPosition {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let num = (((self.x as u64) & 0x3FFFFF) << 42)
+            | (((self.z as u64) & 0x3FFFFF) << 20)
+            | ((self.y as u64) & 0xFFFFF);
+
+        to.serialize_other(&num)
+    }
+}
+
+impl Deserialize for ChunkSectionPosition {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: raw, data } = u64::mc_deserialize(data)?;
+        let y = (raw & 0xFFFFF) as i32;
+        let z = ((raw >> 20) & 0x3FFFFF) as i32;
+        let x = ((raw >> 42) & 0x3FFFFF) as i32;
+        Deserialized::ok(Self { x, y, z }, data)
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for ChunkSectionPosition {
+    fn test_gen_random() -> Self {
+        Self {
+            x: (u32::test_gen_random() & 0x3FFFFF) as i32,
+            y: (u32::test_gen_random() & 0xFFFFF) as i32,
+            z: (u32::test_gen_random() & 0x3FFFFF) as i32,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Copy)]
+pub struct MultiBlockChangeRecord {
+    pub block_id: u64,
+    pub rel_position: Vec3<i8>,
+}
+
+impl Serialize for MultiBlockChangeRecord {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let raw = (self.block_id << 12)
+            | (((self.rel_position.x as u64) & 0xF) << 8)
+            | (((self.rel_position.y as u64) & 0xF) << 4)
+            | ((self.rel_position.z as u64) & 0xF);
+        let raw = VarLong(raw as i64);
+        to.serialize_other(&raw)
+    }
+}
+
+impl Deserialize for MultiBlockChangeRecord {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: raw, data } = VarLong::mc_deserialize(data)?;
+        let raw = raw.0 as u64;
+        let block_id = raw >> 12;
+        let x = ((raw >> 8) & 0xF) as i8;
+        let y = ((raw >> 4) & 0xF) as i8;
+        let z = (raw & 0xF) as i8;
+        let rel_position = (x, y, z).into();
+        Deserialized::ok(
+            Self {
+                block_id,
+                rel_position,
+            },
+            data,
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for MultiBlockChangeRecord {
+    fn test_gen_random() -> Self {
+        let mut rel_position = <Vec3<i8>>::test_gen_random();
+        rel_position.x &= 0xF;
+        rel_position.y &= 0xF;
+        rel_position.z &= 0xF;
+        let block_id = u64::test_gen_random() & ((1 << 52) - 1);
+
+        Self {
+            block_id,
+            rel_position,
+        }
+    }
+}
+
+proto_varint_enum!(BossBarAction,
+    0x00 :: Add(BossBarAddSpec),
+    0x01 :: Remove,
+    0x02 :: UpdateHealth(BossBarUpdateHealthSpec),
+    0x03 :: UpdateTitle(BossBarUpdateTitleSpec),
+    0x04 :: UpdateStyle(BossBarUpdateStyleSpec),
+    0x05 :: UpdateFlags(BossBarUpdateFlagsSpec)
+);
+
+proto_varint_enum!(BossBarColor,
+    0x00 :: Pink,
+    0x01 :: Blue,
+    0x02 :: Red,
+    0x03 :: Green,
+    0x04 :: Yellow,
+    0x05 :: Purple,
+    0x06 :: White
+);
+
+proto_varint_enum!(BossBarDivision,
+    0x00 :: NoDivision,
+    0x01 :: SixNotches,
+    0x02 :: TenNotches,
+    0x03 :: TwelveNotches,
+    0x04 :: TwentyNotches
+);
+
+proto_byte_flag!(BossBarFlags,
+    0x01 :: is_darken_sky set_darken_sky,
+    0x02 :: is_dragon_bar set_dragon_bar,
+    0x04 :: is_create_fog set_create_fog
+);
+
+proto_struct!(BossBarAddSpec {
+    title: Chat,
+    health: f32,
+    color: BossBarColor,
+    division: BossBarDivision,
+    flags: BossBarFlags
+});
+
+proto_struct!(BossBarUpdateHealthSpec { health: f32 });
+
+proto_struct!(BossBarUpdateTitleSpec { title: String });
+
+proto_struct!(BossBarUpdateStyleSpec {
+    color: BossBarColor,
+    dividers: BossBarDivision
+});
+
+proto_struct!(BossBarUpdateFlagsSpec {
+    flags: BossBarFlags
+});
+
+proto_struct!(TabCompleteMatch {
+    match_: String,
+    tooltip: Option<Chat>
+});
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CommandNodeSpec {
+    pub children_indices: CountedArray<VarInt, VarInt>,
+    pub redirect_node: Option<VarInt>,
+    pub is_executable: bool,
+    pub node: CommandNode,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum CommandNode {
+    Root,
+    Argument(CommandArgumentNodeSpec),
+    Literal(CommandLiteralNodeSpec),
+}
+
+impl Serialize for CommandNodeSpec {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let mut flags: u8 = 0;
+
+        use CommandNode::*;
+
+        flags |= match &self.node {
+            Root => 0x00,
+            Literal(_) => 0x01,
+            Argument(_) => 0x02,
+        };
+
+        if self.is_executable {
+            flags |= 0x04;
+        }
+
+        if self.redirect_node.is_some() {
+            flags |= 0x08;
+        }
+
+        if let Argument(body) = &self.node {
+            if body.suggestions_types.is_some() {
+                flags |= 0x10
+            }
+        }
+
+        to.serialize_byte(flags)?;
+        to.serialize_other(&self.children_indices)?;
+        if let Some(redirect_node) = &self.redirect_node {
+            to.serialize_other(redirect_node)?;
+        }
+
+        match &self.node {
+            Root => Ok(()),
+            Argument(body) => body.serialize(to),
+            Literal(body) => to.serialize_other(body),
+        }
+    }
+}
+
+impl Deserialize for CommandNodeSpec {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: flags, data } = u8::mc_deserialize(data)?;
+        let Deserialized {
+            value: children_indices,
+            data,
+        } = <CountedArray<VarInt, VarInt>>::mc_deserialize(data)?;
+        let (redirect_node, data) = if flags & 0x08 != 0 {
+            let Deserialized {
+                value: redirect_node,
+                data,
+            } = VarInt::mc_deserialize(data)?;
+            (Some(redirect_node), data)
+        } else {
+            (None, data)
+        };
+        let is_executable = flags & 0x04 != 0;
+
+        use CommandNode::*;
+        let Deserialized { value: node, data } = match flags & 0x03 {
+            0x00 => Deserialized::ok(Root, data),
+            0x01 => {
+                Ok(CommandLiteralNodeSpec::mc_deserialize(data)?.map(move |body| Literal(body)))
+            }
+            0x02 => Ok(
+                CommandArgumentNodeSpec::deserialize(flags & 0x10 != 0, data)?
+                    .map(move |body| Argument(body)),
+            ),
+            other => panic!("impossible condition (bitmask) {}", other),
+        }?;
+
+        Deserialized::ok(
+            Self {
+                children_indices,
+                redirect_node,
+                is_executable,
+                node,
+            },
+            data,
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for CommandNodeSpec {
+    fn test_gen_random() -> Self {
+        let children_indices = <CountedArray<VarInt, VarInt>>::test_gen_random();
+        let redirect_node = <Option<VarInt>>::test_gen_random();
+        let is_executable = rand::random::<bool>();
+        let idx = rand::random::<usize>() % 3;
+        let node = match idx {
+            0 => CommandNode::Root,
+            1 => CommandNode::Argument(CommandArgumentNodeSpec::test_gen_random()),
+            2 => CommandNode::Literal(CommandLiteralNodeSpec::test_gen_random()),
+            other => panic!("impossible state {}", other),
+        };
+
+        Self {
+            children_indices,
+            redirect_node,
+            is_executable,
+            node,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CommandArgumentNodeSpec {
+    pub name: String,
+    pub parser: CommandParserSpec,
+    pub suggestions_types: Option<SuggestionsTypeSpec>,
+}
+
+impl CommandArgumentNodeSpec {
+    fn serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        to.serialize_other(&self.name)?;
+        to.serialize_other(&self.parser)?;
+        if let Some(suggestions_types) = &self.suggestions_types {
+            to.serialize_other(suggestions_types)?;
+        }
+
+        Ok(())
+    }
+
+    fn deserialize(has_suggestion_types: bool, data: &[u8]) -> DeserializeResult<Self> {
+        let Deserialized { value: name, data } = String::mc_deserialize(data)?;
+        let Deserialized {
+            value: parser,
+            data,
+        } = CommandParserSpec::mc_deserialize(data)?;
+        let (suggestions_types, data) = if has_suggestion_types {
+            let Deserialized {
+                value: suggestions_types,
+                data,
+            } = SuggestionsTypeSpec::mc_deserialize(data)?;
+            (Some(suggestions_types), data)
+        } else {
+            (None, data)
+        };
+
+        Deserialized::ok(
+            Self {
+                name,
+                parser,
+                suggestions_types,
+            },
+            data,
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for CommandArgumentNodeSpec {
+    fn test_gen_random() -> Self {
+        let name = String::test_gen_random();
+        let suggestions_types = <Option<SuggestionsTypeSpec>>::test_gen_random();
+        let parser = CommandParserSpec::test_gen_random();
+
+        Self {
+            name,
+            parser,
+            suggestions_types,
+        }
+    }
+}
+
+proto_str_enum!(SuggestionsTypeSpec,
+    "minecraft:ask_server" :: AskServer,
+    "minecraft:all_recipes" :: AllRecipes,
+    "minecraft:available_sounds" :: AvailableSounds,
+    "minecraft:summonable_entities" :: SummonableEntities,
+    "minecraft:available_biomes" :: AvailableBiomes
+);
+
+proto_struct!(CommandLiteralNodeSpec { name: String });
+
+proto_str_enum!(CommandParserSpec,
+    "brigadier:bool" :: Bool,
+    "brigadier:double" :: Double(DoubleParserProps),
+    "brigadier:float" :: Float(FloatParserProps),
+    "brigadier:integer" :: Integer(IntegerParserProps),
+    "brigadier:string" :: StringParser(StringParserMode),
+    "minecraft:entity" :: Entity(EntityParserFlags),
+    "minecraft:game_profile" :: GameProfile,
+    "minecraft:block_pos" :: BlockPosition,
+    "minecraft:column_pos" :: ColumnPosition,
+    "minecraft:vec3" :: Vec3,
+    "minecraft:vec2" :: Vec2,
+    "minecraft:block_state" :: BlockState,
+    "minecraft:block_predicate" :: BlockPredicate,
+    "minecraft:item_stack" :: ItemStack,
+    "minecraft:item_predicate" :: ItemPredicate,
+    "minecraft:color" :: Color,
+    "minecraft:component" :: Component,
+    "minecraft:message" :: Message,
+    "minecraft:nbt" :: Nbt,
+    "minecraft:nbt_path" :: NbtPath,
+    "minecraft:objective" :: Objective,
+    "minecraft:objective_criteria" :: ObjectiveCriteria,
+    "minecraft:operation" :: Operation,
+    "minecraft:particle" :: Particle,
+    "minecraft:rotation" :: Rotation,
+    "minecraft:angle" :: Angle,
+    "minecraft:scoreboard_slot" :: ScoreboardSlot,
+    "minecraft:score_holder" :: ScoreHolder(ScoreHolderFlags),
+    "minecraft:swizzle" :: Swizzle,
+    "minecraft:team" :: Team,
+    "minecraft:item_slot" :: ItemSlot,
+    "minecraft:resource_location" :: ResourceLocation,
+    "minecraft:mob_effect" :: MobEffect,
+    "minecraft:function" :: Function,
+    "minecraft:entity_anchor" :: EntityAnchor,
+    "minecraft:range" :: Range(RangeParserProps),
+    "minecraft:int_range" :: IntRange,
+    "minecraft:float_range" :: FloatRange,
+    "minecraft:item_enchantment" :: ItemEnchantment,
+    "minecraft:entity_summon" :: EntitySummon,
+    "minecraft:dimension" :: Dimension,
+    "minecraft:uuid" :: UUID,
+    "minecraft:nbt_tag" :: NbtTag,
+    "minecraft:nbt_compound_tag" :: NbtCompoundTag,
+    "minecraft:time" :: Time
+);
+
+pub struct NumParserProps<T> {
+    pub min: Option<T>,
+    pub max: Option<T>,
+}
+
+pub type DoubleParserProps = NumParserProps<f64>;
+
+pub type FloatParserProps = NumParserProps<f32>;
+
+pub type IntegerParserProps = NumParserProps<i32>;
+
+impl<T> Copy for NumParserProps<T> where T: Copy {}
+
+impl<T> Clone for NumParserProps<T>
+where
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            min: self.min.clone(),
+            max: self.max.clone(),
+        }
+    }
+}
+
+impl<T> Debug for NumParserProps<T>
+where
+    T: Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "NumParserProps(min={:?}, max={:?})", self.min, self.max)
+    }
+}
+
+impl<T> PartialEq for NumParserProps<T>
+where
+    T: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        other.max.eq(&self.max) && other.min.eq(&self.min)
+    }
+}
+
+impl<T> Serialize for NumParserProps<T>
+where
+    T: Serialize,
+{
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let mut flags: u8 = 0;
+        if self.min.is_some() {
+            flags |= 0x01;
+        }
+
+        if self.max.is_some() {
+            flags |= 0x02;
+        }
+
+        to.serialize_other(&flags)?;
+        if let Some(min) = &self.min {
+            to.serialize_other(min)?;
+        }
+
+        if let Some(max) = &self.max {
+            to.serialize_other(max)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<T> Deserialize for NumParserProps<T>
+where
+    T: Deserialize,
+{
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: flags, data } = u8::mc_deserialize(data)?;
+        let (min, data) = if flags & 0x01 != 0 {
+            let Deserialized { value: min, data } = T::mc_deserialize(data)?;
+            (Some(min), data)
+        } else {
+            (None, data)
+        };
+
+        let (max, data) = if flags & 0x02 != 0 {
+            let Deserialized { value: max, data } = T::mc_deserialize(data)?;
+            (Some(max), data)
+        } else {
+            (None, data)
+        };
+
+        let out = Self { min, max };
+        Deserialized::ok(out, data)
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl<T> TestRandom for NumParserProps<T>
+where
+    T: TestRandom + std::cmp::PartialOrd,
+    rand::distributions::Standard: rand::distributions::Distribution<T>,
+{
+    fn test_gen_random() -> Self {
+        let has_min = rand::random::<bool>();
+        let has_max = rand::random::<bool>();
+        let (min, max) = if has_min && has_max {
+            let a = rand::random::<T>();
+            let b = rand::random::<T>();
+            if a < b {
+                (Some(a), Some(b))
+            } else {
+                (Some(b), Some(a))
+            }
+        } else if !has_min && !has_max {
+            (None, None)
+        } else {
+            let v = rand::random::<T>();
+            if has_min {
+                (Some(v), None)
+            } else {
+                (None, Some(v))
+            }
+        };
+
+        Self { min, max }
+    }
+}
+
+proto_varint_enum!(StringParserMode,
+    0x00 :: SingleWord,
+    0x01 :: QuotablePharse,
+    0x02 :: GreedyPhrase
+);
+
+proto_byte_flag!(EntityParserFlags,
+    0x01 :: is_single_target set_single_target,
+    0x02 :: is_players_only set_players_only
+);
+
+proto_byte_flag!(ScoreHolderFlags,
+    0x01 :: is_multiple set_multiple
+);
+
+proto_struct!(RangeParserProps { decimal: bool });
+
+proto_byte_enum!(TeamAction,
+    0x00 :: Create(TeamActionCreateSpec),
+    0x01 :: Remove,
+    0x02 :: UpdateInfo(TeamActionUpdateInfoSpec),
+    0x03 :: AddPlayers(TeamActionPlayerList),
+    0x04 :: RemovePlayers(TeamActionPlayerList)
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum TeamMember {
+    Player(String),
+    Entity(UUID4),
+}
+
+impl Serialize for TeamMember {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        use TeamMember::*;
+        match self {
+            Player(username) => username.mc_serialize(to),
+            Entity(entity_id) => entity_id.to_string().mc_serialize(to),
+        }
+    }
+}
+
+impl Deserialize for TeamMember {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        use TeamMember::*;
+
+        Ok(String::mc_deserialize(data)?.map(move |raw| {
+            if let Some(entity_id) = UUID4::parse(raw.as_str()) {
+                Entity(entity_id)
+            } else {
+                Player(raw)
+            }
+        }))
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for TeamMember {
+    fn test_gen_random() -> Self {
+        use TeamMember::*;
+
+        let rand_bool: bool = rand::random();
+        if rand_bool {
+            Player(String::test_gen_random())
+        } else {
+            Entity(UUID4::random())
+        }
+    }
+}
+
+proto_str_enum!(TeamTagNameVisibility,
+    "always" :: Always,
+    "hideForOtherTeams" :: HideForOtherTeams,
+    "hideForOwnTeam" :: HideForOwnTeam,
+    "never" :: Never
+);
+
+proto_str_enum!(TeamCollisionRule,
+    "always" :: Always,
+    "pushForOtherTeams" :: PushForOtherTeams,
+    "pushOwnTeam" :: PushOwnTeam,
+    "never" :: Never
+);
+
+proto_struct!(TeamActionPlayerList {
+    entities: CountedArray<TeamMember, VarInt>
+});
+
+proto_struct!(TeamActionCreateSpec {
+    display_name: Chat,
+    friendly_flags: TeamFriendlyFlags,
+    tag_name_visibility: TeamTagNameVisibility,
+    collision_rule: TeamCollisionRule,
+    color: VarInt,
+    prefix: Chat,
+    suffix: Chat,
+    entities: CountedArray<TeamMember, VarInt>
+});
+
+proto_struct!(TeamActionUpdateInfoSpec {
+    display_name: Chat,
+    friendly_flags: TeamFriendlyFlags,
+    tag_name_visibility: TeamTagNameVisibility,
+    collision_rule: TeamCollisionRule,
+    color: VarInt,
+    prefix: Chat,
+    suffix: Chat
+});
+
+proto_byte_flag!(TeamFriendlyFlags,
+    0x01 :: allow_friendly_fire set_friendly_fire,
+    0x02 :: show_invisible_teammates set_show_invisible_teammates
+);
+
+proto_byte_enum!(UpdateScoreAction,
+    0x00 :: Upsert(VarInt),
+    0x01 :: Remove
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct UpdateScoreSpec {
+    pub objective_name: String,
+    pub action: UpdateScoreAction,
+}
+
+impl Serialize for UpdateScoreSpec {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        to.serialize_byte(self.action.id())?;
+        to.serialize_other(&self.objective_name)?;
+        self.action.serialize_body(to)?;
+
+        Ok(())
+    }
+}
+
+impl Deserialize for UpdateScoreSpec {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized {
+            value: action_id,
+            data,
+        } = u8::mc_deserialize(data)?;
+        let Deserialized {
+            value: objective_name,
+            data,
+        } = String::mc_deserialize(data)?;
+
+        Ok(
+            UpdateScoreAction::deserialize_with_id(action_id, data)?.map(move |action| Self {
+                objective_name,
+                action,
+            }),
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for UpdateScoreSpec {
+    fn test_gen_random() -> Self {
+        Self {
+            objective_name: String::test_gen_random(),
+            action: UpdateScoreAction::test_gen_random(),
+        }
+    }
+}
+
+// proto_varint_enum!(TitleActionSpec,
+//     0x00 :: SetTitle(Chat),
+//     0x01 :: SetSubtitle(Chat),
+//     0x02 :: SetActionBar(Chat),
+//     0x03 :: SetTimesAndDisplay(TitleTimesSpec),
+//     0x04 :: Hide,
+//     0x05 :: Reset
+// );
+
+// proto_struct!(TitleTimesSpec {
+//     fade_in: i32,
+//     stay: i32,
+//     fade_out: i32
+// });
+
+proto_varint_enum!(SoundCategory,
+    0x00 :: Master,
+    0x01 :: Music,
+    0x02 :: Records,
+    0x03 :: Weather,
+    0x04 :: Block,
+    0x05 :: Hostile,
+    0x06 :: Neutral,
+    0x07 :: Player,
+    0x08 :: Ambient,
+    0x09 :: Voice
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct StopSoundSpec {
+    pub source: Option<SoundCategory>,
+    pub sound: Option<String>,
+}
+
+impl Serialize for StopSoundSpec {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let has_sound = self.sound.is_some();
+        let has_source = self.source.is_some();
+        let mut flags = 0;
+        if has_sound {
+            flags |= 0x02;
+        }
+        if has_source {
+            flags |= 0x01;
+        }
+
+        to.serialize_byte(flags)?;
+        if let Some(source) = &self.source {
+            to.serialize_other(source)?;
+        }
+
+        if let Some(sound) = &self.sound {
+            to.serialize_other(sound)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Deserialize for StopSoundSpec {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: flags, data } = u8::mc_deserialize(data)?;
+
+        let is_source_present = flags & 0x01 != 0;
+        let is_sound_present = flags & 0x02 != 0;
+
+        let (source, data) = if is_source_present {
+            let Deserialized {
+                value: source,
+                data,
+            } = SoundCategory::mc_deserialize(data)?;
+            (Some(source), data)
+        } else {
+            (None, data)
+        };
+
+        let (sound, data) = if is_sound_present {
+            let Deserialized { value: sound, data } = String::mc_deserialize(data)?;
+            (Some(sound), data)
+        } else {
+            (None, data)
+        };
+
+        Deserialized::ok(Self { source, sound }, data)
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for StopSoundSpec {
+    fn test_gen_random() -> Self {
+        let source = if rand::random::<bool>() {
+            Some(SoundCategory::test_gen_random())
+        } else {
+            None
+        };
+
+        let sound = if source.is_none() || rand::random::<bool>() {
+            Some(String::test_gen_random())
+        } else {
+            None
+        };
+
+        Self { source, sound }
+    }
+}
+
+proto_byte_enum!(GameMode,
+    0x00 :: Survival,
+    0x01 :: Creative,
+    0x02 :: Adventure,
+    0x03 :: Spectator
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum PreviousGameMode {
+    NoPrevious,
+    Previous(GameMode),
+}
+
+impl PreviousGameMode {
+    pub fn id(&self) -> i8 {
+        use PreviousGameMode::*;
+        match self {
+            NoPrevious => -1,
+            Previous(mode) => mode.id() as i8,
+        }
+    }
+}
+
+impl Serialize for PreviousGameMode {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        to.serialize_byte(self.id() as u8)
+    }
+}
+
+impl Deserialize for PreviousGameMode {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: id, data } = i8::mc_deserialize(data)?;
+
+        use PreviousGameMode::*;
+        match id {
+            -1 => Deserialized::ok(NoPrevious, data),
+            other => {
+                Ok(GameMode::deserialize_with_id(other as u8, data)?.map(move |gm| Previous(gm)))
+            }
+        }
+    }
+}
+
+impl Into<Option<GameMode>> for PreviousGameMode {
+    fn into(self) -> Option<GameMode> {
+        use PreviousGameMode::*;
+        match self {
+            NoPrevious => None,
+            Previous(mode) => Some(mode),
+        }
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for PreviousGameMode {
+    fn test_gen_random() -> Self {
+        use PreviousGameMode::*;
+        match <Option<GameMode> as TestRandom>::test_gen_random() {
+            Some(gamemode) => Previous(gamemode),
+            None => NoPrevious,
+        }
+    }
+}
+
+proto_byte_enum!(WinGameAction,
+    0x00 :: Respawn,
+    0x01 :: RollCreditsAndRespawn
+);
+
+proto_byte_enum!(DemoEvent,
+    0x00 :: ShowWelcomeScreen,
+    0x65 :: TellMovementControls,
+    0x66 :: TellJumpControl,
+    0x67 :: TellInventoryControl,
+    0x68 :: EndDemo
+);
+
+proto_byte_enum!(RespawnRequestType,
+    0x00 :: Screen,
+    0x01 :: Immediate
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum GameChangeReason {
+    NoRespawnAvailable,
+    EndRaining,
+    BeginRaining,
+    ChangeGameMode(GameMode),
+    WinGame(WinGameAction),
+    Demo(DemoEvent),
+    ArrowHitPlayer,
+    RainLevelChange(f32),
+    ThunderLevelChange(f32),
+    PufferfishSting,
+    ElderGuardianMobAppearance,
+    Respawn(RespawnRequestType),
+}
+
+impl Serialize for GameChangeReason {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        use GameChangeReason::*;
+        to.serialize_byte(match self {
+            NoRespawnAvailable => 0x00,
+            EndRaining => 0x01,
+            BeginRaining => 0x02,
+            ChangeGameMode(_) => 0x03,
+            WinGame(_) => 0x04,
+            Demo(_) => 0x05,
+            ArrowHitPlayer => 0x06,
+            RainLevelChange(_) => 0x07,
+            ThunderLevelChange(_) => 0x08,
+            PufferfishSting => 0x09,
+            ElderGuardianMobAppearance => 0x0A,
+            Respawn(_) => 0x0B,
+        })?;
+
+        let value = match self {
+            ChangeGameMode(body) => body.id() as f32,
+            WinGame(body) => body.id() as f32,
+            Demo(body) => body.id() as f32,
+            RainLevelChange(body) => *body,
+            ThunderLevelChange(body) => *body,
+            Respawn(body) => body.id() as f32,
+            _ => 0 as f32,
+        };
+        to.serialize_other(&value)
+    }
+}
+
+impl Deserialize for GameChangeReason {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized {
+            value: reason_id,
+            data,
+        } = u8::mc_deserialize(data)?;
+        let Deserialized { value, data } = f32::mc_deserialize(data)?;
+        use GameChangeReason::*;
+        match reason_id {
+            0x00 => Deserialized::ok(NoRespawnAvailable, data),
+            0x01 => Deserialized::ok(EndRaining, data),
+            0x02 => Deserialized::ok(BeginRaining, data),
+            0x03 => Ok(GameMode::deserialize_with_id(value as u8, data)?
+                .map(move |mode| ChangeGameMode(mode))),
+            0x04 => Ok(WinGameAction::deserialize_with_id(value as u8, data)?
+                .map(move |mode| WinGame(mode))),
+            0x05 => {
+                Ok(DemoEvent::deserialize_with_id(value as u8, data)?.map(move |mode| Demo(mode)))
+            }
+            0x06 => Deserialized::ok(ArrowHitPlayer, data),
+            0x07 => Deserialized::ok(RainLevelChange(value), data),
+            0x08 => Deserialized::ok(ThunderLevelChange(value), data),
+            0x09 => Deserialized::ok(PufferfishSting, data),
+            0x0A => Deserialized::ok(ElderGuardianMobAppearance, data),
+            0x0B => Ok(RespawnRequestType::deserialize_with_id(value as u8, data)?
+                .map(move |mode| Respawn(mode))),
+            other => Err(DeserializeErr::CannotUnderstandValue(alloc::format!(
+                "invalid game change reason id {}",
+                other
+            ))),
+        }
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for GameChangeReason {
+    fn test_gen_random() -> Self {
+        // todo
+        GameChangeReason::PufferfishSting
+    }
+}
+
+proto_varint_enum!(MapIconType,
+    0x00 :: WhiteArrow,
+    0x01 :: GreenArrow,
+    0x02 :: RedArrow,
+    0x03 :: BlueArrow,
+    0x04 :: WhiteCross,
+    0x05 :: RedPointer,
+    0x06 :: WhiteCircle,
+    0x07 :: SmallWhiteCircle,
+    0x08 :: Mansion,
+    0x09 :: Temple,
+    0x0A :: WhiteBanner,
+    0x0B :: OrangeBanner,
+    0x0C :: MagentaBanner,
+    0x0D :: LightBlueBanner,
+    0x0E :: YellowBanner,
+    0x0F :: LimeBanner,
+    0x10 :: PinkBanner,
+    0x11 :: GrayBanner,
+    0x12 :: LightGrayBanner,
+    0x13 :: CyanBanner,
+    0x14 :: PurpleBanner,
+    0x15 :: BlueBanner,
+    0x16 :: BrownBanner,
+    0x17 :: GreenBanner,
+    0x18 :: RedBanner,
+    0x19 :: BlackBanner,
+    0x1A :: TreasureMarker
+);
+
+proto_struct!(MapIconSpec {
+    kind: MapIconType,
+    position: TopDownPosition<i8>,
+    direction: i8,
+    display_name: Option<Chat>
+});
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum MapColumns {
+    NoUpdates,
+    Updated(MapColumnsSpec),
+}
+
+proto_struct!(MapColumnsSpec {
+    columns: u8,
+    rows: u8, // TODO: docs just say "Byte", should be i8?
+    position: TopDownPosition<u8>,
+    data: CountedArray<u8, VarInt>
+});
+
+impl Serialize for MapColumns {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        use MapColumns::*;
+        match self {
+            NoUpdates => to.serialize_other(&0u8),
+            Updated(body) => to.serialize_other(body),
+        }
+    }
+}
+
+impl Deserialize for MapColumns {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized {
+            value: columns,
+            data: rest,
+        } = u8::mc_deserialize(data)?;
+        use MapColumns::*;
+        match columns {
+            0x00 => Deserialized::ok(NoUpdates, rest),
+            _ => Ok(MapColumnsSpec::mc_deserialize(data)?.map(move |v| Updated(v))),
+        }
+    }
+}
+
+impl Into<Option<MapColumnsSpec>> for MapColumns {
+    fn into(self) -> Option<MapColumnsSpec> {
+        use MapColumns::*;
+        match self {
+            NoUpdates => None,
+            Updated(body) => Some(body),
+        }
+    }
+}
+
+impl From<Option<MapColumnsSpec>> for MapColumns {
+    fn from(other: Option<MapColumnsSpec>) -> Self {
+        use MapColumns::*;
+        match other {
+            Some(body) => {
+                if body.columns == 0 {
+                    NoUpdates
+                } else {
+                    Updated(body)
+                }
+            }
+            None => NoUpdates,
+        }
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for MapColumns {
+    fn test_gen_random() -> Self {
+        <Option<MapColumnsSpec>>::test_gen_random().into()
+    }
+}
+
+proto_struct!(TradeSpec {
+    input_item_1: Slot,
+    output_item: Slot,
+    input_item_2: Slot,
+    trade_disabled: bool,
+    trade_uses: i32,
+    max_trade_uses: i32,
+    xp: i32,
+    special_price: i32,
+    price_multiplier: f32,
+    demand: i32
+});
+
+proto_varint_enum!(Hand,
+    0x00 :: MainHand,
+    0x01 :: OffHand
+);
+
+proto_varint_enum!(WindowType, // TODO: does 0x00 actually map to GenericOneRow?
+    0x00 :: GenericOneRow,
+    0x01 :: GenericTwoRow,
+    0x02 :: GenericThreeRow,
+    0x03 :: GenericFourRow,
+    0x04 :: GenericFiveRow,
+    0x05 :: GenericSixRow,
+    0x06 :: GenericSquare,
+    0x07 :: Anvil,
+    0x08 :: Beacon,
+    0x09 :: BlastFurnace,
+    0x0A :: BrewingStand,
+    0x0B :: CraftingTable,
+    0x0C :: EnchantmentTable,
+    0x0D :: Furnace,
+    0x0E :: Grindstone,
+    0x0F :: Hopper,
+    0x10 :: Lectern,
+    0x11 :: Loom,
+    0x12 :: Merchant,
+    0x13 :: ShulkerBox,
+    0x14 :: Smoker,
+    0x15 :: Cartography,
+    0x16 :: StoneCutter
+);
+
+proto_byte_flag!(PlayerAbilityFlags,
+    0x01 :: is_invulnerable set_invulnerable,
+    0x02 :: is_flying set_flying,
+    0x04 :: is_flight_allowed set_flight_allowed,
+    0x08 :: is_instant_break set_instant_break
+);
+
+// proto_varint_enum!(CombatEvent,
+//     0x00 :: Enter,
+//     0x01 :: End(CombatEndSpec),
+//     0x02 :: EntityDead(CombatEntityDeadSpec)
+// );
+
+// proto_struct!(CombatEndSpec {
+//     duration_ticks: VarInt,
+//     entity_id: i32
+// });
+
+// proto_struct!(CombatEntityDeadSpec {
+//     player_id: VarInt,
+//     entity_id: i32,
+//     message: Chat
+// });
+
+proto_struct!(PlayerInfoAction<A> {
+    uuid: UUID4,
+    action: A
+});
+
+proto_varint_enum!(PlayerInfoActionList,
+    0x00 :: Add(CountedArray<PlayerInfoAction<PlayerAddActionSpec>, VarInt>),
+    0x01 :: UpdateGameMode(CountedArray<PlayerInfoAction<GameMode>, VarInt>),
+    0x02 :: UpdateLatency(CountedArray<PlayerInfoAction<VarInt>, VarInt>),
+    0x03 :: UpdateDisplayName(CountedArray<PlayerInfoAction<Option<Chat>>, VarInt>),
+    0x04 :: Remove(CountedArray<UUID4, VarInt>)
+);
+
+proto_struct!(PlayerAddActionSpec {
+    name: String,
+    properties: CountedArray<PlayerAddProperty, VarInt>,
+    game_mode: GameMode,
+    ping_ms: VarInt,
+    display_name: Option<Chat>
+});
+
+proto_struct!(PlayerAddProperty {
+    name: String,
+    value: String,
+    signature: Option<String>
+});
+
+proto_varint_enum!(FacePlayerKind,
+    0x00 :: Feet,
+    0x01 :: Eyes
+);
+
+proto_struct!(FacePlayerEntityTarget {
+    entity_id: VarInt,
+    kind: FacePlayerKind
+});
+
+proto_byte_flag!(PositionAndLookFlags,
+    0x01 :: is_x_rel set_x_rel,
+    0x02 :: is_y_rel set_y_rel,
+    0x04 :: is_z_rel set_z_rel,
+    0x08 :: is_y_rotation_rel set_y_rotation_rel,
+    0x10 :: is_x_rotation_rel set_x_rotation_rel
+);
+
+proto_byte_enum!(EntityEffectKind,
+    0x01 :: Speed,
+    0x02 :: Slowness,
+    0x03 :: Haste,
+    0x04 :: MiningFatigue,
+    0x05 :: Strength,
+    0x06 :: InstantHealth,
+    0x07 :: InstantDamage,
+    0x08 :: JumpBoost,
+    0x09 :: Nausea,
+    0x0A :: Regeneration,
+    0x0B :: Resistance,
+    0x0C :: FireResistance,
+    0x0D :: WaterBreathing,
+    0x0E :: Invisibility,
+    0x0F :: Blindness,
+    0x10 :: NightVision,
+    0x11 :: Hunger,
+    0x12 :: Weakness,
+    0x13 :: Poison,
+    0x14 :: Wither,
+    0x15 :: HealthBoost,
+    0x16 :: Absorption,
+    0x17 :: Saturation,
+    0x18 :: Glowing,
+    0x19 :: Levetation,
+    0x1A :: Luck,
+    0x1B :: Unluck,
+    0x1C :: SlowFalling,
+    0x1D :: ConduitPower,
+    0x1E :: DolphinsGrace,
+    0x1F :: BadOmen,
+    0x20 :: HeroOfTheVillage
+);
+
+// proto_varint_enum!(WorldBorderAction,
+//     0x00 :: SetSize(WorldBorderSetSizeSpec),
+//     0x01 :: LerpSize(WorldBorderLerpSizeSpec),
+//     0x02 :: SetCenter(TopDownPosition<f64>),
+//     0x03 :: Initialize(WorldBorderInitiaializeSpec),
+//     0x04 :: SetWarningTime(WorldBorderWarningTimeSpec),
+//     0x05 :: SetWarningBlocks(WorldBorderWarningBlocksSpec)
+// );
+
+// proto_struct!(WorldBorderSetSizeSpec {
+//     diameter: f64
+// });
+
+// proto_struct!(WorldBorderLerpSizeSpec {
+//     old_diameter: f64,
+//     new_diameter: f64,
+//     speed: VarLong
+// });
+
+// proto_struct!(WorldBorderInitializeSpec {
+//     position: TopDownPosition<f64>,
+//     old_diameter: f64,
+//     new_diameter: f64,
+//     speed: VarLong,
+//     portal_teleport_boundary: VarLong,
+//     warning_time: VarInt,
+//     warning_blocks: VarInt
+// });
+
+// proto_struct!(WorldBorderWarningTimeSpec {
+//     warning_time: VarInt
+// });
+
+// proto_struct!(WorldBorderWarningBlocksSpec {
+//     warning_blocks: VarInt
+// });
+
+proto_byte_enum!(ScoreboardPosition,
+    0x00 :: List,
+    0x01 :: Sidebar,
+    0x02 :: BelowName,
+    0x03 :: TeamSpecific(i8)
+);
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EntityEquipmentEntry {
+    pub slot: EquipmentSlot,
+    pub item: Slot,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EntityEquipmentArray {
+    data: Vec<EntityEquipmentEntry>,
+}
+
+impl Serialize for EntityEquipmentArray {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        if self.data.is_empty() {
+            return Err(SerializeErr::CannotSerialize(
+                "entity equipment must be non-empty to send!".to_owned(),
+            ));
+        }
+
+        let n = self.data.len();
+
+        for i in 0..n {
+            let is_last = i == n - 1;
+            let entry = self.data.get(i).expect("iter in bounds");
+            let mut slot_raw = entry.slot.id();
+            if !is_last {
+                slot_raw |= 0x80;
+            }
+            to.serialize_byte(slot_raw)?;
+            to.serialize_other(&entry.item)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Deserialize for EntityEquipmentArray {
+    fn mc_deserialize(mut data: &[u8]) -> DeserializeResult<'_, Self> {
+        if data.is_empty() {
+            return DeserializeErr::Eof.into();
+        }
+
+        let mut out = Vec::new();
+        let mut has_next = true;
+        while has_next {
+            let Deserialized {
+                value: raw_slot_id,
+                data: rest,
+            } = u8::mc_deserialize(data)?;
+            has_next = raw_slot_id & 0x80 != 0;
+            let slot_id = raw_slot_id & 0x7F;
+            let Deserialized {
+                value: slot,
+                data: rest,
+            } = EquipmentSlot::deserialize_with_id(slot_id, rest)?;
+            let Deserialized {
+                value: item,
+                data: rest,
+            } = Slot::mc_deserialize(rest)?;
+            out.push(EntityEquipmentEntry { slot, item });
+            data = rest;
+        }
+
+        Deserialized::ok(Self { data: out }, data)
+    }
+}
+
+impl core::ops::Deref for EntityEquipmentArray {
+    type Target = Vec<EntityEquipmentEntry>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl core::ops::DerefMut for EntityEquipmentArray {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl From<Vec<EntityEquipmentEntry>> for EntityEquipmentArray {
+    fn from(data: Vec<EntityEquipmentEntry>) -> Self {
+        Self { data }
+    }
+}
+
+impl From<EntityEquipmentArray> for Vec<EntityEquipmentEntry> {
+    fn from(other: EntityEquipmentArray) -> Self {
+        other.data
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for EntityEquipmentArray {
+    fn test_gen_random() -> Self {
+        let mut out = Vec::new();
+
+        for slot in &[
+            EquipmentSlot::MainHand,
+            EquipmentSlot::OffHand,
+            EquipmentSlot::ArmorBoots,
+            EquipmentSlot::ArmorLeggings,
+            EquipmentSlot::ArmorChestplate,
+            EquipmentSlot::ArmorHelmet,
+        ] {
+            out.push(EntityEquipmentEntry {
+                slot: slot.clone(),
+                item: Slot::test_gen_random(),
+            });
+        }
+
+        out.into()
+    }
+}
+
+proto_byte_enum!(EquipmentSlot,
+    0x00 :: MainHand,
+    0x01 :: OffHand,
+    0x02 :: ArmorBoots,
+    0x03 :: ArmorLeggings,
+    0x04 :: ArmorChestplate,
+    0x05 :: ArmorHelmet
+);
+
+proto_byte_enum!(ScoreboardObjectiveAction,
+    0x00 :: Create(ScoreboardObjectiveSpec),
+    0x01 :: Remove,
+    0x02 :: UpdateText(ScoreboardObjectiveSpec)
+);
+
+proto_varint_enum!(ScoreboardObjectiveKind,
+    0x00 :: Integer,
+    0x01 :: Hearts
+);
+
+proto_struct!(ScoreboardObjectiveSpec {
+    text: Chat,
+    kind: ScoreboardObjectiveKind
+});
+
+proto_struct!(AdvancementMappingEntrySpec {
+    key: String,
+    value: AdvancementSpec
+});
+
+proto_struct!(AdvancementSpec {
+    parent: Option<String>,
+    display: Option<AdvancementDisplaySpec>,
+    criteria: CountedArray<String, VarInt>,
+    requirements: CountedArray<CountedArray<String, VarInt>, VarInt>
+});
+
+proto_struct!(AdvancementDisplaySpec {
+    title: Chat,
+    description: Chat,
+    icon: Slot,
+    frame_type: AdvancementFrameType,
+    flags: AdvancementDisplayFlags,
+    position: Vec2<f32>
+});
+
+proto_struct!(SlotAtSpec {
+    number: i16,
+    data: Slot
+});
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct AdvancementDisplayFlags {
+    pub background_texture: Option<String>,
+    pub show_toast: bool,
+    pub hidden: bool,
+}
+
+impl Serialize for AdvancementDisplayFlags {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let mut raw_flags: i32 = 0;
+        if self.background_texture.is_some() {
+            raw_flags |= 0x01;
+        }
+        if self.show_toast {
+            raw_flags |= 0x02;
+        }
+        if self.hidden {
+            raw_flags |= 0x04;
+        }
+
+        to.serialize_other(&raw_flags)?;
+        if let Some(texture) = &self.background_texture {
+            to.serialize_other(texture)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Deserialize for AdvancementDisplayFlags {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized {
+            value: raw_flags,
+            data,
+        } = i32::mc_deserialize(data)?;
+        let has_background_texture = raw_flags & 0x01 != 0;
+        let show_toast = raw_flags & 0x02 != 0;
+        let hidden = raw_flags & 0x04 != 0;
+
+        Ok(if has_background_texture {
+            String::mc_deserialize(data)?.map(move |id| Some(id))
+        } else {
+            Deserialized { value: None, data }
+        }
+        .map(move |background_texture| Self {
+            background_texture,
+            show_toast,
+            hidden,
+        }))
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for AdvancementDisplayFlags {
+    fn test_gen_random() -> Self {
+        let background_texture = if rand::random::<bool>() {
+            Some(String::test_gen_random())
+        } else {
+            None
+        };
+        let show_toast = rand::random::<bool>();
+        let hidden = rand::random::<bool>();
+
+        Self {
+            background_texture,
+            show_toast,
+            hidden,
+        }
+    }
+}
+
+proto_varint_enum!(AdvancementFrameType,
+    0x00 :: Task,
+    0x01 :: Challenge,
+    0x02 :: Goal
+);
+
+proto_struct!(AdvancementProgressEntrySpec {
+    key: String,
+    value: AdvancementProgressSpec
+});
+
+proto_struct!(AdvancementProgressSpec {
+    criteria: CountedArray<AdvancementCriteriaSpec, VarInt>
+});
+
+proto_struct!(AdvancementCriteriaSpec {
+    identifier: String,
+    progress: AdvancementCriterionProgressSpec
+});
+
+proto_struct!(AdvancementCriterionProgressSpec {
+    achieved_at: Option<i64>
+});
+
+proto_struct!(EntityPropertySpec {
+    key: String,
+    value: f64,
+    modifiers: CountedArray<EntityPropertyModifierSpec, VarInt>
+});
+
+proto_struct!(EntityPropertyModifierSpec {
+    uuid: UUID4,
+    amount: f64,
+    operation: EntityPropertyModifierOperation
+});
+
+proto_byte_enum!(EntityPropertyModifierOperation,
+    0x00 :: AddSubtractAmount,
+    0x01 :: AddSubtractAmountPercentOfCurrent,
+    0x02 :: MultiplyByAmountPercent
+);
+
+proto_byte_flag!(EntityEffectFlags,
+    0x01 :: is_ambient set_ambient,
+    0x02 :: is_show_particles set_show_particles,
+    0x04 :: is_show_icon set_show_icon
+);
+
+proto_struct!(TagSpec {
+    name: String,
+    entries: CountedArray<VarInt, VarInt>
+});
+
+proto_varint_enum!(ClientStatusAction,
+    0x00 :: PerformRespawn,
+    0x01 :: RequestStats
+);
+
+proto_varint_enum!(ClientChatMode,
+    0x00 :: Enabled,
+    0x01 :: CommandsOnly,
+    0x02 :: Hidden
+);
+
+proto_varint_enum!(ClientMainHand,
+    0x00 :: Left,
+    0x01 :: Right
+);
+
+proto_byte_flag!(ClientDisplayedSkinParts,
+    0x01 :: is_cape_enabled set_cape_enabled,
+    0x02 :: is_jacket_enabled set_jacket_enabled,
+    0x04 :: is_left_sleeve_enabled set_left_sleeve_enabled,
+    0x08 :: is_right_sleeve_enabled set_right_sleeve_enabled,
+    0x10 :: is_left_pants_leg_enabled set_left_pants_leg_enabled,
+    0x20 :: is_right_pant_legs_enabled set_right_pant_legs_enabled,
+    0x40 :: is_hat_enabled set_hat_enabled
+);
+
+proto_varint_enum!(InventoryOperationMode,
+    0x00 :: MouseClick,
+    0x01 :: ShiftClick,
+    0x02 :: NumberClick,
+    0x03 :: MiddleClick,
+    0x04 :: DropClick,
+    0x05 :: Drag,
+    0x06 :: DoubleClick
+);
+
+proto_struct!(InteractAtSpec {
+    target_position: Vec3<f32>,
+    hand: Hand
+});
+
+proto_varint_enum!(InteractKind,
+    0x00 :: Interact(Hand),
+    0x01 :: Attack,
+    0x02 :: InteractAt(InteractAtSpec)
+);
+
+proto_byte_flag!(ClientPlayerAbilities,
+    0x01 :: is_creative set_creative,
+    0x02 :: is_flying set_flying,
+    0x04 :: is_fly_enabled set_fly_enabled,
+    0x08 :: is_damaged_disabled set_damaged_disabled
+);
+
+proto_varint_enum!(PlayerDiggingStatus,
+    0x00 :: Started,
+    0x01 :: Cancelled,
+    0x02 :: Finished,
+    0x03 :: DropStack,
+    0x04 :: DropItem,
+    0x05 :: ShootArrowOrFishEating,
+    0x06 :: SwapItemInHand
+);
+
+proto_byte_enum!(DiggingFace,
+    0x00 :: Bottom,
+    0x01 :: Top,
+    0x02 :: North,
+    0x03 :: South,
+    0x04 :: West,
+    0x05 :: East
+);
+
+proto_varint_enum!(EntityActionKind,
+    0x00 :: StartSneaking,
+    0x01 :: StopSneaking,
+    0x02 :: LeaveBed,
+    0x03 :: StartSprinting,
+    0x04 :: StopSprinting,
+    0x05 :: StartJumpWithHorse,
+    0x06 :: StopJumpWithHorse,
+    0x07 :: OpenHorseInventory,
+    0x08 :: StartFlyingWithElytra
+);
+
+proto_byte_flag!(SteerVehicleFlags,
+    0x01 :: is_jump set_jump,
+    0x02 :: is_unmount set_unmount
+);
+
+proto_varint_enum!(RecipeBookType,
+    0x00 :: Crafting,
+    0x01 :: Furnace,
+    0x02 :: BlastFurnace,
+    0x03 :: Smoker
+);
+
+proto_varint_enum!(ResourcePackStatus,
+    0x00 :: Loaded,
+    0x01 :: Declined,
+    0x02 :: FailedDownload,
+    0x03 :: Accepted
+);
+
+proto_varint_enum!(AdvancementTabAction,
+    0x00 :: Opened(String),
+    0x01 :: Closed
+);
+
+proto_varint_enum!(CommandBlockMode,
+    0x00 :: Sequence,
+    0x01 :: Auto,
+    0x02 :: Redstone
+);
+
+proto_byte_flag!(CommandBlockFlags,
+    0x01 :: is_track_output set_track_output,
+    0x02 :: is_conditional set_conditional,
+    0x04 :: is_automatic set_automatic
+);
+
+proto_varint_enum!(UpdateStructureBlockAction,
+    0x00 :: UpdateData,
+    0x01 :: SaveStructure,
+    0x02 :: LoadStructure,
+    0x03 :: DetectSize
+);
+
+proto_varint_enum!(UpdateStructureBlockMode,
+    0x00 :: Save,
+    0x01 :: Load,
+    0x02 :: Corner,
+    0x03 :: Data
+);
+
+proto_varint_enum!(UpdateStructureBlockMirror,
+    0x00 :: NoMirror,
+    0x01 :: LeftRight,
+    0x02 :: FrontBack
+);
+
+proto_varint_enum!(UpdateStructureBlockRotation,
+    0x00 :: NoRotation,
+    0x01 :: Clockwise90,
+    0x02 :: Clockwise180,
+    0x03 :: CounterClockwise90
+);
+
+proto_byte_flag!(UpdateStructureBlockFlags,
+    0x01 :: is_ignore_entities set_ignore_entities,
+    0x02 :: is_show_air set_show_air,
+    0x04 :: is_show_bounding_box set_show_bounding_box
+);
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct RecipeSpec {
+    pub recipe: Recipe,
+    pub id: String,
+}
+
+proto_str_enum!(Recipe,
+    "minecraft:crafting_shapeless" :: CraftingShapeless(RecipeCraftingShapelessSpec),
+    "minecraft:crafting_shaped" :: CraftingShaped(RecipeCraftingShapedSpec),
+    "minecraft:crafting_special_armordye" :: CraftingArmorDye,
+    "minecraft:crafting_special_bookcloning" :: CraftingBookCloning,
+    "minecraft:crafting_special_mapcloning" :: CraftingMapCloning,
+    "minecraft:crafting_special_mapextending" :: CraftingMapExtending,
+    "minecraft:crafting_special_firework_rocket" :: CraftingFireworkRocket,
+    "minecraft:crafting_special_firework_star" :: CraftingFireworkStar,
+    "minecraft:crafting_special_firework_star_fade" :: CraftingFireworkStarFade,
+    "minecraft:crafting_special_repairitem" :: CraftingRepairItem,
+    "minecraft:crafting_special_tippedarrow" :: CraftingTippedArrow,
+    "minecraft:crafting_special_bannerduplicate" :: CraftingBannerDuplicate,
+    "minecraft:crafting_special_banneraddpattern" :: CraftingBannerAddPattern,
+    "minecraft:crafting_special_shielddecoration" :: CraftingShieldDecoration,
+    "minecraft:crafting_special_shulkerboxcoloring" :: CraftingShulkerBoxColoring,
+    "minecraft:crafting_special_suspiciousstew" :: CraftingSuspiciousStew,
+    "minecraft:smelting" :: Smelting(RecipeSmeltingSpec),
+    "minecraft:blasting" :: Blasting(RecipeSmeltingSpec),
+    "minecraft:smoking" :: Smoking(RecipeSmeltingSpec),
+    "minecraft:campfire_cooking" :: CampfireCooking(RecipeSmeltingSpec),
+    "minecraft:stonecutting" :: StoneCutting(RecipeStonecuttingSpec),
+    "minecraft:smithing" :: Smithing(RecipeSmithingSpec)
+);
+
+impl Serialize for RecipeSpec {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        let _type = self.recipe.id();
+        to.serialize_other(&_type)?;
+        to.serialize_other(&self.id)?;
+        self.recipe.serialize_body(to)
+    }
+}
+
+impl Deserialize for RecipeSpec {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: _type, data } = String::mc_deserialize(data)?;
+        let Deserialized {
+            value: recipe_id,
+            data,
+        } = String::mc_deserialize(data)?;
+
+        Ok(
+            Recipe::deserialize_with_id(_type.as_str(), data)?.map(move |recipe| RecipeSpec {
+                id: recipe_id,
+                recipe,
+            }),
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for RecipeSpec {
+    fn test_gen_random() -> Self {
+        RecipeSpec {
+            recipe: Recipe::test_gen_random(),
+            id: String::test_gen_random(),
+        }
+    }
+}
+
+proto_struct!(RecipeIngredient {
+    items: CountedArray<Slot, VarInt>
+});
+
+proto_struct!(RecipeCraftingShapelessSpec {
+    group: String,
+    ingredients: CountedArray<RecipeIngredient, VarInt>,
+    result: Slot
+});
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct RecipeCraftingShapedSpec {
+    pub width: VarInt,
+    pub height: VarInt,
+    pub group: String,
+    pub ingredients: Vec<RecipeIngredient>,
+    pub result: Slot,
+}
+
+impl Serialize for RecipeCraftingShapedSpec {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        to.serialize_other(&self.width)?;
+        to.serialize_other(&self.height)?;
+        to.serialize_other(&self.group)?;
+        for elem in &self.ingredients {
+            to.serialize_other(elem)?;
+        }
+        to.serialize_other(&self.result)?;
+        Ok(())
+    }
+}
+
+impl Deserialize for RecipeCraftingShapedSpec {
+    fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+        let Deserialized { value: width, data } = <VarInt>::mc_deserialize(data)?;
+        let Deserialized {
+            value: height,
+            data,
+        } = <VarInt>::mc_deserialize(data)?;
+        let Deserialized {
+            value: group,
+            mut data,
+        } = <String>::mc_deserialize(data)?;
+
+        let ingredients_count = width.0 as usize * height.0 as usize;
+        let mut ingredients: Vec<RecipeIngredient> = Vec::with_capacity(ingredients_count);
+        for _ in 0..ingredients_count {
+            let Deserialized {
+                value: elem,
+                data: rest,
+            } = RecipeIngredient::mc_deserialize(data)?;
+            data = rest;
+            ingredients.push(elem);
+        }
+
+        let Deserialized {
+            value: result,
+            data,
+        } = Slot::mc_deserialize(data)?;
+
+        Deserialized::ok(
+            Self {
+                width,
+                height,
+                group,
+                ingredients,
+                result,
+            },
+            data,
+        )
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for RecipeCraftingShapedSpec {
+    fn test_gen_random() -> Self {
+        use rand::distributions::Distribution;
+        let size_distr = rand::distributions::Uniform::new(1, 9);
+        let mut rng = rand::thread_rng();
+
+        let width: VarInt = size_distr.sample(&mut rng).into();
+        let height: VarInt = size_distr.sample(&mut rng).into();
+        let n_ingredients = (width.0 as usize) * (height.0 as usize);
+        let mut ingredients = Vec::with_capacity(n_ingredients);
+        for _ in 0..n_ingredients {
+            ingredients.push(RecipeIngredient::test_gen_random());
+        }
+
+        RecipeCraftingShapedSpec {
+            width,
+            height,
+            group: String::test_gen_random(),
+            ingredients,
+            result: Some(ItemStack::test_gen_random()),
+        }
+    }
+}
+
+proto_struct!(RecipeSmeltingSpec {
+    group: String,
+    ingredient: RecipeIngredient,
+    result: Slot,
+    experience: f32,
+    cooking_time: VarInt
+});
+
+proto_struct!(RecipeStonecuttingSpec {
+    group: String,
+    ingredient: RecipeIngredient,
+    result: Slot
+});
+
+proto_struct!(RecipeSmithingSpec {
+    base: RecipeIngredient,
+    addition: RecipeIngredient,
+    result: Slot
+});
+
+proto_varint_enum!(RecipeUnlockAction,
+    0x00 :: Init,
+    0x01 :: Add,
+    0x02 :: Remove
+);
+
+// #[derive(Clone, PartialEq, Debug)]
+// pub struct ChunkData {
+//     pub position: ChunkPosition<i32>,
+//     pub primary_bit_mask: VarInt,
+//     pub heightmaps: NamedNbtTag,
+//     pub biomes: Option<CountedArray<VarInt, VarInt>>,
+//     pub data: CountedArray<u8, VarInt>,
+//     pub block_entities: Vec<NamedNbtTag>,
+// }
+
+// impl Serialize for ChunkData {
+//     fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+//         to.serialize_other(&self.position)?;
+//         let full_chunk = self.biomes.is_some();
+//         to.serialize_other(&full_chunk)?;
+//         to.serialize_other(&self.primary_bit_mask)?;
+//         to.serialize_other(&self.heightmaps)?;
+
+//         if full_chunk {
+//             to.serialize_other(self.biomes.as_ref().unwrap())?;
+//         }
+
+//         to.serialize_other(&self.data)?;
+//         let num_block_entities = VarInt(self.block_entities.len() as i32);
+//         to.serialize_other(&num_block_entities)?;
+//         for entity in &self.block_entities {
+//             to.serialize_other(entity)?;
+//         }
+
+//         Ok(())
+//     }
+// }
+
+// impl Deserialize for ChunkData {
+//     fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+//         let Deserialized { value: position, data } = <ChunkPosition<i32>>::mc_deserialize(data)?;
+//         let Deserialized { value: is_full_chunk, data } = bool::mc_deserialize(data)?;
+//         let Deserialized { value: primary_bit_mask, data } = VarInt::mc_deserialize(data)?;
+//         let Deserialized { value: heightmaps, mut data } = NamedNbtTag::mc_deserialize(data)?;
+//         let biomes = if is_full_chunk {
+//             let Deserialized { value: biomes, data: rest } = <CountedArray<VarInt, VarInt>>::mc_deserialize(data)?;
+//             data = rest;
+//             Some(biomes)
+//         } else {
+//             None
+//         };
+//         let Deserialized { value: chunk_data, data } = <CountedArray<u8, VarInt>>::mc_deserialize(data)?;
+//         let Deserialized { value: n_block_entities_raw, mut data } = VarInt::mc_deserialize(data)?;
+//         let n_block_entities = n_block_entities_raw.0 as usize;
+//         let mut block_entities = Vec::with_capacity(n_block_entities);
+//         for _ in 0..n_block_entities {
+//             let Deserialized { value: entity, data: rest } = NamedNbtTag::mc_deserialize(data)?;
+//             data = rest;
+//             block_entities.push(entity);
+//         }
+
+//         Deserialized::ok(ChunkData {
+//             position,
+//             primary_bit_mask,
+//             heightmaps,
+//             biomes,
+//             data: chunk_data,
+//             block_entities,
+//         }, data)
+//     }
+// // }
+
+// #[cfg(all(test, feature = "std"))]
+// impl TestRandom for ChunkData {
+//     fn test_gen_random() -> Self {
+//         ChunkData {
+//             position: <ChunkPosition<i32>>::test_gen_random(),
+//             primary_bit_mask: VarInt::test_gen_random(),
+//             heightmaps: NamedNbtTag::test_gen_random(),
+//             biomes: None,
+//             data: <CountedArray<u8, VarInt>>::test_gen_random(),
+//             block_entities: vec![],
+//         }
+//     }
+// }
+
+// pub const LIGHT_DATA_LENGTH: usize = 2048;
+// pub const LIGHT_DATA_SECTIONS: usize = 18;
+
+// #[derive(Clone, PartialEq)]
+// pub struct LightingData {
+//     pub data: Box<[Option<[u8; LIGHT_DATA_LENGTH]>; LIGHT_DATA_SECTIONS]>,
+// }
+
+// impl LightingData {
+//     fn deserialize(update_mask: VarInt, mut data: &[u8]) -> DeserializeResult<Self> {
+//         let mut out = Box::new([None; LIGHT_DATA_SECTIONS]);
+//         for i in 0..LIGHT_DATA_SECTIONS {
+//             // gotta read the var int
+//             if update_mask.0 & (1 << i) != 0 {
+//                 let Deserialized { value: length, data: rest } = VarInt::mc_deserialize(data)?;
+//                 if (length.0 as usize) != LIGHT_DATA_LENGTH {
+//                     return Err(DeserializeErr::CannotUnderstandValue(alloc::format!("bad data length in light update {}", length)));
+//                 }
+
+//                 data = rest;
+//                 if data.len() < LIGHT_DATA_LENGTH {
+//                     return Err(DeserializeErr::Eof);
+//                 }
+
+//                 let (section, rest) = data.split_at(LIGHT_DATA_LENGTH);
+//                 let mut to_vec = [0u8; LIGHT_DATA_LENGTH];
+//                 to_vec.copy_from_slice(section);
+//                 out[i] = Some(to_vec);
+//                 data = rest;
+//             }
+//         }
+
+//         let result = Self {
+//             data: out,
+//         };
+
+//         Deserialized::ok(result, data)
+//     }
+
+//     fn update_mask(&self) -> VarInt {
+//         self.compute_has_mask(true)
+//     }
+
+//     fn reset_mask(&self) -> VarInt {
+//         self.compute_has_mask(false)
+//     }
+
+//     fn compute_has_mask(&self, has: bool) -> VarInt {
+//         let mut out: u32 = 0;
+//         for i in 0..LIGHT_DATA_SECTIONS {
+//             if self.data[i].is_some() == has {
+//                 out |= 1 << i;
+//             }
+//         }
+
+//         VarInt(out as i32)
+//     }
+
+//     fn serialize_data<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+//         for item in self.data.iter() {
+//             if let Some(contents) = item {
+//                 to.serialize_other(&VarInt(2048))?;
+//                 to.serialize_bytes(&contents[..])?;
+//             }
+//         }
+
+//         Ok(())
+//     }
+// }
+
+// impl fmt::Debug for LightingData {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         write!(
+//             f,
+//             "LightingData(update={:018b}, reset={:018b}, size={}, bytes={})",
+//             self.update_mask().0,
+//             self.reset_mask().0,
+//             self.data.iter().filter(move |v| v.is_some()).count(),
+//             self.data.iter()
+//                 .filter_map(move |v| v.
+//                     map(move |arr| arr.len()))
+//                 .sum::<usize>())
+//     }
+// }
+
+// impl fmt::Display for LightingData {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         <dyn fmt::Debug>::fmt(self, f)
+//     }
+// }
+
+// #[cfg(all(test, feature = "std"))]
+// impl LightingData {
+//     fn gen_random_mask() -> i32 {
+//         let rand: u32 = rand::random();
+//         (rand & ((1 << 19) - 1)) as i32
+//     }
+// }
+
+// #[cfg(all(test, feature = "std"))]
+// impl TestRandom for LightingData {
+//     fn test_gen_random() -> Self {
+//         let set_mask = Self::gen_random_mask();
+//         let mut data = Box::new([None; LIGHT_DATA_SECTIONS]);
+//         for i in 0..LIGHT_DATA_SECTIONS {
+//             if (set_mask & (1 << i)) != 0 {
+//                 let mut data_arr = [0u8; LIGHT_DATA_LENGTH];
+//                 for k in 0..LIGHT_DATA_LENGTH {
+//                     data_arr[k] = rand::random();
+//                 }
+//                 data[i] = Some(data_arr);
+//             }
+//         }
+
+//         Self {
+//             data,
+//         }
+//     }
+// }
+
+// #[derive(Clone, PartialEq, Debug)]
+// pub struct LightingUpdateSpec {
+//     pub skylight_data: LightingData,
+//     pub blocklight_data: LightingData,
+// }
+
+// impl Serialize for LightingUpdateSpec {
+//     fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+//         self.skylight_data.update_mask().mc_serialize(to)?;
+//         self.blocklight_data.update_mask().mc_serialize(to)?;
+//         self.skylight_data.reset_mask().mc_serialize(to)?;
+//         self.blocklight_data.reset_mask().mc_serialize(to)?;
+//         self.skylight_data.serialize_data(to)?;
+//         self.blocklight_data.serialize_data(to)
+//     }
+// }
+
+// impl Deserialize for LightingUpdateSpec {
+//     fn mc_deserialize(data: &[u8]) -> DeserializeResult<'_, Self> {
+//         let Deserialized { value: skylight_update_mask, data } = VarInt::mc_deserialize(data)?;
+//         let Deserialized { value: blocklight_update_mask, data } = VarInt::mc_deserialize(data)?;
+//         let Deserialized { value: _, data } = VarInt::mc_deserialize(data)?;
+//         let Deserialized { value: _, data } = VarInt::mc_deserialize(data)?;
+
+//         let Deserialized { value: skylight_data, data } = LightingData::deserialize(skylight_update_mask, data)?;
+//         let Deserialized { value: blocklight_data, data } = LightingData::deserialize(blocklight_update_mask, data)?;
+
+//         Deserialized::ok(Self {
+//             skylight_data,
+//             blocklight_data,
+//         }, data)
+//     }
+// }
+
+// #[cfg(all(test, feature = "std"))]
+// impl TestRandom for LightingUpdateSpec {
+//     fn test_gen_random() -> Self {
+//         Self {
+//             skylight_data: LightingData::test_gen_random(),
+//             blocklight_data: LightingData::test_gen_random(),
+//         }
+//     }
+// }
+
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct EntityMetadata {
+    pub fields: Vec<EntityMetadataField>,
+}
+
+impl Serialize for EntityMetadata {
+    fn mc_serialize<S: Serializer>(&self, to: &mut S) -> SerializeResult {
+        for field in &self.fields {
+            to.serialize_byte(field.index)?;
+            to.serialize_other(&field.data)?;
+        }
+        to.serialize_byte(0xFF)
+    }
+}
+
+impl Deserialize for EntityMetadata {
+    fn mc_deserialize(mut data: &[u8]) -> DeserializeResult<'_, Self> {
+        let mut fields = Vec::new();
+        loop {
+            let Deserialized {
+                value: index,
+                data: rest,
+            } = u8::mc_deserialize(data)?;
+            data = rest;
+            if index == 0xFF {
+                break;
+            }
+
+            let Deserialized {
+                value: field,
+                data: rest,
+            } = EntityMetadataFieldData::mc_deserialize(data)?;
+            data = rest;
+            fields.push(EntityMetadataField { index, data: field });
+        }
+
+        Deserialized::ok(Self { fields }, data)
+    }
+}
+
+#[cfg(all(test, feature = "std"))]
+impl TestRandom for EntityMetadata {
+    fn test_gen_random() -> Self {
+        let n_fields = rand::random::<usize>() % 10;
+        let mut fields = Vec::with_capacity(n_fields);
+        for i in 0..n_fields {
+            fields.push(EntityMetadataField {
+                index: i as u8,
+                data: EntityMetadataFieldData::test_gen_random(),
+            });
+        }
+
+        Self { fields }
+    }
+}
+
+impl EntityMetadata {
+    pub fn set(&mut self, index: u8, data: EntityMetadataFieldData) {
+        for field in &mut self.fields {
+            if field.index == index {
+                field.data = data;
+                return;
+            }
+        }
+
+        self.fields.push(EntityMetadataField { index, data })
+    }
+
+    pub fn remove(&mut self, index: u8) -> bool {
+        for i in 0..self.fields.len() {
+            let field = self
+                .fields
+                .get(i)
+                .expect("iterating through this vec, definitely have this index");
+            if field.index == index {
+                self.fields.remove(i);
+                return true;
+            }
+        }
+
+        false
+    }
+
+    pub fn get(&self, index: u8) -> Option<&EntityMetadataFieldData> {
+        for field in &self.fields {
+            if field.index == index {
+                return Some(&field.data);
+            }
+        }
+
+        None
+    }
+
+    pub fn get_mut(&mut self, index: u8) -> Option<&mut EntityMetadataFieldData> {
+        for field in &mut self.fields {
+            if field.index == index {
+                return Some(&mut field.data);
+            }
+        }
+
+        None
+    }
+}
+
+impl<'a> core::iter::IntoIterator for &'a EntityMetadata {
+    type Item = (u8, &'a EntityMetadataFieldData);
+    type IntoIter = FieldIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        FieldIter { data: self, at: 0 }
+    }
+}
+
+pub struct FieldIter<'a> {
+    data: &'a EntityMetadata,
+    at: usize,
+}
+
+impl<'a> core::iter::Iterator for FieldIter<'a> {
+    type Item = (u8, &'a EntityMetadataFieldData);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.data
+            .fields
+            .get(self.at)
+            .map(move |field| (field.index, &field.data))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.data.fields.len();
+        (len, Some(len))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct EntityMetadataField {
+    pub index: u8,
+    pub data: EntityMetadataFieldData,
+}
+
+proto_varint_enum!(EntityMetadataFieldData,
+    0x00 :: Byte(i8),
+    0x01 :: VarInt(VarInt),
+    0x02 :: Float(f32),
+    0x03 :: String(String),
+    0x04 :: Chat(Chat),
+    0x05 :: OptChat(Option<Chat>),
+    0x06 :: Slot(Slot),
+    0x07 :: Boolean(bool),
+    0x08 :: Rotation(Vec3<f32>),
+    0x09 :: Position(IntPosition),
+    0x0A :: OptPosition(Option<IntPosition>),
+    0x0B :: Direction(EntityDirection),
+    0x0C :: OptUUID(Option<UUID4>),
+    0x0D :: OptBlockId(VarInt),
+    0x0E :: NBT(NamedNbtTag),
+    0x0F :: Particle(ParticleSpec),
+    0x10 :: VillagerData(EntityVillagerData),
+    0x11 :: OptVarInt(VarInt),
+    0x12 :: Pose(EntityPose)
+);
+
+proto_varint_enum!(EntityDirection,
+    0x00 :: Down,
+    0x01 :: Up,
+    0x02 :: North,
+    0x03 :: South,
+    0x04 :: West,
+    0x05 :: East
+);
+
+proto_struct!(EntityVillagerData {
+    villager_type: VillagerType,
+    villager_profession: VillagerProfession,
+    level: VarInt
+});
+
+proto_varint_enum!(VillagerType,
+    0x00 :: Desert,
+    0x01 :: Jungle,
+    0x02 :: Plains,
+    0x03 :: Savanna,
+    0x04 :: Snow,
+    0x05 :: Swamp,
+    0x06 :: Taiga
+);
+
+proto_varint_enum!(VillagerProfession,
+    0x00 :: None,
+    0x01 :: Armorer,
+    0x02 :: Butcher,
+    0x03 :: Cartographer,
+    0x04 :: Cleric,
+    0x05 :: Farmer,
+    0x06 :: Fisherman,
+    0x07 :: Fletcher,
+    0x08 :: LeatherWorker,
+    0x09 :: Librarian,
+    0x0A :: Mason,
+    0x0B :: Nitwit,
+    0x0C :: Shepherd,
+    0x0D :: Toolsmith,
+    0x0E :: Weaponsmith
+);
+
+proto_varint_enum!(EntityPose,
+    0x00 :: Standing,
+    0x01 :: FallFlying,
+    0x02 :: Sleeping,
+    0x03 :: Swimming,
+    0x04 :: SpinAttack,
+    0x05 :: Sneaking,
+    0x06 :: LongJumping,
+    0x07 :: Dying
+);
+
+proto_varint_enum!(ParticleSpec,
+    0x00 :: AmbientEntityEffect,
+    0x01 :: AngryVillager,
+    0x02 :: Barrier,
+    0x03 :: Light,
+    0x04 :: Block(BlockParticleData),
+    0x05 :: Bubble,
+    0x06 :: Cloud,
+    0x07 :: Crit,
+    0x08 :: DamageIndicator,
+    0x09 :: DragonBreath,
+    0x0A :: DrippingLava,
+    0x0B :: FallingLava,
+    0x0C :: LandingLava,
+    0x0D :: DrippingWater,
+    0x0E :: FallingWater,
+    0x0F :: Dust(DustParticleData),
+    0x10 :: DustColorTransition(DustColorTransitionData),
+    0x11 :: Effect,
+    0x12 :: ElderGuardian,
+    0x13 :: EnchantedHit,
+    0x14 :: Enchant,
+    0x15 :: EndRod,
+    0x16 :: EntityEffect,
+    0x17 :: ExplosionEmitter,
+    0x18 :: Explosion,
+    0x19 :: FallingDust(DustParticleData),
+    0x1A :: Firework,
+    0x1B :: Fishing,
+    0x1C :: Flame,
+    0x1D :: SoulFireFlame,
+    0x1E :: Soul,
+    0x1F :: Flash,
+    0x20 :: HappyVillager,
+    0x21 :: Composter,
+    0x22 :: Heart,
+    0x23 :: InstantEffect,
+    0x24 :: Item(Slot),
+    0x25 :: Vibration(VibrationData),
+    0x26 :: ItemSlime,
+    0x27 :: ItemSnowball,
+    0x28 :: LargeSmoke,
+    0x29 :: Lava,
+    0x2A :: Mycelium,
+    0x2B :: Note,
+    0x2C :: Poof,
+    0x2D :: Portal,
+    0x2E :: Rain,
+    0x2F :: Smoke,
+    0x30 :: Sneeze,
+    0x31 :: Spit,
+    0x32 :: SquidInk,
+    0x33 :: SweepAttack,
+    0x34 :: TotemOfUndying,
+    0x35 :: Underwater,
+    0x36 :: Splash,
+    0x37 :: Witch,
+    0x38 :: BubblePop,
+    0x39 :: CurrentDown,
+    0x3A :: BubbleColumnUp,
+    0x3B :: Nautilus,
+    0x3C :: Dolphin,
+    0x3D :: CampfireCosySmoke,
+    0x3E :: CampfireSignalSmoke,
+    0x3F :: DrippingHoney,
+    0x40 :: FallingHoney,
+    0x41 :: LandingHoney,
+    0x42 :: FallingNectar,
+    0x43 :: FallingSporeBlossom,
+    0x44 :: Ash,
+    0x45 :: CrimsonSpore,
+    0x46 :: WarpedSpore,
+    0x47 :: SporeBlossomAir,
+    0x48 :: DrippingObsidianTear,
+    0x49 :: FallingObsidianTear,
+    0x4A :: LandingObsidianTear,
+    0x4B :: ReversePortal,
+    0x4C :: WhiteAsh,
+    0x4D :: SmallFlame,
+    0x4E :: Snowflake,
+    0x4F :: DrippingDripstoneLava,
+    0x50 :: FallingDripstoneLava,
+    0x51 :: DrippingDripstoneWater,
+    0x52 :: FallingDripstoneWater,
+    0x53 :: GlowSquidInk,
+    0x54 :: Glow,
+    0x55 :: WaxOn,
+    0x56 :: WaxOff,
+    0x57 :: ElectricSpark,
+    0x58 :: Scrape
+);
+
+proto_struct!(BlockParticleData {
+    block_state: VarInt
+});
+
+proto_struct!(DustParticleData {
+    red: f32,
+    green: f32,
+    blue: f32,
+    scale: f32
+});
+
+proto_struct!(DustColorTransitionData {
+    from_red: f32,
+    from_green: f32,
+    from_blue: f32,
+    scale: f32,
+    to_red: f32,
+    to_green: f32,
+    to_blue: f32
+});
+
+proto_struct!(VibrationData {
+    origin_x: f64,
+    origin_y: f64,
+    origin_z: f64,
+    dest_x: f64,
+    dest_y: f64,
+    dest_z: f64
+});
+
+#[cfg(all(test, feature = "std"))]
+pub mod tests {
+    use super::*;
+    use crate::packet_test_cases;
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        Handshake,
+        HandshakeSpec,
+        test_handshake,
+        bench_write_handshake,
+        bench_read_handshake
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        StatusRequest,
+        StatusRequestSpec,
+        test_status_request,
+        bench_write_status_request,
+        bench_read_status_request
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        StatusPing,
+        StatusPingSpec,
+        test_status_ping,
+        bench_write_status_ping,
+        bench_read_status_ping
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        StatusResponse,
+        StatusResponseSpec,
+        test_status_response,
+        bench_write_status_response,
+        bench_read_status_response
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        StatusPong,
+        StatusPongSpec,
+        test_status_pong,
+        bench_write_status_pong,
+        bench_read_status_pong
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginDisconnect,
+        LoginDisconnectSpec,
+        test_login_disconnect,
+        bench_write_login_disconnect,
+        bench_read_login_disconnect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginEncryptionRequest,
+        LoginEncryptionRequestSpec,
+        test_login_encryption_request,
+        bench_write_login_encryption_request,
+        bench_read_login_encryption_request
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginSuccess,
+        LoginSuccessSpec,
+        test_login_success,
+        bench_write_login_success,
+        bench_read_login_success
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginSetCompression,
+        LoginSetCompressionSpec,
+        test_login_set_compression,
+        bench_write_login_set_compression,
+        bench_read_login_set_compression
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginPluginRequest,
+        LoginPluginRequestSpec,
+        test_login_plugin_request,
+        bench_write_login_plugin_request,
+        bench_read_login_plugin_request
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginStart,
+        LoginStartSpec,
+        test_login_start,
+        bench_write_login_start,
+        bench_read_login_start
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginEncryptionResponse,
+        LoginEncryptionResponseSpec,
+        test_login_encryption_response,
+        bench_write_login_encryption_response,
+        bench_read_login_encryption_response
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        LoginPluginResponse,
+        LoginPluginResponseSpec,
+        test_login_plugin_response,
+        bench_write_login_plugin_response,
+        bench_read_login_plugin_response
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnEntity,
+        PlaySpawnEntitySpec,
+        test_play_spawn_entity,
+        bench_write_play_spawn_entity,
+        bench_read_play_spawn_entity
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnExperienceOrb,
+        PlaySpawnExperienceOrbSpec,
+        test_play_spawn_experience_orb,
+        bench_write_play_spawn_experience_orb,
+        bench_read_play_spawn_experience_orb
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnLivingEntity,
+        PlaySpawnLivingEntitySpec,
+        test_play_spawn_living_entity,
+        bench_write_play_spawn_living_entity,
+        bench_read_play_spawn_living_entity
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnPainting,
+        PlaySpawnPaintingSpec,
+        test_play_spawn_painting,
+        bench_write_play_spawn_painting,
+        bench_read_play_spawn_painting
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnPlayer,
+        PlaySpawnPlayerSpec,
+        test_play_spawn_player,
+        bench_write_play_spawn_player,
+        bench_read_play_spawn_player
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityAnimation,
+        PlayEntityAnimationSpec,
+        test_play_entity_animation,
+        bench_write_play_entity_animation,
+        bench_read_play_entity_animation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayStatistics,
+        PlayStatisticsSpec,
+        test_play_statistics,
+        bench_write_play_statistics,
+        bench_read_play_statistics
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayAcknowledgePlayerDigging,
+        PlayAcknowledgePlayerDiggingSpec,
+        test_play_acknowledge_player_digging,
+        bench_write_play_acknowledge_player_digging,
+        bench_read_play_acknowledge_player_digging
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBlockBreakAnimation,
+        PlayBlockBreakAnimationSpec,
+        test_play_block_break_animation,
+        bench_write_play_block_break_animation,
+        bench_read_play_block_break_animation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBlockEntityData,
+        PlayBlockEntityDataSpec,
+        test_play_block_entity_data,
+        bench_write_play_block_entity_data,
+        bench_read_play_block_entity_data
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBlockAction,
+        PlayBlockActionSpec,
+        test_play_block_action,
+        bench_write_play_block_action,
+        bench_read_play_block_action
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBlockChange,
+        PlayBlockChangeSpec,
+        test_play_block_change,
+        bench_write_play_block_change,
+        bench_read_play_block_change
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBossBar,
+        PlayBossBarSpec,
+        test_play_boss_bar,
+        bench_write_play_boss_bar,
+        bench_read_play_boss_bar
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerDifficulty,
+        PlayServerDifficultySpec,
+        test_play_server_difficulty,
+        bench_write_play_server_difficulty,
+        bench_read_play_server_difficulty
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerChatMessage,
+        PlayServerChatMessageSpec,
+        test_play_server_chat_message,
+        bench_write_play_server_chat_message,
+        bench_read_play_server_chat_message
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTabComplete,
+        PlayTabCompleteSpec,
+        test_play_tab_complete,
+        bench_write_play_tab_complete,
+        bench_read_play_tab_complete
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayDeclareCommands,
+        PlayDeclareCommandsSpec,
+        test_play_declare_commands,
+        bench_write_play_declare_commands,
+        bench_read_play_declare_commands
+    );
+
+    // packet_test_cases!(
+    //     RawPacket755,
+    //     Packet755,
+    //     PlayServerWindowConfirmation,
+    //     PlayServerWindowConfirmationSpec,
+    //     test_play_server_window_confirmation,
+    //     bench_write_play_server_window_confirmation,
+    //     bench_read_play_server_window_confirmation
+    // );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerCloseWindow,
+        PlayServerCloseWindowSpec,
+        test_play_server_close_window,
+        bench_write_play_server_close_window,
+        bench_read_play_server_close_window
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayWindowItems,
+        PlayWindowItemsSpec,
+        test_play_window_items,
+        bench_write_play_window_items,
+        bench_read_play_window_items
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayWindowProperty,
+        PlayWindowPropertySpec,
+        test_play_window_property,
+        bench_write_play_window_property,
+        bench_read_play_window_property
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetSlot,
+        PlaySetSlotSpec,
+        test_play_set_slot,
+        bench_write_play_set_slot,
+        bench_read_play_set_slot
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetCooldown,
+        PlaySetCooldownSpec,
+        test_play_set_cooldown,
+        bench_write_play_set_cooldown,
+        bench_read_play_set_cooldown
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerPluginMessage,
+        PlayServerPluginMessageSpec,
+        test_play_server_plugin_message,
+        bench_write_play_server_plugin_message,
+        bench_read_play_server_plugin_message
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayNamedSoundEffect,
+        PlayNamedSoundEffectSpec,
+        test_play_named_sound_effect,
+        bench_write_play_named_sound_effect,
+        bench_read_play_named_sound_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayDisconnect,
+        PlayDisconnectSpec,
+        test_play_disconnect,
+        bench_write_play_disconnect,
+        bench_read_play_disconnect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityStatus,
+        PlayEntityStatusSpec,
+        test_play_entity_status,
+        bench_write_play_entity_status,
+        bench_read_play_entity_status
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayExplosion,
+        PlayExplosionSpec,
+        test_play_explosion,
+        bench_write_play_explosion,
+        bench_read_play_explosion
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUnloadChunk,
+        PlayUnloadChunkSpec,
+        test_play_unload_chunk,
+        bench_write_play_unload_chunk,
+        bench_read_play_unload_chunk
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayChangeGameState,
+        PlayChangeGameStateSpec,
+        test_play_change_game_state,
+        bench_write_play_change_game_state,
+        bench_read_play_change_game_state
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayOpenHorseWindow,
+        PlayOpenHorseWindowSpec,
+        test_play_open_horse_window,
+        bench_write_play_open_horse_window,
+        bench_read_play_open_horse_window
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerKeepAlive,
+        PlayServerKeepAliveSpec,
+        test_play_server_keep_alive,
+        bench_write_play_server_keep_alive,
+        bench_read_play_server_keep_alive
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayChunkData,
+        PlayChunkDataWrapper,
+        test_play_chunk_data,
+        bench_write_play_chunk_data,
+        bench_read_play_chunk_data
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEffect,
+        PlayEffectSpec,
+        test_play_effect,
+        bench_write_play_effect,
+        bench_read_play_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayParticle,
+        PlayParticleSpec,
+        test_play_particle,
+        bench_write_play_particle,
+        bench_read_play_particle
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateLight,
+        PlayUpdateLightSpec,
+        test_play_update_light,
+        bench_write_play_update_light,
+        bench_read_play_update_light
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayJoinGame,
+        PlayJoinGameSpec,
+        test_play_join_game,
+        bench_write_play_join_game,
+        bench_read_play_join_game
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayMapData,
+        PlayMapDataSpec,
+        test_play_map_data,
+        bench_write_play_map_data,
+        bench_read_play_map_data
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTradeList,
+        PlayTradeListSpec,
+        test_play_trade_list,
+        bench_write_play_trade_list,
+        bench_read_play_trade_list
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityPosition,
+        PlayEntityPositionSpec,
+        test_play_entity_position,
+        bench_write_play_entity_position,
+        bench_read_play_entity_position
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityPositionAndRotation,
+        PlayEntityPositionAndRotationSpec,
+        test_play_entity_position_and_rotation,
+        bench_write_play_entity_position_and_rotation,
+        bench_read_play_entity_position_and_rotation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityRotation,
+        PlayEntityRotationSpec,
+        test_play_entity_rotation,
+        bench_write_play_entity_rotation,
+        bench_read_play_entity_rotation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityMovement,
+        PlayEntityMovementSpec,
+        test_play_entity_movement,
+        bench_write_play_entity_movement,
+        bench_read_play_entity_movement
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerVehicleMove,
+        PlayEntityVehicleMoveSpec,
+        test_play_server_vehicle_move,
+        bench_write_play_server_vehicle_move,
+        bench_read_play_server_vehicle_move
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayOpenBook,
+        PlayOpenBookSpec,
+        test_play_open_book,
+        bench_write_play_open_book,
+        bench_read_play_open_book
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayOpenWindow,
+        PlayOpenWindowSpec,
+        test_play_open_window,
+        bench_write_play_open_window,
+        bench_read_play_open_window
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayOpenSignEditor,
+        PlayOpenSignEditorSpec,
+        test_play_open_sign_editor,
+        bench_write_play_open_sign_editor,
+        bench_read_play_open_sign_editor
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCraftRecipeResponse,
+        PlayCraftRecipeResponseSpec,
+        test_play_craft_recipe_response,
+        bench_write_play_craft_recipe_response,
+        bench_read_play_craft_recipe_response
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerPlayerAbilities,
+        PlayServerPlayerAbilitiesSpec,
+        test_play_server_player_abilities,
+        bench_write_play_server_player_abilities,
+        bench_read_play_server_player_abilities
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCombatEvent,
+        PlayCombatEventSpec,
+        test_play_combat_event,
+        bench_write_play_combat_event,
+        bench_read_play_combat_event
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPlayerInfo,
+        PlayPlayerInfoSpec,
+        test_play_player_info,
+        bench_write_play_player_info,
+        bench_read_play_player_info
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayFacePlayer,
+        PlayFacePlayerSpec,
+        test_play_face_player,
+        bench_write_play_face_player,
+        bench_read_play_face_player
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerPlayerPositionAndLook,
+        PlayServerPlayerPositionAndLookSpec,
+        test_play_server_player_position_and_look,
+        bench_write_play_server_player_position_and_look,
+        bench_read_play_server_player_position_and_look
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUnlockRecipes,
+        PlayUnlockRecipesSpec,
+        test_play_unlock_recipes,
+        bench_write_play_unlock_recipes,
+        bench_read_play_unlock_recipes
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayDestroyEntities,
+        PlayDestroyEntitiesSpec,
+        test_play_destroy_entities,
+        bench_write_play_destroy_entities,
+        bench_read_play_destroy_entities
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayRemoveEntityEffect,
+        PlayRemoveEntityEffectSpec,
+        test_play_remove_entity_effect,
+        bench_write_play_remove_entity_effect,
+        bench_read_play_remove_entity_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayResourcePackSend,
+        PlayResourcePackSendSpec,
+        test_play_resource_pack_send,
+        bench_write_play_resource_pack_send,
+        bench_read_play_resource_pack_send
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayRespawn,
+        PlayRespawnSpec,
+        test_play_respawn,
+        bench_write_play_respawn,
+        bench_read_play_respawn
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityHeadLook,
+        PlayEntityHeadLookSpec,
+        test_play_entity_head_look,
+        bench_write_play_entity_head_look,
+        bench_read_play_entity_head_look
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayMultiBlockChange,
+        PlayMultiBlockChangeSpec,
+        test_play_multi_block_change,
+        bench_write_play_multi_block_change,
+        bench_read_play_multi_block_change
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySelectAdvancementTab,
+        PlaySelectAdvancementTabSpec,
+        test_play_select_advancement_tab,
+        bench_write_play_select_advancement_tab,
+        bench_read_play_select_advancement_tab
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayWorldBorder,
+        PlayWorldBorderSpec,
+        test_play_world_border,
+        bench_write_play_world_border,
+        bench_read_play_world_border
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCamera,
+        PlayCameraSpec,
+        test_play_camera,
+        bench_write_play_camera,
+        bench_read_play_camera
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayServerHeldItemChange,
+        PlayServerHeldItemChangeSpec,
+        test_play_server_held_item_change,
+        bench_write_play_server_held_item_change,
+        bench_read_play_server_held_item_change
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateViewPosition,
+        PlayUpdateViewPositionSpec,
+        test_play_update_view_position,
+        bench_write_play_update_view_position,
+        bench_read_play_update_view_position
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateViewDistance,
+        PlayUpdateViewDistanceSpec,
+        test_play_update_view_distance,
+        bench_write_play_update_view_distance,
+        bench_read_play_update_view_distance
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpawnPosition,
+        PlaySpawnPositionSpec,
+        test_play_spawn_position,
+        bench_write_play_spawn_position,
+        bench_read_play_spawn_position
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayDisplayScoreboard,
+        PlayDisplayScoreboardSpec,
+        test_play_display_scoreboard,
+        bench_write_play_display_scoreboard,
+        bench_read_play_display_scoreboard
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityMetadata,
+        PlayEntityMetadataSpec,
+        test_play_entity_metadata,
+        bench_write_play_entity_metadata,
+        bench_read_play_entity_metadata
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayAttachEntity,
+        PlayAttachEntitySpec,
+        test_play_attach_entity,
+        bench_write_play_attach_entity,
+        bench_read_play_attach_entity
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityVelocity,
+        PlayEntityVelocitySpec,
+        test_play_entity_velocity,
+        bench_write_play_entity_velocity,
+        bench_read_play_entity_velocity
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityEquipment,
+        PlayEntityEquiptmentSpec,
+        test_play_entity_equipment,
+        bench_write_play_entity_equipment,
+        bench_read_play_entity_equipment
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetExperience,
+        PlaySetExperienceSpec,
+        test_play_set_experience,
+        bench_write_play_set_experience,
+        bench_read_play_set_experience
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdatehealth,
+        PlayUpdateHealthSpec,
+        test_play_updatehealth,
+        bench_write_play_updatehealth,
+        bench_read_play_updatehealth
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayScoreboardObjective,
+        PlayScoreboardObjectiveSpec,
+        test_play_scoreboard_objective,
+        bench_write_play_scoreboard_objective,
+        bench_read_play_scoreboard_objective
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetPassengers,
+        PlaySetPassengersSpec,
+        test_play_set_passengers,
+        bench_write_play_set_passengers,
+        bench_read_play_set_passengers
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTeams,
+        PlayTeamsSpec,
+        test_play_teams,
+        bench_write_play_teams,
+        bench_read_play_teams
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateScore,
+        PlayUpdateScoreSpec,
+        test_play_update_score,
+        bench_write_play_update_score,
+        bench_read_play_update_score
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTimeUpdate,
+        PlayTimeUpdateSpec,
+        test_play_time_update,
+        bench_write_play_time_update,
+        bench_read_play_time_update
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTitle,
+        PlayTitleSpec,
+        test_play_title,
+        bench_write_play_title,
+        bench_read_play_title
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntitySoundEffect,
+        PlayEntitySoundEffectSpec,
+        test_play_entity_sound_effect,
+        bench_write_play_entity_sound_effect,
+        bench_read_play_entity_sound_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySoundEffect,
+        PlaySoundEffectSpec,
+        test_play_sound_effect,
+        bench_write_play_sound_effect,
+        bench_read_play_sound_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayStopSound,
+        PlayStopSoundSpec,
+        test_play_stop_sound,
+        bench_write_play_stop_sound,
+        bench_read_play_stop_sound
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayerPlayerListHeaderAndFooter,
+        PlayPlayerListHeaderAndFooterSpec,
+        test_player_player_list_header_and_footer,
+        bench_write_player_player_list_header_and_footer,
+        bench_read_player_player_list_header_and_footer
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayNbtQueryResponse,
+        PlayNbtQueryResponseSpec,
+        test_play_nbt_query_response,
+        bench_write_play_nbt_query_response,
+        bench_read_play_nbt_query_response
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCollectItem,
+        PlayCollectItemSpec,
+        test_play_collect_item,
+        bench_write_play_collect_item,
+        bench_read_play_collect_item
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityTeleport,
+        PlayEntityTeleportSpec,
+        test_play_entity_teleport,
+        bench_write_play_entity_teleport,
+        bench_read_play_entity_teleport
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayAdvancements,
+        PlayAdvancementsSpec,
+        test_play_advancements,
+        bench_write_play_advancements,
+        bench_read_play_advancements
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityProperties,
+        PlayEntityPropertiesSpec,
+        test_play_entity_properties,
+        bench_write_play_entity_properties,
+        bench_read_play_entity_properties
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityEffect,
+        PlayEntityEffectSpec,
+        test_play_entity_effect,
+        bench_write_play_entity_effect,
+        bench_read_play_entity_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayDeclareRecipes,
+        PlayDeclareRecipesSpec,
+        test_play_declare_recipes,
+        bench_write_play_declare_recipes,
+        bench_read_play_declare_recipes
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTags,
+        PlayTagsSpec,
+        test_play_tags,
+        bench_write_play_tags,
+        bench_read_play_tags
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayTeleportConfirm,
+        PlayTeleportConfirmSpec,
+        test_play_teleport_confirm,
+        bench_write_play_teleport_confirm,
+        bench_read_play_teleport_confirm
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayQueryBlockNbt,
+        PlayQueryBlockNbtSpec,
+        test_play_query_block_nbt,
+        bench_write_play_query_block_nbt,
+        bench_read_play_query_block_nbt
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayQueryEntityNbt,
+        PlayQueryEntityNbtSpec,
+        test_play_query_entity_nbt,
+        bench_write_play_query_entity_nbt,
+        bench_read_play_query_entity_nbt
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetDifficulty,
+        PlaySetDifficultySpec,
+        test_play_set_difficulty,
+        bench_write_play_set_difficulty,
+        bench_read_play_set_difficulty
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientChatMessage,
+        PlayClientChatMessageSpec,
+        test_play_client_chat_message,
+        bench_write_play_client_chat_message,
+        bench_read_play_client_chat_message
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientStatus,
+        PlayClientStatusSpec,
+        test_play_client_status,
+        bench_write_play_client_status,
+        bench_read_play_client_status
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientSettings,
+        PlayClientSettingsSpec,
+        test_play_client_settings,
+        bench_write_play_client_settings,
+        bench_read_play_client_settings
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientTabComplete,
+        PlayClientTabCompleteSpec,
+        test_play_client_tab_complete,
+        bench_write_play_client_tab_complete,
+        bench_read_play_client_tab_complete
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientWindowConfirmation,
+        PlayClientWindowConfirmationSpec,
+        test_play_client_window_confirmation,
+        bench_write_play_client_window_confirmation,
+        bench_read_play_client_window_confirmation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClickWindowButton,
+        PlayClickWindowButtonSpec,
+        test_play_click_window_button,
+        bench_write_play_click_window_button,
+        bench_read_play_click_window_button
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClickWindow,
+        PlayClickWindowSpec,
+        test_play_click_window,
+        bench_write_play_click_window,
+        bench_read_play_click_window
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientCloseWindow,
+        PlayClientCloseWindowSpec,
+        test_play_client_close_window,
+        bench_write_play_client_close_window,
+        bench_read_play_client_close_window
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientPluginMessage,
+        PlayClientPluginMessageSpec,
+        test_play_client_plugin_message,
+        bench_write_play_client_plugin_message,
+        bench_read_play_client_plugin_message
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEditBook,
+        PlayEditBookSpec,
+        test_play_edit_book,
+        bench_write_play_edit_book,
+        bench_read_play_edit_book
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayInteractEntity,
+        PlayInteractEntitySpec,
+        test_play_interact_entity,
+        bench_write_play_interact_entity,
+        bench_read_play_interact_entity
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayGenerateStructure,
+        PlayGenerateStructureSpec,
+        test_play_generate_structure,
+        bench_write_play_generate_structure,
+        bench_read_play_generate_structure
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientKeepAlive,
+        PlayClientKeepAliveSpec,
+        test_play_client_keep_alive,
+        bench_write_play_client_keep_alive,
+        bench_read_play_client_keep_alive
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayLockDifficulty,
+        PlayLockDifficultySpec,
+        test_play_lock_difficulty,
+        bench_write_play_lock_difficulty,
+        bench_read_play_lock_difficulty
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPlayerPosition,
+        PlayPlayerPositionSpec,
+        test_play_player_position,
+        bench_write_play_player_position,
+        bench_read_play_player_position
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientPlayerPositionAndRotation,
+        PlayClientPlayerPositionAndRotationSpec,
+        test_play_client_player_position_and_rotation,
+        bench_write_play_client_player_position_and_rotation,
+        bench_read_play_client_player_position_and_rotation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPlayerRotation,
+        PlayPlayerRotationSpec,
+        test_play_player_rotation,
+        bench_write_play_player_rotation,
+        bench_read_play_player_rotation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPlayerMovement,
+        PlayPlayerMovementSpec,
+        test_play_player_movement,
+        bench_write_play_player_movement,
+        bench_read_play_player_movement
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientVehicleMove,
+        PlayClientVehicleMoveSpec,
+        test_play_client_vehicle_move,
+        bench_write_play_client_vehicle_move,
+        bench_read_play_client_vehicle_move
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySteerBoat,
+        PlaySteerBoatSpec,
+        test_play_steer_boat,
+        bench_write_play_steer_boat,
+        bench_read_play_steer_boat
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPickItem,
+        PlayPickItemSpec,
+        test_play_pick_item,
+        bench_write_play_pick_item,
+        bench_read_play_pick_item
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCraftRecipeRequest,
+        PlayCraftRecipeRequestSpec,
+        test_play_craft_recipe_request,
+        bench_write_play_craft_recipe_request,
+        bench_read_play_craft_recipe_request
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientPlayerAbilities,
+        PlayClientPlayerAbilitiesSpec,
+        test_play_client_player_abilities,
+        bench_write_play_client_player_abilities,
+        bench_read_play_client_player_abilities
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayPlayerDigging,
+        PlayPlayerDiggingSpec,
+        test_play_player_digging,
+        bench_write_play_player_digging,
+        bench_read_play_player_digging
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayEntityAction,
+        PlayEntityActionSpec,
+        test_play_entity_action,
+        bench_write_play_entity_action,
+        bench_read_play_entity_action
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySteerVehicle,
+        PlaySteerVehicleSpec,
+        test_play_steer_vehicle,
+        bench_write_play_steer_vehicle,
+        bench_read_play_steer_vehicle
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetDisplayedRecipe,
+        PlaySetDisplayedRecipeSpec,
+        test_play_set_displayed_recipe,
+        bench_write_play_set_displayed_recipe,
+        bench_read_play_set_displayed_recipe
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetRecipeBookState,
+        PlaySetRecipeBookStateSpec,
+        test_play_set_recipe_book_state,
+        bench_write_play_set_recipe_book_state,
+        bench_read_play_set_recipe_book_state
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayNameItem,
+        PlayNameItemSpec,
+        test_play_name_item,
+        bench_write_play_name_item,
+        bench_read_play_name_item
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayResourcePackStatus,
+        PlayResourcePackStatusSpec,
+        test_play_resource_pack_status,
+        bench_write_play_resource_pack_status,
+        bench_read_play_resource_pack_status
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayAdvancementTab,
+        PlayAdvancementTabSpec,
+        test_play_advancement_tab,
+        bench_write_play_advancement_tab,
+        bench_read_play_advancement_tab
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySelectTrade,
+        PlaySelectTradeSpec,
+        test_play_select_trade,
+        bench_write_play_select_trade,
+        bench_read_play_select_trade
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySetBeaconEffect,
+        PlaySetBeaconEffectSpec,
+        test_play_set_beacon_effect,
+        bench_write_play_set_beacon_effect,
+        bench_read_play_set_beacon_effect
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientHeldItemChange,
+        PlayClientHeldItemChangeSpec,
+        test_play_client_held_item_change,
+        bench_write_play_client_held_item_change,
+        bench_read_play_client_held_item_change
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateCommandBlock,
+        PlayUpdateCommandBlockSpec,
+        test_play_update_command_block,
+        bench_write_play_update_command_block,
+        bench_read_play_update_command_block
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateCommandBlockMinecart,
+        PlayUpdateCommandBlockMinecartSpec,
+        test_play_update_command_block_minecart,
+        bench_write_play_update_command_block_minecart,
+        bench_read_play_update_command_block_minecart
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateJigsawBlock,
+        PlayUpdateJigsawBlockSpec,
+        test_play_update_jigsaw_block,
+        bench_write_play_update_jigsaw_block,
+        bench_read_play_update_jigsaw_block
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayCreativeInventoryAction,
+        PlayCreativeInventoryActionSpec,
+        test_play_creative_inventory_action,
+        bench_write_play_creative_inventory_action,
+        bench_read_play_creative_inventory_action
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateStructureBlock,
+        PlayUpdateStructureBlockSpec,
+        test_play_update_structure_block,
+        bench_write_play_update_structure_block,
+        bench_read_play_update_structure_block
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUpdateSign,
+        PlayUpdateSignSpec,
+        test_play_update_sign,
+        bench_write_play_update_sign,
+        bench_read_play_update_sign
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayClientAnimation,
+        PlayClientAnimationSpec,
+        test_play_client_animation,
+        bench_write_play_client_animation,
+        bench_read_play_client_animation
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlaySpectate,
+        PlaySpectateSpec,
+        test_play_spectate,
+        bench_write_play_spectate,
+        bench_read_play_spectate
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayBlockPlacement,
+        PlayBlockPlacementSpec,
+        test_play_block_placement,
+        bench_write_play_block_placement,
+        bench_read_play_block_placement
+    );
+
+    packet_test_cases!(
+        RawPacket755,
+        Packet755,
+        PlayUseItem,
+        PlayUseItemSpec,
+        test_play_use_item,
+        bench_write_play_use_item,
+        bench_read_play_use_item
+    );
+
+    // trust me, this is some cutting edge shit
+    // I'm definitely not generating code using a unit test
+    #[test]
+    fn test_generate_test_cases() {
+        Packet755::describe().packets.iter().map(move |packet| {
+            let snake_case = to_snake_case(packet.name.clone());
+            alloc::format!("packet_test_cases!(RawPacket755, Packet755, {}, {},\n        test_{}, bench_write_{}, bench_read_{});\n",
+                           packet.name, packet.body_struct, snake_case, snake_case, snake_case).to_owned()
+        }).for_each(move |line| {
+            println!("{}", line)
+        })
+    }
+
+    fn to_snake_case(camel: String) -> String {
+        let mut parts = Vec::new();
+        let mut buf = String::new();
+        for c in camel.chars() {
+            if !buf.is_empty() && char::is_uppercase(c) {
+                parts.push(buf);
+                buf = String::new();
+            }
+
+            buf.push(c.to_ascii_lowercase());
+        }
+
+        if !buf.is_empty() {
+            parts.push(buf);
+        }
+
+        parts.join("_")
+    }
+}