STORAGE_COUNTERS

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STORAGE_COUNTER
{
    public int Type;
    public _Value_e__Union Value;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct STORAGE_COUNTERS
{
    public uint Version;
    public uint Size;
    public uint NumberOfCounters;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public STORAGE_COUNTER[] Counters;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STORAGE_COUNTER
    Public Type As Integer
    Public Value As _Value_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure STORAGE_COUNTERS
    Public Version As UInteger
    Public Size As UInteger
    Public NumberOfCounters As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public Counters() As STORAGE_COUNTER
End Structure

import ctypes
from ctypes import wintypes

class STORAGE_COUNTER(ctypes.Structure):
    _fields_ = [
        ("Type", ctypes.c_int),
        ("Value", _Value_e__Union),
    ]

class STORAGE_COUNTERS(ctypes.Structure):
    _fields_ = [
        ("Version", wintypes.DWORD),
        ("Size", wintypes.DWORD),
        ("NumberOfCounters", wintypes.DWORD),
        ("Counters", STORAGE_COUNTER * 1),
    ]

#[repr(C)]
pub struct STORAGE_COUNTER {
    pub Type: i32,
    pub Value: _Value_e__Union,
}

#[repr(C)]
pub struct STORAGE_COUNTERS {
    pub Version: u32,
    pub Size: u32,
    pub NumberOfCounters: u32,
    pub Counters: [STORAGE_COUNTER; 1],
}

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

type STORAGE_COUNTER struct {
	Type int32
	Value _Value_e__Union
}

type STORAGE_COUNTERS struct {
	Version uint32
	Size uint32
	NumberOfCounters uint32
	Counters [1]STORAGE_COUNTER
}

type
  STORAGE_COUNTER = record
    Type: Integer;
    Value: _Value_e__Union;
  end;

  STORAGE_COUNTERS = record
    Version: DWORD;
    Size: DWORD;
    NumberOfCounters: DWORD;
    Counters: array[0..0] of STORAGE_COUNTER;
  end;

const STORAGE_COUNTER = extern struct {
    Type: i32,
    Value: _Value_e__Union,
};

const STORAGE_COUNTERS = extern struct {
    Version: u32,
    Size: u32,
    NumberOfCounters: u32,
    Counters: [1]STORAGE_COUNTER,
};

type
  STORAGE_COUNTER {.bycopy.} = object
    Type: int32
    Value: _Value_e__Union

  STORAGE_COUNTERS {.bycopy.} = object
    Version: uint32
    Size: uint32
    NumberOfCounters: uint32
    Counters: array[1, STORAGE_COUNTER]

struct STORAGE_COUNTER
{
    int Type;
    _Value_e__Union Value;
}

struct STORAGE_COUNTERS
{
    uint Version;
    uint Size;
    uint NumberOfCounters;
    STORAGE_COUNTER[1] Counters;
}