ENPROTECTED

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct NMHDR
{
    public IntPtr hwndFrom;
    public UIntPtr idFrom;
    public uint code;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CHARRANGE
{
    public int cpMin;
    public int cpMax;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ENPROTECTED
{
    public NMHDR nmhdr;
    public uint msg;
    public UIntPtr wParam;
    public IntPtr lParam;
    public CHARRANGE chrg;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure NMHDR
    Public hwndFrom As IntPtr
    Public idFrom As UIntPtr
    Public code As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CHARRANGE
    Public cpMin As Integer
    Public cpMax As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ENPROTECTED
    Public nmhdr As NMHDR
    Public msg As UInteger
    Public wParam As UIntPtr
    Public lParam As IntPtr
    Public chrg As CHARRANGE
End Structure

import ctypes
from ctypes import wintypes

class NMHDR(ctypes.Structure):
    _fields_ = [
        ("hwndFrom", ctypes.c_void_p),
        ("idFrom", ctypes.c_size_t),
        ("code", wintypes.DWORD),
    ]

class CHARRANGE(ctypes.Structure):
    _fields_ = [
        ("cpMin", ctypes.c_int),
        ("cpMax", ctypes.c_int),
    ]

class ENPROTECTED(ctypes.Structure):
    _fields_ = [
        ("nmhdr", NMHDR),
        ("msg", wintypes.DWORD),
        ("wParam", ctypes.c_size_t),
        ("lParam", ctypes.c_ssize_t),
        ("chrg", CHARRANGE),
    ]

#[repr(C)]
pub struct NMHDR {
    pub hwndFrom: *mut core::ffi::c_void,
    pub idFrom: usize,
    pub code: u32,
}

#[repr(C)]
pub struct CHARRANGE {
    pub cpMin: i32,
    pub cpMax: i32,
}

#[repr(C)]
pub struct ENPROTECTED {
    pub nmhdr: NMHDR,
    pub msg: u32,
    pub wParam: usize,
    pub lParam: isize,
    pub chrg: CHARRANGE,
}

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

type NMHDR struct {
	hwndFrom uintptr
	idFrom uintptr
	code uint32
}

type CHARRANGE struct {
	cpMin int32
	cpMax int32
}

type ENPROTECTED struct {
	nmhdr NMHDR
	msg uint32
	wParam uintptr
	lParam uintptr
	chrg CHARRANGE
}

type
  NMHDR = record
    hwndFrom: Pointer;
    idFrom: NativeUInt;
    code: DWORD;
  end;

  CHARRANGE = record
    cpMin: Integer;
    cpMax: Integer;
  end;

  ENPROTECTED = record
    nmhdr: NMHDR;
    msg: DWORD;
    wParam: NativeUInt;
    lParam: NativeInt;
    chrg: CHARRANGE;
  end;

const NMHDR = extern struct {
    hwndFrom: ?*anyopaque,
    idFrom: usize,
    code: u32,
};

const CHARRANGE = extern struct {
    cpMin: i32,
    cpMax: i32,
};

const ENPROTECTED = extern struct {
    nmhdr: NMHDR,
    msg: u32,
    wParam: usize,
    lParam: isize,
    chrg: CHARRANGE,
};

type
  NMHDR {.bycopy.} = object
    hwndFrom: pointer
    idFrom: uint
    code: uint32

  CHARRANGE {.bycopy.} = object
    cpMin: int32
    cpMax: int32

  ENPROTECTED {.bycopy.} = object
    nmhdr: NMHDR
    msg: uint32
    wParam: uint
    lParam: int
    chrg: CHARRANGE

struct NMHDR
{
    void* hwndFrom;
    size_t idFrom;
    uint code;
}

struct CHARRANGE
{
    int cpMin;
    int cpMax;
}

struct ENPROTECTED
{
    NMHDR nmhdr;
    uint msg;
    size_t wParam;
    ptrdiff_t lParam;
    CHARRANGE chrg;
}