PPM_WMI_IDLE_STATES_EX

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PPM_WMI_IDLE_STATE
{
    public uint Latency;
    public uint Power;
    public uint TimeCheck;
    public byte PromotePercent;
    public byte DemotePercent;
    public byte StateType;
    public byte Reserved;
    public uint StateFlags;
    public uint Context;
    public uint IdleHandler;
    public uint Reserved1;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PPM_WMI_IDLE_STATES_EX
{
    public uint Type;
    public uint Count;
    public uint TargetState;
    public uint OldState;
    public IntPtr TargetProcessors;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] public PPM_WMI_IDLE_STATE[] State;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PPM_WMI_IDLE_STATE
    Public Latency As UInteger
    Public Power As UInteger
    Public TimeCheck As UInteger
    Public PromotePercent As Byte
    Public DemotePercent As Byte
    Public StateType As Byte
    Public Reserved As Byte
    Public StateFlags As UInteger
    Public Context As UInteger
    Public IdleHandler As UInteger
    Public Reserved1 As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PPM_WMI_IDLE_STATES_EX
    Public Type As UInteger
    Public Count As UInteger
    Public TargetState As UInteger
    Public OldState As UInteger
    Public TargetProcessors As IntPtr
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=1)> Public State() As PPM_WMI_IDLE_STATE
End Structure

import ctypes
from ctypes import wintypes

class PPM_WMI_IDLE_STATE(ctypes.Structure):
    _fields_ = [
        ("Latency", wintypes.DWORD),
        ("Power", wintypes.DWORD),
        ("TimeCheck", wintypes.DWORD),
        ("PromotePercent", ctypes.c_ubyte),
        ("DemotePercent", ctypes.c_ubyte),
        ("StateType", ctypes.c_ubyte),
        ("Reserved", ctypes.c_ubyte),
        ("StateFlags", wintypes.DWORD),
        ("Context", wintypes.DWORD),
        ("IdleHandler", wintypes.DWORD),
        ("Reserved1", wintypes.DWORD),
    ]

class PPM_WMI_IDLE_STATES_EX(ctypes.Structure):
    _fields_ = [
        ("Type", wintypes.DWORD),
        ("Count", wintypes.DWORD),
        ("TargetState", wintypes.DWORD),
        ("OldState", wintypes.DWORD),
        ("TargetProcessors", ctypes.c_void_p),
        ("State", PPM_WMI_IDLE_STATE * 1),
    ]

#[repr(C)]
pub struct PPM_WMI_IDLE_STATE {
    pub Latency: u32,
    pub Power: u32,
    pub TimeCheck: u32,
    pub PromotePercent: u8,
    pub DemotePercent: u8,
    pub StateType: u8,
    pub Reserved: u8,
    pub StateFlags: u32,
    pub Context: u32,
    pub IdleHandler: u32,
    pub Reserved1: u32,
}

#[repr(C)]
pub struct PPM_WMI_IDLE_STATES_EX {
    pub Type: u32,
    pub Count: u32,
    pub TargetState: u32,
    pub OldState: u32,
    pub TargetProcessors: *mut core::ffi::c_void,
    pub State: [PPM_WMI_IDLE_STATE; 1],
}

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

type PPM_WMI_IDLE_STATE struct {
	Latency uint32
	Power uint32
	TimeCheck uint32
	PromotePercent byte
	DemotePercent byte
	StateType byte
	Reserved byte
	StateFlags uint32
	Context uint32
	IdleHandler uint32
	Reserved1 uint32
}

type PPM_WMI_IDLE_STATES_EX struct {
	Type uint32
	Count uint32
	TargetState uint32
	OldState uint32
	TargetProcessors uintptr
	State [1]PPM_WMI_IDLE_STATE
}

type
  PPM_WMI_IDLE_STATE = record
    Latency: DWORD;
    Power: DWORD;
    TimeCheck: DWORD;
    PromotePercent: Byte;
    DemotePercent: Byte;
    StateType: Byte;
    Reserved: Byte;
    StateFlags: DWORD;
    Context: DWORD;
    IdleHandler: DWORD;
    Reserved1: DWORD;
  end;

  PPM_WMI_IDLE_STATES_EX = record
    Type: DWORD;
    Count: DWORD;
    TargetState: DWORD;
    OldState: DWORD;
    TargetProcessors: Pointer;
    State: array[0..0] of PPM_WMI_IDLE_STATE;
  end;

const PPM_WMI_IDLE_STATE = extern struct {
    Latency: u32,
    Power: u32,
    TimeCheck: u32,
    PromotePercent: u8,
    DemotePercent: u8,
    StateType: u8,
    Reserved: u8,
    StateFlags: u32,
    Context: u32,
    IdleHandler: u32,
    Reserved1: u32,
};

const PPM_WMI_IDLE_STATES_EX = extern struct {
    Type: u32,
    Count: u32,
    TargetState: u32,
    OldState: u32,
    TargetProcessors: ?*anyopaque,
    State: [1]PPM_WMI_IDLE_STATE,
};

type
  PPM_WMI_IDLE_STATE {.bycopy.} = object
    Latency: uint32
    Power: uint32
    TimeCheck: uint32
    PromotePercent: uint8
    DemotePercent: uint8
    StateType: uint8
    Reserved: uint8
    StateFlags: uint32
    Context: uint32
    IdleHandler: uint32
    Reserved1: uint32

  PPM_WMI_IDLE_STATES_EX {.bycopy.} = object
    Type: uint32
    Count: uint32
    TargetState: uint32
    OldState: uint32
    TargetProcessors: pointer
    State: array[1, PPM_WMI_IDLE_STATE]

struct PPM_WMI_IDLE_STATE
{
    uint Latency;
    uint Power;
    uint TimeCheck;
    ubyte PromotePercent;
    ubyte DemotePercent;
    ubyte StateType;
    ubyte Reserved;
    uint StateFlags;
    uint Context;
    uint IdleHandler;
    uint Reserved1;
}

struct PPM_WMI_IDLE_STATES_EX
{
    uint Type;
    uint Count;
    uint TargetState;
    uint OldState;
    void* TargetProcessors;
    PPM_WMI_IDLE_STATE[1] State;
}