SYSTEM_POWER_POLICY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct POWER_ACTION_POLICY
{
    public int Action;
    public uint Flags;
    public uint EventCode;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SYSTEM_POWER_LEVEL
{
    [MarshalAs(UnmanagedType.U1)] public bool Enable;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] public byte[] Spare;
    public uint BatteryLevel;
    public POWER_ACTION_POLICY PowerPolicy;
    public int MinSystemState;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SYSTEM_POWER_POLICY
{
    public uint Revision;
    public POWER_ACTION_POLICY PowerButton;
    public POWER_ACTION_POLICY SleepButton;
    public POWER_ACTION_POLICY LidClose;
    public int LidOpenWake;
    public uint Reserved;
    public POWER_ACTION_POLICY Idle;
    public uint IdleTimeout;
    public byte IdleSensitivity;
    public byte DynamicThrottle;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)] public byte[] Spare2;
    public int MinSleep;
    public int MaxSleep;
    public int ReducedLatencySleep;
    public uint WinLogonFlags;
    public uint Spare3;
    public uint DozeS4Timeout;
    public uint BroadcastCapacityResolution;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public SYSTEM_POWER_LEVEL[] DischargePolicy;
    public uint VideoTimeout;
    [MarshalAs(UnmanagedType.U1)] public bool VideoDimDisplay;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] public uint[] VideoReserved;
    public uint SpindownTimeout;
    [MarshalAs(UnmanagedType.U1)] public bool OptimizeForPower;
    public byte FanThrottleTolerance;
    public byte ForcedThrottle;
    public byte MinThrottle;
    public POWER_ACTION_POLICY OverThrottled;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure POWER_ACTION_POLICY
    Public Action As Integer
    Public Flags As UInteger
    Public EventCode As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SYSTEM_POWER_LEVEL
    <MarshalAs(UnmanagedType.U1)> Public Enable As Boolean
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=3)> Public Spare() As Byte
    Public BatteryLevel As UInteger
    Public PowerPolicy As POWER_ACTION_POLICY
    Public MinSystemState As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SYSTEM_POWER_POLICY
    Public Revision As UInteger
    Public PowerButton As POWER_ACTION_POLICY
    Public SleepButton As POWER_ACTION_POLICY
    Public LidClose As POWER_ACTION_POLICY
    Public LidOpenWake As Integer
    Public Reserved As UInteger
    Public Idle As POWER_ACTION_POLICY
    Public IdleTimeout As UInteger
    Public IdleSensitivity As Byte
    Public DynamicThrottle As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=2)> Public Spare2() As Byte
    Public MinSleep As Integer
    Public MaxSleep As Integer
    Public ReducedLatencySleep As Integer
    Public WinLogonFlags As UInteger
    Public Spare3 As UInteger
    Public DozeS4Timeout As UInteger
    Public BroadcastCapacityResolution As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Public DischargePolicy() As SYSTEM_POWER_LEVEL
    Public VideoTimeout As UInteger
    <MarshalAs(UnmanagedType.U1)> Public VideoDimDisplay As Boolean
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=3)> Public VideoReserved() As UInteger
    Public SpindownTimeout As UInteger
    <MarshalAs(UnmanagedType.U1)> Public OptimizeForPower As Boolean
    Public FanThrottleTolerance As Byte
    Public ForcedThrottle As Byte
    Public MinThrottle As Byte
    Public OverThrottled As POWER_ACTION_POLICY
End Structure

import ctypes
from ctypes import wintypes

class POWER_ACTION_POLICY(ctypes.Structure):
    _fields_ = [
        ("Action", ctypes.c_int),
        ("Flags", wintypes.DWORD),
        ("EventCode", wintypes.DWORD),
    ]

class SYSTEM_POWER_LEVEL(ctypes.Structure):
    _fields_ = [
        ("Enable", ctypes.c_byte),
        ("Spare", ctypes.c_ubyte * 3),
        ("BatteryLevel", wintypes.DWORD),
        ("PowerPolicy", POWER_ACTION_POLICY),
        ("MinSystemState", ctypes.c_int),
    ]

class SYSTEM_POWER_POLICY(ctypes.Structure):
    _fields_ = [
        ("Revision", wintypes.DWORD),
        ("PowerButton", POWER_ACTION_POLICY),
        ("SleepButton", POWER_ACTION_POLICY),
        ("LidClose", POWER_ACTION_POLICY),
        ("LidOpenWake", ctypes.c_int),
        ("Reserved", wintypes.DWORD),
        ("Idle", POWER_ACTION_POLICY),
        ("IdleTimeout", wintypes.DWORD),
        ("IdleSensitivity", ctypes.c_ubyte),
        ("DynamicThrottle", ctypes.c_ubyte),
        ("Spare2", ctypes.c_ubyte * 2),
        ("MinSleep", ctypes.c_int),
        ("MaxSleep", ctypes.c_int),
        ("ReducedLatencySleep", ctypes.c_int),
        ("WinLogonFlags", wintypes.DWORD),
        ("Spare3", wintypes.DWORD),
        ("DozeS4Timeout", wintypes.DWORD),
        ("BroadcastCapacityResolution", wintypes.DWORD),
        ("DischargePolicy", SYSTEM_POWER_LEVEL * 4),
        ("VideoTimeout", wintypes.DWORD),
        ("VideoDimDisplay", ctypes.c_byte),
        ("VideoReserved", wintypes.DWORD * 3),
        ("SpindownTimeout", wintypes.DWORD),
        ("OptimizeForPower", ctypes.c_byte),
        ("FanThrottleTolerance", ctypes.c_ubyte),
        ("ForcedThrottle", ctypes.c_ubyte),
        ("MinThrottle", ctypes.c_ubyte),
        ("OverThrottled", POWER_ACTION_POLICY),
    ]

#[repr(C)]
pub struct POWER_ACTION_POLICY {
    pub Action: i32,
    pub Flags: u32,
    pub EventCode: u32,
}

#[repr(C)]
pub struct SYSTEM_POWER_LEVEL {
    pub Enable: u8,
    pub Spare: [u8; 3],
    pub BatteryLevel: u32,
    pub PowerPolicy: POWER_ACTION_POLICY,
    pub MinSystemState: i32,
}

#[repr(C)]
pub struct SYSTEM_POWER_POLICY {
    pub Revision: u32,
    pub PowerButton: POWER_ACTION_POLICY,
    pub SleepButton: POWER_ACTION_POLICY,
    pub LidClose: POWER_ACTION_POLICY,
    pub LidOpenWake: i32,
    pub Reserved: u32,
    pub Idle: POWER_ACTION_POLICY,
    pub IdleTimeout: u32,
    pub IdleSensitivity: u8,
    pub DynamicThrottle: u8,
    pub Spare2: [u8; 2],
    pub MinSleep: i32,
    pub MaxSleep: i32,
    pub ReducedLatencySleep: i32,
    pub WinLogonFlags: u32,
    pub Spare3: u32,
    pub DozeS4Timeout: u32,
    pub BroadcastCapacityResolution: u32,
    pub DischargePolicy: [SYSTEM_POWER_LEVEL; 4],
    pub VideoTimeout: u32,
    pub VideoDimDisplay: u8,
    pub VideoReserved: [u32; 3],
    pub SpindownTimeout: u32,
    pub OptimizeForPower: u8,
    pub FanThrottleTolerance: u8,
    pub ForcedThrottle: u8,
    pub MinThrottle: u8,
    pub OverThrottled: POWER_ACTION_POLICY,
}

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

type POWER_ACTION_POLICY struct {
	Action int32
	Flags uint32
	EventCode uint32
}

type SYSTEM_POWER_LEVEL struct {
	Enable byte
	Spare [3]byte
	BatteryLevel uint32
	PowerPolicy POWER_ACTION_POLICY
	MinSystemState int32
}

type SYSTEM_POWER_POLICY struct {
	Revision uint32
	PowerButton POWER_ACTION_POLICY
	SleepButton POWER_ACTION_POLICY
	LidClose POWER_ACTION_POLICY
	LidOpenWake int32
	Reserved uint32
	Idle POWER_ACTION_POLICY
	IdleTimeout uint32
	IdleSensitivity byte
	DynamicThrottle byte
	Spare2 [2]byte
	MinSleep int32
	MaxSleep int32
	ReducedLatencySleep int32
	WinLogonFlags uint32
	Spare3 uint32
	DozeS4Timeout uint32
	BroadcastCapacityResolution uint32
	DischargePolicy [4]SYSTEM_POWER_LEVEL
	VideoTimeout uint32
	VideoDimDisplay byte
	VideoReserved [3]uint32
	SpindownTimeout uint32
	OptimizeForPower byte
	FanThrottleTolerance byte
	ForcedThrottle byte
	MinThrottle byte
	OverThrottled POWER_ACTION_POLICY
}

type
  POWER_ACTION_POLICY = record
    Action: Integer;
    Flags: DWORD;
    EventCode: DWORD;
  end;

  SYSTEM_POWER_LEVEL = record
    Enable: ByteBool;
    Spare: array[0..2] of Byte;
    BatteryLevel: DWORD;
    PowerPolicy: POWER_ACTION_POLICY;
    MinSystemState: Integer;
  end;

  SYSTEM_POWER_POLICY = record
    Revision: DWORD;
    PowerButton: POWER_ACTION_POLICY;
    SleepButton: POWER_ACTION_POLICY;
    LidClose: POWER_ACTION_POLICY;
    LidOpenWake: Integer;
    Reserved: DWORD;
    Idle: POWER_ACTION_POLICY;
    IdleTimeout: DWORD;
    IdleSensitivity: Byte;
    DynamicThrottle: Byte;
    Spare2: array[0..1] of Byte;
    MinSleep: Integer;
    MaxSleep: Integer;
    ReducedLatencySleep: Integer;
    WinLogonFlags: DWORD;
    Spare3: DWORD;
    DozeS4Timeout: DWORD;
    BroadcastCapacityResolution: DWORD;
    DischargePolicy: array[0..3] of SYSTEM_POWER_LEVEL;
    VideoTimeout: DWORD;
    VideoDimDisplay: ByteBool;
    VideoReserved: array[0..2] of DWORD;
    SpindownTimeout: DWORD;
    OptimizeForPower: ByteBool;
    FanThrottleTolerance: Byte;
    ForcedThrottle: Byte;
    MinThrottle: Byte;
    OverThrottled: POWER_ACTION_POLICY;
  end;

const POWER_ACTION_POLICY = extern struct {
    Action: i32,
    Flags: u32,
    EventCode: u32,
};

const SYSTEM_POWER_LEVEL = extern struct {
    Enable: u8,
    Spare: [3]u8,
    BatteryLevel: u32,
    PowerPolicy: POWER_ACTION_POLICY,
    MinSystemState: i32,
};

const SYSTEM_POWER_POLICY = extern struct {
    Revision: u32,
    PowerButton: POWER_ACTION_POLICY,
    SleepButton: POWER_ACTION_POLICY,
    LidClose: POWER_ACTION_POLICY,
    LidOpenWake: i32,
    Reserved: u32,
    Idle: POWER_ACTION_POLICY,
    IdleTimeout: u32,
    IdleSensitivity: u8,
    DynamicThrottle: u8,
    Spare2: [2]u8,
    MinSleep: i32,
    MaxSleep: i32,
    ReducedLatencySleep: i32,
    WinLogonFlags: u32,
    Spare3: u32,
    DozeS4Timeout: u32,
    BroadcastCapacityResolution: u32,
    DischargePolicy: [4]SYSTEM_POWER_LEVEL,
    VideoTimeout: u32,
    VideoDimDisplay: u8,
    VideoReserved: [3]u32,
    SpindownTimeout: u32,
    OptimizeForPower: u8,
    FanThrottleTolerance: u8,
    ForcedThrottle: u8,
    MinThrottle: u8,
    OverThrottled: POWER_ACTION_POLICY,
};

type
  POWER_ACTION_POLICY {.bycopy.} = object
    Action: int32
    Flags: uint32
    EventCode: uint32

  SYSTEM_POWER_LEVEL {.bycopy.} = object
    Enable: uint8
    Spare: array[3, uint8]
    BatteryLevel: uint32
    PowerPolicy: POWER_ACTION_POLICY
    MinSystemState: int32

  SYSTEM_POWER_POLICY {.bycopy.} = object
    Revision: uint32
    PowerButton: POWER_ACTION_POLICY
    SleepButton: POWER_ACTION_POLICY
    LidClose: POWER_ACTION_POLICY
    LidOpenWake: int32
    Reserved: uint32
    Idle: POWER_ACTION_POLICY
    IdleTimeout: uint32
    IdleSensitivity: uint8
    DynamicThrottle: uint8
    Spare2: array[2, uint8]
    MinSleep: int32
    MaxSleep: int32
    ReducedLatencySleep: int32
    WinLogonFlags: uint32
    Spare3: uint32
    DozeS4Timeout: uint32
    BroadcastCapacityResolution: uint32
    DischargePolicy: array[4, SYSTEM_POWER_LEVEL]
    VideoTimeout: uint32
    VideoDimDisplay: uint8
    VideoReserved: array[3, uint32]
    SpindownTimeout: uint32
    OptimizeForPower: uint8
    FanThrottleTolerance: uint8
    ForcedThrottle: uint8
    MinThrottle: uint8
    OverThrottled: POWER_ACTION_POLICY

struct POWER_ACTION_POLICY
{
    int Action;
    uint Flags;
    uint EventCode;
}

struct SYSTEM_POWER_LEVEL
{
    ubyte Enable;
    ubyte[3] Spare;
    uint BatteryLevel;
    POWER_ACTION_POLICY PowerPolicy;
    int MinSystemState;
}

struct SYSTEM_POWER_POLICY
{
    uint Revision;
    POWER_ACTION_POLICY PowerButton;
    POWER_ACTION_POLICY SleepButton;
    POWER_ACTION_POLICY LidClose;
    int LidOpenWake;
    uint Reserved;
    POWER_ACTION_POLICY Idle;
    uint IdleTimeout;
    ubyte IdleSensitivity;
    ubyte DynamicThrottle;
    ubyte[2] Spare2;
    int MinSleep;
    int MaxSleep;
    int ReducedLatencySleep;
    uint WinLogonFlags;
    uint Spare3;
    uint DozeS4Timeout;
    uint BroadcastCapacityResolution;
    SYSTEM_POWER_LEVEL[4] DischargePolicy;
    uint VideoTimeout;
    ubyte VideoDimDisplay;
    uint[3] VideoReserved;
    uint SpindownTimeout;
    ubyte OptimizeForPower;
    ubyte FanThrottleTolerance;
    ubyte ForcedThrottle;
    ubyte MinThrottle;
    POWER_ACTION_POLICY OverThrottled;
}