DUMP_POINTERS_EX

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DUMP_POINTERS_VERSION
{
    public uint Version;
    public uint Size;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DUMP_POINTERS_EX
{
    public DUMP_POINTERS_VERSION Header;
    public IntPtr DumpData;
    public IntPtr CommonBufferVa;
    public uint CommonBufferSize;
    [MarshalAs(UnmanagedType.U1)] public bool AllocateCommonBuffers;
    public IntPtr DeviceObject;
    public IntPtr DriverList;
    public uint dwPortFlags;
    public uint MaxDeviceDumpSectionSize;
    public uint MaxDeviceDumpLevel;
    public uint MaxTransferSize;
    public IntPtr AdapterObject;
    public IntPtr MappedRegisterBase;
    [MarshalAs(UnmanagedType.U1)] public bool DeviceReady;
    public IntPtr DumpDevicePowerOn;
    public IntPtr DumpDevicePowerOnContext;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DUMP_POINTERS_VERSION
    Public Version As UInteger
    Public Size As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure DUMP_POINTERS_EX
    Public Header As DUMP_POINTERS_VERSION
    Public DumpData As IntPtr
    Public CommonBufferVa As IntPtr
    Public CommonBufferSize As UInteger
    <MarshalAs(UnmanagedType.U1)> Public AllocateCommonBuffers As Boolean
    Public DeviceObject As IntPtr
    Public DriverList As IntPtr
    Public dwPortFlags As UInteger
    Public MaxDeviceDumpSectionSize As UInteger
    Public MaxDeviceDumpLevel As UInteger
    Public MaxTransferSize As UInteger
    Public AdapterObject As IntPtr
    Public MappedRegisterBase As IntPtr
    <MarshalAs(UnmanagedType.U1)> Public DeviceReady As Boolean
    Public DumpDevicePowerOn As IntPtr
    Public DumpDevicePowerOnContext As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class DUMP_POINTERS_VERSION(ctypes.Structure):
    _fields_ = [
        ("Version", wintypes.DWORD),
        ("Size", wintypes.DWORD),
    ]

class DUMP_POINTERS_EX(ctypes.Structure):
    _fields_ = [
        ("Header", DUMP_POINTERS_VERSION),
        ("DumpData", ctypes.c_void_p),
        ("CommonBufferVa", ctypes.c_void_p),
        ("CommonBufferSize", wintypes.DWORD),
        ("AllocateCommonBuffers", ctypes.c_byte),
        ("DeviceObject", ctypes.c_void_p),
        ("DriverList", ctypes.c_void_p),
        ("dwPortFlags", wintypes.DWORD),
        ("MaxDeviceDumpSectionSize", wintypes.DWORD),
        ("MaxDeviceDumpLevel", wintypes.DWORD),
        ("MaxTransferSize", wintypes.DWORD),
        ("AdapterObject", ctypes.c_void_p),
        ("MappedRegisterBase", ctypes.c_void_p),
        ("DeviceReady", ctypes.c_void_p),
        ("DumpDevicePowerOn", ctypes.c_void_p),
        ("DumpDevicePowerOnContext", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct DUMP_POINTERS_VERSION {
    pub Version: u32,
    pub Size: u32,
}

#[repr(C)]
pub struct DUMP_POINTERS_EX {
    pub Header: DUMP_POINTERS_VERSION,
    pub DumpData: *mut core::ffi::c_void,
    pub CommonBufferVa: *mut core::ffi::c_void,
    pub CommonBufferSize: u32,
    pub AllocateCommonBuffers: u8,
    pub DeviceObject: *mut core::ffi::c_void,
    pub DriverList: *mut core::ffi::c_void,
    pub dwPortFlags: u32,
    pub MaxDeviceDumpSectionSize: u32,
    pub MaxDeviceDumpLevel: u32,
    pub MaxTransferSize: u32,
    pub AdapterObject: *mut core::ffi::c_void,
    pub MappedRegisterBase: *mut core::ffi::c_void,
    pub DeviceReady: *mut core::ffi::c_void,
    pub DumpDevicePowerOn: *mut core::ffi::c_void,
    pub DumpDevicePowerOnContext: *mut core::ffi::c_void,
}

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

type DUMP_POINTERS_VERSION struct {
	Version uint32
	Size uint32
}

type DUMP_POINTERS_EX struct {
	Header DUMP_POINTERS_VERSION
	DumpData uintptr
	CommonBufferVa uintptr
	CommonBufferSize uint32
	AllocateCommonBuffers byte
	DeviceObject uintptr
	DriverList uintptr
	dwPortFlags uint32
	MaxDeviceDumpSectionSize uint32
	MaxDeviceDumpLevel uint32
	MaxTransferSize uint32
	AdapterObject uintptr
	MappedRegisterBase uintptr
	DeviceReady uintptr
	DumpDevicePowerOn uintptr
	DumpDevicePowerOnContext uintptr
}

type
  DUMP_POINTERS_VERSION = record
    Version: DWORD;
    Size: DWORD;
  end;

  DUMP_POINTERS_EX = record
    Header: DUMP_POINTERS_VERSION;
    DumpData: Pointer;
    CommonBufferVa: Pointer;
    CommonBufferSize: DWORD;
    AllocateCommonBuffers: ByteBool;
    DeviceObject: Pointer;
    DriverList: Pointer;
    dwPortFlags: DWORD;
    MaxDeviceDumpSectionSize: DWORD;
    MaxDeviceDumpLevel: DWORD;
    MaxTransferSize: DWORD;
    AdapterObject: Pointer;
    MappedRegisterBase: Pointer;
    DeviceReady: Pointer;
    DumpDevicePowerOn: Pointer;
    DumpDevicePowerOnContext: Pointer;
  end;

const DUMP_POINTERS_VERSION = extern struct {
    Version: u32,
    Size: u32,
};

const DUMP_POINTERS_EX = extern struct {
    Header: DUMP_POINTERS_VERSION,
    DumpData: ?*anyopaque,
    CommonBufferVa: ?*anyopaque,
    CommonBufferSize: u32,
    AllocateCommonBuffers: u8,
    DeviceObject: ?*anyopaque,
    DriverList: ?*anyopaque,
    dwPortFlags: u32,
    MaxDeviceDumpSectionSize: u32,
    MaxDeviceDumpLevel: u32,
    MaxTransferSize: u32,
    AdapterObject: ?*anyopaque,
    MappedRegisterBase: ?*anyopaque,
    DeviceReady: ?*anyopaque,
    DumpDevicePowerOn: ?*anyopaque,
    DumpDevicePowerOnContext: ?*anyopaque,
};

type
  DUMP_POINTERS_VERSION {.bycopy.} = object
    Version: uint32
    Size: uint32

  DUMP_POINTERS_EX {.bycopy.} = object
    Header: DUMP_POINTERS_VERSION
    DumpData: pointer
    CommonBufferVa: pointer
    CommonBufferSize: uint32
    AllocateCommonBuffers: uint8
    DeviceObject: pointer
    DriverList: pointer
    dwPortFlags: uint32
    MaxDeviceDumpSectionSize: uint32
    MaxDeviceDumpLevel: uint32
    MaxTransferSize: uint32
    AdapterObject: pointer
    MappedRegisterBase: pointer
    DeviceReady: pointer
    DumpDevicePowerOn: pointer
    DumpDevicePowerOnContext: pointer

struct DUMP_POINTERS_VERSION
{
    uint Version;
    uint Size;
}

struct DUMP_POINTERS_EX
{
    DUMP_POINTERS_VERSION Header;
    void* DumpData;
    void* CommonBufferVa;
    uint CommonBufferSize;
    ubyte AllocateCommonBuffers;
    void* DeviceObject;
    void* DriverList;
    uint dwPortFlags;
    uint MaxDeviceDumpSectionSize;
    uint MaxDeviceDumpLevel;
    uint MaxTransferSize;
    void* AdapterObject;
    void* MappedRegisterBase;
    void* DeviceReady;
    void* DumpDevicePowerOn;
    void* DumpDevicePowerOnContext;
}