RPC_ASYNC_STATE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_ASYNC_NOTIFICATION_INFO
{
    public _APC_e__Struct APC;
    public _IOC_e__Struct IOC;
    public _IntPtr_e__Struct IntPtr;
    public IntPtr hEvent;
    public IntPtr NotificationRoutine;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct RPC_ASYNC_STATE
{
    public uint Size;
    public uint Signature;
    public int Lock;
    public uint Flags;
    public IntPtr StubInfo;
    public IntPtr UserInfo;
    public IntPtr RuntimeInfo;
    public int Event;
    public int NotificationType;
    public RPC_ASYNC_NOTIFICATION_INFO u;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public IntPtr[] Reserved;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_ASYNC_NOTIFICATION_INFO
    Public APC As _APC_e__Struct
    Public IOC As _IOC_e__Struct
    Public IntPtr As _IntPtr_e__Struct
    Public hEvent As IntPtr
    Public NotificationRoutine As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure RPC_ASYNC_STATE
    Public Size As UInteger
    Public Signature As UInteger
    Public Lock As Integer
    Public Flags As UInteger
    Public StubInfo As IntPtr
    Public UserInfo As IntPtr
    Public RuntimeInfo As IntPtr
    Public Event As Integer
    Public NotificationType As Integer
    Public u As RPC_ASYNC_NOTIFICATION_INFO
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=4)> Public Reserved() As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class RPC_ASYNC_NOTIFICATION_INFO(ctypes.Structure):
    _fields_ = [
        ("APC", _APC_e__Struct),
        ("IOC", _IOC_e__Struct),
        ("IntPtr", _IntPtr_e__Struct),
        ("hEvent", ctypes.c_void_p),
        ("NotificationRoutine", ctypes.c_void_p),
    ]

class RPC_ASYNC_STATE(ctypes.Structure):
    _fields_ = [
        ("Size", wintypes.DWORD),
        ("Signature", wintypes.DWORD),
        ("Lock", ctypes.c_int),
        ("Flags", wintypes.DWORD),
        ("StubInfo", ctypes.c_void_p),
        ("UserInfo", ctypes.c_void_p),
        ("RuntimeInfo", ctypes.c_void_p),
        ("Event", ctypes.c_int),
        ("NotificationType", ctypes.c_int),
        ("u", RPC_ASYNC_NOTIFICATION_INFO),
        ("Reserved", ctypes.c_ssize_t * 4),
    ]

#[repr(C)]
pub struct RPC_ASYNC_NOTIFICATION_INFO {
    pub APC: _APC_e__Struct,
    pub IOC: _IOC_e__Struct,
    pub IntPtr: _IntPtr_e__Struct,
    pub hEvent: *mut core::ffi::c_void,
    pub NotificationRoutine: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct RPC_ASYNC_STATE {
    pub Size: u32,
    pub Signature: u32,
    pub Lock: i32,
    pub Flags: u32,
    pub StubInfo: *mut core::ffi::c_void,
    pub UserInfo: *mut core::ffi::c_void,
    pub RuntimeInfo: *mut core::ffi::c_void,
    pub Event: i32,
    pub NotificationType: i32,
    pub u: RPC_ASYNC_NOTIFICATION_INFO,
    pub Reserved: [isize; 4],
}

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

type RPC_ASYNC_NOTIFICATION_INFO struct {
	APC _APC_e__Struct
	IOC _IOC_e__Struct
	IntPtr _IntPtr_e__Struct
	hEvent uintptr
	NotificationRoutine uintptr
}

type RPC_ASYNC_STATE struct {
	Size uint32
	Signature uint32
	Lock int32
	Flags uint32
	StubInfo uintptr
	UserInfo uintptr
	RuntimeInfo uintptr
	Event int32
	NotificationType int32
	u RPC_ASYNC_NOTIFICATION_INFO
	Reserved [4]uintptr
}

type
  RPC_ASYNC_NOTIFICATION_INFO = record
    APC: _APC_e__Struct;
    IOC: _IOC_e__Struct;
    IntPtr: _IntPtr_e__Struct;
    hEvent: Pointer;
    NotificationRoutine: Pointer;
  end;

  RPC_ASYNC_STATE = record
    Size: DWORD;
    Signature: DWORD;
    Lock: Integer;
    Flags: DWORD;
    StubInfo: Pointer;
    UserInfo: Pointer;
    RuntimeInfo: Pointer;
    Event: Integer;
    NotificationType: Integer;
    u: RPC_ASYNC_NOTIFICATION_INFO;
    Reserved: array[0..3] of NativeInt;
  end;

const RPC_ASYNC_NOTIFICATION_INFO = extern struct {
    APC: _APC_e__Struct,
    IOC: _IOC_e__Struct,
    IntPtr: _IntPtr_e__Struct,
    hEvent: ?*anyopaque,
    NotificationRoutine: ?*anyopaque,
};

const RPC_ASYNC_STATE = extern struct {
    Size: u32,
    Signature: u32,
    Lock: i32,
    Flags: u32,
    StubInfo: ?*anyopaque,
    UserInfo: ?*anyopaque,
    RuntimeInfo: ?*anyopaque,
    Event: i32,
    NotificationType: i32,
    u: RPC_ASYNC_NOTIFICATION_INFO,
    Reserved: [4]isize,
};

type
  RPC_ASYNC_NOTIFICATION_INFO {.bycopy.} = object
    APC: _APC_e__Struct
    IOC: _IOC_e__Struct
    IntPtr: _IntPtr_e__Struct
    hEvent: pointer
    NotificationRoutine: pointer

  RPC_ASYNC_STATE {.bycopy.} = object
    Size: uint32
    Signature: uint32
    Lock: int32
    Flags: uint32
    StubInfo: pointer
    UserInfo: pointer
    RuntimeInfo: pointer
    Event: int32
    NotificationType: int32
    u: RPC_ASYNC_NOTIFICATION_INFO
    Reserved: array[4, int]

struct RPC_ASYNC_NOTIFICATION_INFO
{
    _APC_e__Struct APC;
    _IOC_e__Struct IOC;
    _IntPtr_e__Struct IntPtr;
    void* hEvent;
    void* NotificationRoutine;
}

struct RPC_ASYNC_STATE
{
    uint Size;
    uint Signature;
    int Lock;
    uint Flags;
    void* StubInfo;
    void* UserInfo;
    void* RuntimeInfo;
    int Event;
    int NotificationType;
    RPC_ASYNC_NOTIFICATION_INFO u;
    ptrdiff_t[4] Reserved;
}