STORAGE_PHYSICAL_DEVICE_DATA

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STORAGE_SPEC_VERSION
{
    public _Anonymous_e__Struct Anonymous;
    public uint AsUlong;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STORAGE_PHYSICAL_DEVICE_DATA
{
    public uint DeviceId;
    public uint Role;
    public int HealthStatus;
    public int CommandProtocol;
    public STORAGE_SPEC_VERSION SpecVersion;
    public int FormFactor;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public byte[] Vendor;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] public byte[] Model;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public byte[] FirmwareRevision;
    public ulong Capacity;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] PhysicalLocation;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public uint[] Reserved;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STORAGE_SPEC_VERSION
    Public Anonymous As _Anonymous_e__Struct
    Public AsUlong As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STORAGE_PHYSICAL_DEVICE_DATA
    Public DeviceId As UInteger
    Public Role As UInteger
    Public HealthStatus As Integer
    Public CommandProtocol As Integer
    Public SpecVersion As STORAGE_SPEC_VERSION
    Public FormFactor As Integer
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=8)> Public Vendor() As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=40)> Public Model() As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16)> Public FirmwareRevision() As Byte
    Public Capacity As ULong
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=32)> Public PhysicalLocation() As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=2)> Public Reserved() As UInteger
End Structure

import ctypes
from ctypes import wintypes

class STORAGE_SPEC_VERSION(ctypes.Structure):
    _fields_ = [
        ("Anonymous", _Anonymous_e__Struct),
        ("AsUlong", wintypes.DWORD),
    ]

class STORAGE_PHYSICAL_DEVICE_DATA(ctypes.Structure):
    _fields_ = [
        ("DeviceId", wintypes.DWORD),
        ("Role", wintypes.DWORD),
        ("HealthStatus", ctypes.c_int),
        ("CommandProtocol", ctypes.c_int),
        ("SpecVersion", STORAGE_SPEC_VERSION),
        ("FormFactor", ctypes.c_int),
        ("Vendor", ctypes.c_ubyte * 8),
        ("Model", ctypes.c_ubyte * 40),
        ("FirmwareRevision", ctypes.c_ubyte * 16),
        ("Capacity", ctypes.c_ulonglong),
        ("PhysicalLocation", ctypes.c_ubyte * 32),
        ("Reserved", wintypes.DWORD * 2),
    ]

#[repr(C)]
pub struct STORAGE_SPEC_VERSION {
    pub Anonymous: _Anonymous_e__Struct,
    pub AsUlong: u32,
}

#[repr(C)]
pub struct STORAGE_PHYSICAL_DEVICE_DATA {
    pub DeviceId: u32,
    pub Role: u32,
    pub HealthStatus: i32,
    pub CommandProtocol: i32,
    pub SpecVersion: STORAGE_SPEC_VERSION,
    pub FormFactor: i32,
    pub Vendor: [u8; 8],
    pub Model: [u8; 40],
    pub FirmwareRevision: [u8; 16],
    pub Capacity: u64,
    pub PhysicalLocation: [u8; 32],
    pub Reserved: [u32; 2],
}

import "golang.org/x/sys/windows"

type STORAGE_SPEC_VERSION struct {
	Anonymous _Anonymous_e__Struct
	AsUlong uint32
}

type STORAGE_PHYSICAL_DEVICE_DATA struct {
	DeviceId uint32
	Role uint32
	HealthStatus int32
	CommandProtocol int32
	SpecVersion STORAGE_SPEC_VERSION
	FormFactor int32
	Vendor [8]byte
	Model [40]byte
	FirmwareRevision [16]byte
	Capacity uint64
	PhysicalLocation [32]byte
	Reserved [2]uint32
}

type
  STORAGE_SPEC_VERSION = record
    Anonymous: _Anonymous_e__Struct;
    AsUlong: DWORD;
  end;

  STORAGE_PHYSICAL_DEVICE_DATA = record
    DeviceId: DWORD;
    Role: DWORD;
    HealthStatus: Integer;
    CommandProtocol: Integer;
    SpecVersion: STORAGE_SPEC_VERSION;
    FormFactor: Integer;
    Vendor: array[0..7] of Byte;
    Model: array[0..39] of Byte;
    FirmwareRevision: array[0..15] of Byte;
    Capacity: UInt64;
    PhysicalLocation: array[0..31] of Byte;
    Reserved: array[0..1] of DWORD;
  end;

const STORAGE_SPEC_VERSION = extern struct {
    Anonymous: _Anonymous_e__Struct,
    AsUlong: u32,
};

const STORAGE_PHYSICAL_DEVICE_DATA = extern struct {
    DeviceId: u32,
    Role: u32,
    HealthStatus: i32,
    CommandProtocol: i32,
    SpecVersion: STORAGE_SPEC_VERSION,
    FormFactor: i32,
    Vendor: [8]u8,
    Model: [40]u8,
    FirmwareRevision: [16]u8,
    Capacity: u64,
    PhysicalLocation: [32]u8,
    Reserved: [2]u32,
};

type
  STORAGE_SPEC_VERSION {.bycopy.} = object
    Anonymous: _Anonymous_e__Struct
    AsUlong: uint32

  STORAGE_PHYSICAL_DEVICE_DATA {.bycopy.} = object
    DeviceId: uint32
    Role: uint32
    HealthStatus: int32
    CommandProtocol: int32
    SpecVersion: STORAGE_SPEC_VERSION
    FormFactor: int32
    Vendor: array[8, uint8]
    Model: array[40, uint8]
    FirmwareRevision: array[16, uint8]
    Capacity: uint64
    PhysicalLocation: array[32, uint8]
    Reserved: array[2, uint32]

struct STORAGE_SPEC_VERSION
{
    _Anonymous_e__Struct Anonymous;
    uint AsUlong;
}

struct STORAGE_PHYSICAL_DEVICE_DATA
{
    uint DeviceId;
    uint Role;
    int HealthStatus;
    int CommandProtocol;
    STORAGE_SPEC_VERSION SpecVersion;
    int FormFactor;
    ubyte[8] Vendor;
    ubyte[40] Model;
    ubyte[16] FirmwareRevision;
    ulong Capacity;
    ubyte[32] PhysicalLocation;
    uint[2] Reserved;
}