VMRMONITORINFO

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VMRGUID
{
    public IntPtr pGUID;
    public Guid GUID;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RECT
{
    public int left;
    public int top;
    public int right;
    public int bottom;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VMRMONITORINFO
{
    public VMRGUID guid;
    public RECT rcMonitor;
    public IntPtr hMon;
    public uint dwFlags;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] public string szDevice;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string szDescription;
    public long liDriverVersion;
    public uint dwVendorId;
    public uint dwDeviceId;
    public uint dwSubSysId;
    public uint dwRevision;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure VMRGUID
    Public pGUID As IntPtr
    Public GUID As Guid
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RECT
    Public left As Integer
    Public top As Integer
    Public right As Integer
    Public bottom As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure VMRMONITORINFO
    Public guid As VMRGUID
    Public rcMonitor As RECT
    Public hMon As IntPtr
    Public dwFlags As UInteger
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=32)> Public szDevice As String
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=256)> Public szDescription As String
    Public liDriverVersion As Long
    Public dwVendorId As UInteger
    Public dwDeviceId As UInteger
    Public dwSubSysId As UInteger
    Public dwRevision As UInteger
End Structure

import ctypes
from ctypes import wintypes

class VMRGUID(ctypes.Structure):
    _fields_ = [
        ("pGUID", ctypes.c_void_p),
        ("GUID", GUID),
    ]

class RECT(ctypes.Structure):
    _fields_ = [
        ("left", ctypes.c_int),
        ("top", ctypes.c_int),
        ("right", ctypes.c_int),
        ("bottom", ctypes.c_int),
    ]

class VMRMONITORINFO(ctypes.Structure):
    _fields_ = [
        ("guid", VMRGUID),
        ("rcMonitor", RECT),
        ("hMon", ctypes.c_void_p),
        ("dwFlags", wintypes.DWORD),
        ("szDevice", ctypes.c_wchar * 32),
        ("szDescription", ctypes.c_wchar * 256),
        ("liDriverVersion", ctypes.c_longlong),
        ("dwVendorId", wintypes.DWORD),
        ("dwDeviceId", wintypes.DWORD),
        ("dwSubSysId", wintypes.DWORD),
        ("dwRevision", wintypes.DWORD),
    ]

#[repr(C)]
pub struct VMRGUID {
    pub pGUID: *mut core::ffi::c_void,
    pub GUID: GUID,
}

#[repr(C)]
pub struct RECT {
    pub left: i32,
    pub top: i32,
    pub right: i32,
    pub bottom: i32,
}

#[repr(C)]
pub struct VMRMONITORINFO {
    pub guid: VMRGUID,
    pub rcMonitor: RECT,
    pub hMon: *mut core::ffi::c_void,
    pub dwFlags: u32,
    pub szDevice: [u16; 32],
    pub szDescription: [u16; 256],
    pub liDriverVersion: i64,
    pub dwVendorId: u32,
    pub dwDeviceId: u32,
    pub dwSubSysId: u32,
    pub dwRevision: u32,
}

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

type VMRGUID struct {
	pGUID uintptr
	GUID windows.GUID
}

type RECT struct {
	left int32
	top int32
	right int32
	bottom int32
}

type VMRMONITORINFO struct {
	guid VMRGUID
	rcMonitor RECT
	hMon uintptr
	dwFlags uint32
	szDevice [32]uint16
	szDescription [256]uint16
	liDriverVersion int64
	dwVendorId uint32
	dwDeviceId uint32
	dwSubSysId uint32
	dwRevision uint32
}

type
  VMRGUID = record
    pGUID: Pointer;
    GUID: TGUID;
  end;

  RECT = record
    left: Integer;
    top: Integer;
    right: Integer;
    bottom: Integer;
  end;

  VMRMONITORINFO = record
    guid: VMRGUID;
    rcMonitor: RECT;
    hMon: Pointer;
    dwFlags: DWORD;
    szDevice: array[0..31] of WideChar;
    szDescription: array[0..255] of WideChar;
    liDriverVersion: Int64;
    dwVendorId: DWORD;
    dwDeviceId: DWORD;
    dwSubSysId: DWORD;
    dwRevision: DWORD;
  end;

const VMRGUID = extern struct {
    pGUID: ?*anyopaque,
    GUID: GUID,
};

const RECT = extern struct {
    left: i32,
    top: i32,
    right: i32,
    bottom: i32,
};

const VMRMONITORINFO = extern struct {
    guid: VMRGUID,
    rcMonitor: RECT,
    hMon: ?*anyopaque,
    dwFlags: u32,
    szDevice: [32]u16,
    szDescription: [256]u16,
    liDriverVersion: i64,
    dwVendorId: u32,
    dwDeviceId: u32,
    dwSubSysId: u32,
    dwRevision: u32,
};

type
  VMRGUID {.bycopy.} = object
    pGUID: pointer
    GUID: GUID

  RECT {.bycopy.} = object
    left: int32
    top: int32
    right: int32
    bottom: int32

  VMRMONITORINFO {.bycopy.} = object
    guid: VMRGUID
    rcMonitor: RECT
    hMon: pointer
    dwFlags: uint32
    szDevice: array[32, uint16]
    szDescription: array[256, uint16]
    liDriverVersion: int64
    dwVendorId: uint32
    dwDeviceId: uint32
    dwSubSysId: uint32
    dwRevision: uint32

struct VMRGUID
{
    void* pGUID;
    GUID GUID;
}

struct RECT
{
    int left;
    int top;
    int right;
    int bottom;
}

struct VMRMONITORINFO
{
    VMRGUID guid;
    RECT rcMonitor;
    void* hMon;
    uint dwFlags;
    wchar[32] szDevice;
    wchar[256] szDescription;
    long liDriverVersion;
    uint dwVendorId;
    uint dwDeviceId;
    uint dwSubSysId;
    uint dwRevision;
}