WHEA_DEVICE_DRIVER_DESCRIPTOR

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct WHEA_ERROR_SOURCE_CONFIGURATION_DD
{
    public IntPtr Initialize;
    public IntPtr Uninitialize;
    public IntPtr Correct;
}

[StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
public struct WHEA_DEVICE_DRIVER_DESCRIPTOR
{
    public ushort Type;
    [MarshalAs(UnmanagedType.U1)] public bool Enabled;
    public byte Reserved;
    public Guid SourceGuid;
    public ushort LogTag;
    public ushort Reserved2;
    public uint PacketLength;
    public uint PacketCount;
    public IntPtr PacketBuffer;
    public WHEA_ERROR_SOURCE_CONFIGURATION_DD Config;
    public Guid CreatorId;
    public Guid PartitionId;
    public uint MaxSectionDataLength;
    public uint MaxSectionsPerRecord;
    public IntPtr PacketStateBuffer;
    public int OpenHandles;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure WHEA_ERROR_SOURCE_CONFIGURATION_DD
    Public Initialize As IntPtr
    Public Uninitialize As IntPtr
    Public Correct As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, Pack:=1, CharSet:=CharSet.Unicode)>
Public Structure WHEA_DEVICE_DRIVER_DESCRIPTOR
    Public Type As UShort
    <MarshalAs(UnmanagedType.U1)> Public Enabled As Boolean
    Public Reserved As Byte
    Public SourceGuid As Guid
    Public LogTag As UShort
    Public Reserved2 As UShort
    Public PacketLength As UInteger
    Public PacketCount As UInteger
    Public PacketBuffer As IntPtr
    Public Config As WHEA_ERROR_SOURCE_CONFIGURATION_DD
    Public CreatorId As Guid
    Public PartitionId As Guid
    Public MaxSectionDataLength As UInteger
    Public MaxSectionsPerRecord As UInteger
    Public PacketStateBuffer As IntPtr
    Public OpenHandles As Integer
End Structure

import ctypes
from ctypes import wintypes

class WHEA_ERROR_SOURCE_CONFIGURATION_DD(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("Initialize", ctypes.c_void_p),
        ("Uninitialize", ctypes.c_void_p),
        ("Correct", ctypes.c_void_p),
    ]

class WHEA_DEVICE_DRIVER_DESCRIPTOR(ctypes.Structure):
    _pack_ = 1
    _fields_ = [
        ("Type", ctypes.c_ushort),
        ("Enabled", ctypes.c_byte),
        ("Reserved", ctypes.c_ubyte),
        ("SourceGuid", GUID),
        ("LogTag", ctypes.c_ushort),
        ("Reserved2", ctypes.c_ushort),
        ("PacketLength", wintypes.DWORD),
        ("PacketCount", wintypes.DWORD),
        ("PacketBuffer", ctypes.c_void_p),
        ("Config", WHEA_ERROR_SOURCE_CONFIGURATION_DD),
        ("CreatorId", GUID),
        ("PartitionId", GUID),
        ("MaxSectionDataLength", wintypes.DWORD),
        ("MaxSectionsPerRecord", wintypes.DWORD),
        ("PacketStateBuffer", ctypes.c_void_p),
        ("OpenHandles", ctypes.c_int),
    ]

#[repr(C, packed(1))]
pub struct WHEA_ERROR_SOURCE_CONFIGURATION_DD {
    pub Initialize: *mut core::ffi::c_void,
    pub Uninitialize: *mut core::ffi::c_void,
    pub Correct: *mut core::ffi::c_void,
}

#[repr(C, packed(1))]
pub struct WHEA_DEVICE_DRIVER_DESCRIPTOR {
    pub Type: u16,
    pub Enabled: u8,
    pub Reserved: u8,
    pub SourceGuid: GUID,
    pub LogTag: u16,
    pub Reserved2: u16,
    pub PacketLength: u32,
    pub PacketCount: u32,
    pub PacketBuffer: *mut core::ffi::c_void,
    pub Config: WHEA_ERROR_SOURCE_CONFIGURATION_DD,
    pub CreatorId: GUID,
    pub PartitionId: GUID,
    pub MaxSectionDataLength: u32,
    pub MaxSectionsPerRecord: u32,
    pub PacketStateBuffer: *mut core::ffi::c_void,
    pub OpenHandles: i32,
}

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

type WHEA_ERROR_SOURCE_CONFIGURATION_DD struct {
	Initialize uintptr
	Uninitialize uintptr
	Correct uintptr
}

type WHEA_DEVICE_DRIVER_DESCRIPTOR struct {
	Type uint16
	Enabled byte
	Reserved byte
	SourceGuid windows.GUID
	LogTag uint16
	Reserved2 uint16
	PacketLength uint32
	PacketCount uint32
	PacketBuffer uintptr
	Config WHEA_ERROR_SOURCE_CONFIGURATION_DD
	CreatorId windows.GUID
	PartitionId windows.GUID
	MaxSectionDataLength uint32
	MaxSectionsPerRecord uint32
	PacketStateBuffer uintptr
	OpenHandles int32
}

type
  WHEA_ERROR_SOURCE_CONFIGURATION_DD = packed record
    Initialize: Pointer;
    Uninitialize: Pointer;
    Correct: Pointer;
  end;

  WHEA_DEVICE_DRIVER_DESCRIPTOR = packed record
    Type: Word;
    Enabled: ByteBool;
    Reserved: Byte;
    SourceGuid: TGUID;
    LogTag: Word;
    Reserved2: Word;
    PacketLength: DWORD;
    PacketCount: DWORD;
    PacketBuffer: Pointer;
    Config: WHEA_ERROR_SOURCE_CONFIGURATION_DD;
    CreatorId: TGUID;
    PartitionId: TGUID;
    MaxSectionDataLength: DWORD;
    MaxSectionsPerRecord: DWORD;
    PacketStateBuffer: Pointer;
    OpenHandles: Integer;
  end;

const WHEA_ERROR_SOURCE_CONFIGURATION_DD = extern struct {
    Initialize: ?*anyopaque,
    Uninitialize: ?*anyopaque,
    Correct: ?*anyopaque,
};

const WHEA_DEVICE_DRIVER_DESCRIPTOR = extern struct {
    Type: u16,
    Enabled: u8,
    Reserved: u8,
    SourceGuid: GUID,
    LogTag: u16,
    Reserved2: u16,
    PacketLength: u32,
    PacketCount: u32,
    PacketBuffer: ?*anyopaque,
    Config: WHEA_ERROR_SOURCE_CONFIGURATION_DD,
    CreatorId: GUID,
    PartitionId: GUID,
    MaxSectionDataLength: u32,
    MaxSectionsPerRecord: u32,
    PacketStateBuffer: ?*anyopaque,
    OpenHandles: i32,
};

type
  WHEA_ERROR_SOURCE_CONFIGURATION_DD {.packed.} = object
    Initialize: pointer
    Uninitialize: pointer
    Correct: pointer

  WHEA_DEVICE_DRIVER_DESCRIPTOR {.packed.} = object
    Type: uint16
    Enabled: uint8
    Reserved: uint8
    SourceGuid: GUID
    LogTag: uint16
    Reserved2: uint16
    PacketLength: uint32
    PacketCount: uint32
    PacketBuffer: pointer
    Config: WHEA_ERROR_SOURCE_CONFIGURATION_DD
    CreatorId: GUID
    PartitionId: GUID
    MaxSectionDataLength: uint32
    MaxSectionsPerRecord: uint32
    PacketStateBuffer: pointer
    OpenHandles: int32

align(1)
struct WHEA_ERROR_SOURCE_CONFIGURATION_DD
{
    void* Initialize;
    void* Uninitialize;
    void* Correct;
}

align(1)
struct WHEA_DEVICE_DRIVER_DESCRIPTOR
{
    ushort Type;
    ubyte Enabled;
    ubyte Reserved;
    GUID SourceGuid;
    ushort LogTag;
    ushort Reserved2;
    uint PacketLength;
    uint PacketCount;
    void* PacketBuffer;
    WHEA_ERROR_SOURCE_CONFIGURATION_DD Config;
    GUID CreatorId;
    GUID PartitionId;
    uint MaxSectionDataLength;
    uint MaxSectionsPerRecord;
    void* PacketStateBuffer;
    int OpenHandles;
}