pub const Media = union(Subtype) {
    hard_drive: *const HardDriveDevicePath,
    cdrom: *const CdromDevicePath,
    vendor: *const VendorDevicePath,
    file_path: *const FilePathDevicePath,
    media_protocol: *const MediaProtocolDevicePath,
    piwg_firmware_file: *const PiwgFirmwareFileDevicePath,
    piwg_firmware_volume: *const PiwgFirmwareVolumeDevicePath,
    relative_offset_range: *const RelativeOffsetRangeDevicePath,
    ram_disk: *const RamDiskDevicePath,

    pub const Subtype = enum(u8) {
        hard_drive = 1,
        cdrom = 2,
        vendor = 3,
        file_path = 4,
        media_protocol = 5,
        piwg_firmware_file = 6,
        piwg_firmware_volume = 7,
        relative_offset_range = 8,
        ram_disk = 9,
        _,
    };

    pub const HardDriveDevicePath = extern struct {
        pub const Format = enum(u8) {
            legacy_mbr = 0x01,
            guid_partition_table = 0x02,
        };

        pub const SignatureType = enum(u8) {
            no_signature = 0x00,
            /// "32-bit signature from address 0x1b8 of the type 0x01 MBR"
            mbr_signature = 0x01,
            guid_signature = 0x02,
        };

        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        partition_number: u32 align(1),
        partition_start: u64 align(1),
        partition_size: u64 align(1),
        partition_signature: [16]u8,
        partition_format: Format,
        signature_type: SignatureType,
    };

    comptime {
        assert(42 == @sizeOf(HardDriveDevicePath));
        assert(1 == @alignOf(HardDriveDevicePath));

        assert(0 == @offsetOf(HardDriveDevicePath, "type"));
        assert(1 == @offsetOf(HardDriveDevicePath, "subtype"));
        assert(2 == @offsetOf(HardDriveDevicePath, "length"));
        assert(4 == @offsetOf(HardDriveDevicePath, "partition_number"));
        assert(8 == @offsetOf(HardDriveDevicePath, "partition_start"));
        assert(16 == @offsetOf(HardDriveDevicePath, "partition_size"));
        assert(24 == @offsetOf(HardDriveDevicePath, "partition_signature"));
        assert(40 == @offsetOf(HardDriveDevicePath, "partition_format"));
        assert(41 == @offsetOf(HardDriveDevicePath, "signature_type"));
    }

    pub const CdromDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        boot_entry: u32 align(1),
        partition_start: u64 align(1),
        partition_size: u64 align(1),
    };

    comptime {
        assert(24 == @sizeOf(CdromDevicePath));
        assert(1 == @alignOf(CdromDevicePath));

        assert(0 == @offsetOf(CdromDevicePath, "type"));
        assert(1 == @offsetOf(CdromDevicePath, "subtype"));
        assert(2 == @offsetOf(CdromDevicePath, "length"));
        assert(4 == @offsetOf(CdromDevicePath, "boot_entry"));
        assert(8 == @offsetOf(CdromDevicePath, "partition_start"));
        assert(16 == @offsetOf(CdromDevicePath, "partition_size"));
    }

    pub const VendorDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        guid: Guid align(1),
    };

    comptime {
        assert(20 == @sizeOf(VendorDevicePath));
        assert(1 == @alignOf(VendorDevicePath));

        assert(0 == @offsetOf(VendorDevicePath, "type"));
        assert(1 == @offsetOf(VendorDevicePath, "subtype"));
        assert(2 == @offsetOf(VendorDevicePath, "length"));
        assert(4 == @offsetOf(VendorDevicePath, "guid"));
    }

    pub const FilePathDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),

        pub fn getPath(self: *const FilePathDevicePath) [*:0]align(1) const u16 {
            return @as([*:0]align(1) const u16, @ptrCast(@as([*]const u8, @ptrCast(self)) + @sizeOf(FilePathDevicePath)));
        }
    };

    comptime {
        assert(4 == @sizeOf(FilePathDevicePath));
        assert(1 == @alignOf(FilePathDevicePath));

        assert(0 == @offsetOf(FilePathDevicePath, "type"));
        assert(1 == @offsetOf(FilePathDevicePath, "subtype"));
        assert(2 == @offsetOf(FilePathDevicePath, "length"));
    }

    pub const MediaProtocolDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        guid: Guid align(1),
    };

    comptime {
        assert(20 == @sizeOf(MediaProtocolDevicePath));
        assert(1 == @alignOf(MediaProtocolDevicePath));

        assert(0 == @offsetOf(MediaProtocolDevicePath, "type"));
        assert(1 == @offsetOf(MediaProtocolDevicePath, "subtype"));
        assert(2 == @offsetOf(MediaProtocolDevicePath, "length"));
        assert(4 == @offsetOf(MediaProtocolDevicePath, "guid"));
    }

    pub const PiwgFirmwareFileDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        fv_filename: Guid align(1),
    };

    comptime {
        assert(20 == @sizeOf(PiwgFirmwareFileDevicePath));
        assert(1 == @alignOf(PiwgFirmwareFileDevicePath));

        assert(0 == @offsetOf(PiwgFirmwareFileDevicePath, "type"));
        assert(1 == @offsetOf(PiwgFirmwareFileDevicePath, "subtype"));
        assert(2 == @offsetOf(PiwgFirmwareFileDevicePath, "length"));
        assert(4 == @offsetOf(PiwgFirmwareFileDevicePath, "fv_filename"));
    }

    pub const PiwgFirmwareVolumeDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        fv_name: Guid align(1),
    };

    comptime {
        assert(20 == @sizeOf(PiwgFirmwareVolumeDevicePath));
        assert(1 == @alignOf(PiwgFirmwareVolumeDevicePath));

        assert(0 == @offsetOf(PiwgFirmwareVolumeDevicePath, "type"));
        assert(1 == @offsetOf(PiwgFirmwareVolumeDevicePath, "subtype"));
        assert(2 == @offsetOf(PiwgFirmwareVolumeDevicePath, "length"));
        assert(4 == @offsetOf(PiwgFirmwareVolumeDevicePath, "fv_name"));
    }

    pub const RelativeOffsetRangeDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        reserved: u32 align(1),
        start: u64 align(1),
        end: u64 align(1),
    };

    comptime {
        assert(24 == @sizeOf(RelativeOffsetRangeDevicePath));
        assert(1 == @alignOf(RelativeOffsetRangeDevicePath));

        assert(0 == @offsetOf(RelativeOffsetRangeDevicePath, "type"));
        assert(1 == @offsetOf(RelativeOffsetRangeDevicePath, "subtype"));
        assert(2 == @offsetOf(RelativeOffsetRangeDevicePath, "length"));
        assert(4 == @offsetOf(RelativeOffsetRangeDevicePath, "reserved"));
        assert(8 == @offsetOf(RelativeOffsetRangeDevicePath, "start"));
        assert(16 == @offsetOf(RelativeOffsetRangeDevicePath, "end"));
    }

    pub const RamDiskDevicePath = extern struct {
        type: DevicePath.Type,
        subtype: Subtype,
        length: u16 align(1),
        start: u64 align(1),
        end: u64 align(1),
        disk_type: Guid align(1),
        instance: u16 align(1),
    };

    comptime {
        assert(38 == @sizeOf(RamDiskDevicePath));
        assert(1 == @alignOf(RamDiskDevicePath));

        assert(0 == @offsetOf(RamDiskDevicePath, "type"));
        assert(1 == @offsetOf(RamDiskDevicePath, "subtype"));
        assert(2 == @offsetOf(RamDiskDevicePath, "length"));
        assert(4 == @offsetOf(RamDiskDevicePath, "start"));
        assert(12 == @offsetOf(RamDiskDevicePath, "end"));
        assert(20 == @offsetOf(RamDiskDevicePath, "disk_type"));
        assert(36 == @offsetOf(RamDiskDevicePath, "instance"));
    }
}