FH_OVERLAPPED

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FH_OVERLAPPED
{
    public UIntPtr Internal;
    public UIntPtr InternalHigh;
    public uint Offset;
    public uint OffsetHigh;
    public IntPtr hEvent;
    public IntPtr pfnCompletion;
    public UIntPtr Reserved1;
    public UIntPtr Reserved2;
    public UIntPtr Reserved3;
    public UIntPtr Reserved4;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FH_OVERLAPPED
    Public Internal As UIntPtr
    Public InternalHigh As UIntPtr
    Public Offset As UInteger
    Public OffsetHigh As UInteger
    Public hEvent As IntPtr
    Public pfnCompletion As IntPtr
    Public Reserved1 As UIntPtr
    Public Reserved2 As UIntPtr
    Public Reserved3 As UIntPtr
    Public Reserved4 As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class FH_OVERLAPPED(ctypes.Structure):
    _fields_ = [
        ("Internal", ctypes.c_size_t),
        ("InternalHigh", ctypes.c_size_t),
        ("Offset", wintypes.DWORD),
        ("OffsetHigh", wintypes.DWORD),
        ("hEvent", ctypes.c_void_p),
        ("pfnCompletion", ctypes.c_void_p),
        ("Reserved1", ctypes.c_size_t),
        ("Reserved2", ctypes.c_size_t),
        ("Reserved3", ctypes.c_size_t),
        ("Reserved4", ctypes.c_size_t),
    ]

#[repr(C)]
pub struct FH_OVERLAPPED {
    pub Internal: usize,
    pub InternalHigh: usize,
    pub Offset: u32,
    pub OffsetHigh: u32,
    pub hEvent: *mut core::ffi::c_void,
    pub pfnCompletion: *mut core::ffi::c_void,
    pub Reserved1: usize,
    pub Reserved2: usize,
    pub Reserved3: usize,
    pub Reserved4: usize,
}

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

type FH_OVERLAPPED struct {
	Internal uintptr
	InternalHigh uintptr
	Offset uint32
	OffsetHigh uint32
	hEvent uintptr
	pfnCompletion uintptr
	Reserved1 uintptr
	Reserved2 uintptr
	Reserved3 uintptr
	Reserved4 uintptr
}

type
  FH_OVERLAPPED = record
    Internal: NativeUInt;
    InternalHigh: NativeUInt;
    Offset: DWORD;
    OffsetHigh: DWORD;
    hEvent: Pointer;
    pfnCompletion: Pointer;
    Reserved1: NativeUInt;
    Reserved2: NativeUInt;
    Reserved3: NativeUInt;
    Reserved4: NativeUInt;
  end;

const FH_OVERLAPPED = extern struct {
    Internal: usize,
    InternalHigh: usize,
    Offset: u32,
    OffsetHigh: u32,
    hEvent: ?*anyopaque,
    pfnCompletion: ?*anyopaque,
    Reserved1: usize,
    Reserved2: usize,
    Reserved3: usize,
    Reserved4: usize,
};

type
  FH_OVERLAPPED {.bycopy.} = object
    Internal: uint
    InternalHigh: uint
    Offset: uint32
    OffsetHigh: uint32
    hEvent: pointer
    pfnCompletion: pointer
    Reserved1: uint
    Reserved2: uint
    Reserved3: uint
    Reserved4: uint

struct FH_OVERLAPPED
{
    size_t Internal;
    size_t InternalHigh;
    uint Offset;
    uint OffsetHigh;
    void* hEvent;
    void* pfnCompletion;
    size_t Reserved1;
    size_t Reserved2;
    size_t Reserved3;
    size_t Reserved4;
}