MONCBSTRUCT

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SECURITY_QUALITY_OF_SERVICE
{
    public uint Length;
    public int ImpersonationLevel;
    public byte ContextTrackingMode;
    [MarshalAs(UnmanagedType.U1)] public bool EffectiveOnly;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CONVCONTEXT
{
    public uint cb;
    public uint wFlags;
    public uint wCountryID;
    public int iCodePage;
    public uint dwLangID;
    public uint dwSecurity;
    public SECURITY_QUALITY_OF_SERVICE qos;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct MONCBSTRUCT
{
    public uint cb;
    public uint dwTime;
    public IntPtr hTask;
    public uint dwRet;
    public uint wType;
    public uint wFmt;
    public IntPtr hConv;
    public IntPtr hsz1;
    public IntPtr hsz2;
    public IntPtr hData;
    public UIntPtr dwData1;
    public UIntPtr dwData2;
    public CONVCONTEXT cc;
    public uint cbData;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public uint[] Data;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SECURITY_QUALITY_OF_SERVICE
    Public Length As UInteger
    Public ImpersonationLevel As Integer
    Public ContextTrackingMode As Byte
    <MarshalAs(UnmanagedType.U1)> Public EffectiveOnly As Boolean
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CONVCONTEXT
    Public cb As UInteger
    Public wFlags As UInteger
    Public wCountryID As UInteger
    Public iCodePage As Integer
    Public dwLangID As UInteger
    Public dwSecurity As UInteger
    Public qos As SECURITY_QUALITY_OF_SERVICE
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure MONCBSTRUCT
    Public cb As UInteger
    Public dwTime As UInteger
    Public hTask As IntPtr
    Public dwRet As UInteger
    Public wType As UInteger
    Public wFmt As UInteger
    Public hConv As IntPtr
    Public hsz1 As IntPtr
    Public hsz2 As IntPtr
    Public hData As IntPtr
    Public dwData1 As UIntPtr
    Public dwData2 As UIntPtr
    Public cc As CONVCONTEXT
    Public cbData As UInteger
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=8)> Public Data() As UInteger
End Structure

import ctypes
from ctypes import wintypes

class SECURITY_QUALITY_OF_SERVICE(ctypes.Structure):
    _fields_ = [
        ("Length", wintypes.DWORD),
        ("ImpersonationLevel", ctypes.c_int),
        ("ContextTrackingMode", ctypes.c_ubyte),
        ("EffectiveOnly", ctypes.c_byte),
    ]

class CONVCONTEXT(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("wFlags", wintypes.DWORD),
        ("wCountryID", wintypes.DWORD),
        ("iCodePage", ctypes.c_int),
        ("dwLangID", wintypes.DWORD),
        ("dwSecurity", wintypes.DWORD),
        ("qos", SECURITY_QUALITY_OF_SERVICE),
    ]

class MONCBSTRUCT(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("dwTime", wintypes.DWORD),
        ("hTask", ctypes.c_void_p),
        ("dwRet", wintypes.DWORD),
        ("wType", wintypes.DWORD),
        ("wFmt", wintypes.DWORD),
        ("hConv", ctypes.c_void_p),
        ("hsz1", ctypes.c_void_p),
        ("hsz2", ctypes.c_void_p),
        ("hData", ctypes.c_void_p),
        ("dwData1", ctypes.c_size_t),
        ("dwData2", ctypes.c_size_t),
        ("cc", CONVCONTEXT),
        ("cbData", wintypes.DWORD),
        ("Data", wintypes.DWORD * 8),
    ]

#[repr(C)]
pub struct SECURITY_QUALITY_OF_SERVICE {
    pub Length: u32,
    pub ImpersonationLevel: i32,
    pub ContextTrackingMode: u8,
    pub EffectiveOnly: u8,
}

#[repr(C)]
pub struct CONVCONTEXT {
    pub cb: u32,
    pub wFlags: u32,
    pub wCountryID: u32,
    pub iCodePage: i32,
    pub dwLangID: u32,
    pub dwSecurity: u32,
    pub qos: SECURITY_QUALITY_OF_SERVICE,
}

#[repr(C)]
pub struct MONCBSTRUCT {
    pub cb: u32,
    pub dwTime: u32,
    pub hTask: *mut core::ffi::c_void,
    pub dwRet: u32,
    pub wType: u32,
    pub wFmt: u32,
    pub hConv: *mut core::ffi::c_void,
    pub hsz1: *mut core::ffi::c_void,
    pub hsz2: *mut core::ffi::c_void,
    pub hData: *mut core::ffi::c_void,
    pub dwData1: usize,
    pub dwData2: usize,
    pub cc: CONVCONTEXT,
    pub cbData: u32,
    pub Data: [u32; 8],
}

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

type SECURITY_QUALITY_OF_SERVICE struct {
	Length uint32
	ImpersonationLevel int32
	ContextTrackingMode byte
	EffectiveOnly byte
}

type CONVCONTEXT struct {
	cb uint32
	wFlags uint32
	wCountryID uint32
	iCodePage int32
	dwLangID uint32
	dwSecurity uint32
	qos SECURITY_QUALITY_OF_SERVICE
}

type MONCBSTRUCT struct {
	cb uint32
	dwTime uint32
	hTask uintptr
	dwRet uint32
	wType uint32
	wFmt uint32
	hConv uintptr
	hsz1 uintptr
	hsz2 uintptr
	hData uintptr
	dwData1 uintptr
	dwData2 uintptr
	cc CONVCONTEXT
	cbData uint32
	Data [8]uint32
}

type
  SECURITY_QUALITY_OF_SERVICE = record
    Length: DWORD;
    ImpersonationLevel: Integer;
    ContextTrackingMode: Byte;
    EffectiveOnly: ByteBool;
  end;

  CONVCONTEXT = record
    cb: DWORD;
    wFlags: DWORD;
    wCountryID: DWORD;
    iCodePage: Integer;
    dwLangID: DWORD;
    dwSecurity: DWORD;
    qos: SECURITY_QUALITY_OF_SERVICE;
  end;

  MONCBSTRUCT = record
    cb: DWORD;
    dwTime: DWORD;
    hTask: Pointer;
    dwRet: DWORD;
    wType: DWORD;
    wFmt: DWORD;
    hConv: Pointer;
    hsz1: Pointer;
    hsz2: Pointer;
    hData: Pointer;
    dwData1: NativeUInt;
    dwData2: NativeUInt;
    cc: CONVCONTEXT;
    cbData: DWORD;
    Data: array[0..7] of DWORD;
  end;

const SECURITY_QUALITY_OF_SERVICE = extern struct {
    Length: u32,
    ImpersonationLevel: i32,
    ContextTrackingMode: u8,
    EffectiveOnly: u8,
};

const CONVCONTEXT = extern struct {
    cb: u32,
    wFlags: u32,
    wCountryID: u32,
    iCodePage: i32,
    dwLangID: u32,
    dwSecurity: u32,
    qos: SECURITY_QUALITY_OF_SERVICE,
};

const MONCBSTRUCT = extern struct {
    cb: u32,
    dwTime: u32,
    hTask: ?*anyopaque,
    dwRet: u32,
    wType: u32,
    wFmt: u32,
    hConv: ?*anyopaque,
    hsz1: ?*anyopaque,
    hsz2: ?*anyopaque,
    hData: ?*anyopaque,
    dwData1: usize,
    dwData2: usize,
    cc: CONVCONTEXT,
    cbData: u32,
    Data: [8]u32,
};

type
  SECURITY_QUALITY_OF_SERVICE {.bycopy.} = object
    Length: uint32
    ImpersonationLevel: int32
    ContextTrackingMode: uint8
    EffectiveOnly: uint8

  CONVCONTEXT {.bycopy.} = object
    cb: uint32
    wFlags: uint32
    wCountryID: uint32
    iCodePage: int32
    dwLangID: uint32
    dwSecurity: uint32
    qos: SECURITY_QUALITY_OF_SERVICE

  MONCBSTRUCT {.bycopy.} = object
    cb: uint32
    dwTime: uint32
    hTask: pointer
    dwRet: uint32
    wType: uint32
    wFmt: uint32
    hConv: pointer
    hsz1: pointer
    hsz2: pointer
    hData: pointer
    dwData1: uint
    dwData2: uint
    cc: CONVCONTEXT
    cbData: uint32
    Data: array[8, uint32]

struct SECURITY_QUALITY_OF_SERVICE
{
    uint Length;
    int ImpersonationLevel;
    ubyte ContextTrackingMode;
    ubyte EffectiveOnly;
}

struct CONVCONTEXT
{
    uint cb;
    uint wFlags;
    uint wCountryID;
    int iCodePage;
    uint dwLangID;
    uint dwSecurity;
    SECURITY_QUALITY_OF_SERVICE qos;
}

struct MONCBSTRUCT
{
    uint cb;
    uint dwTime;
    void* hTask;
    uint dwRet;
    uint wType;
    uint wFmt;
    void* hConv;
    void* hsz1;
    void* hsz2;
    void* hData;
    size_t dwData1;
    size_t dwData2;
    CONVCONTEXT cc;
    uint cbData;
    uint[8] Data;
}