OPENCARDNAMEW

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct OPENCARDNAMEW
{
    public uint dwStructSize;
    public IntPtr hwndOwner;
    public UIntPtr hSCardContext;
    public IntPtr lpstrGroupNames;
    public uint nMaxGroupNames;
    public IntPtr lpstrCardNames;
    public uint nMaxCardNames;
    public IntPtr rgguidInterfaces;
    public uint cguidInterfaces;
    public IntPtr lpstrRdr;
    public uint nMaxRdr;
    public IntPtr lpstrCard;
    public uint nMaxCard;
    public IntPtr lpstrTitle;
    public uint dwFlags;
    public IntPtr pvUserData;
    public uint dwShareMode;
    public uint dwPreferredProtocols;
    public uint dwActiveProtocol;
    public IntPtr lpfnConnect;
    public IntPtr lpfnCheck;
    public IntPtr lpfnDisconnect;
    public UIntPtr hCardHandle;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure OPENCARDNAMEW
    Public dwStructSize As UInteger
    Public hwndOwner As IntPtr
    Public hSCardContext As UIntPtr
    Public lpstrGroupNames As IntPtr
    Public nMaxGroupNames As UInteger
    Public lpstrCardNames As IntPtr
    Public nMaxCardNames As UInteger
    Public rgguidInterfaces As IntPtr
    Public cguidInterfaces As UInteger
    Public lpstrRdr As IntPtr
    Public nMaxRdr As UInteger
    Public lpstrCard As IntPtr
    Public nMaxCard As UInteger
    Public lpstrTitle As IntPtr
    Public dwFlags As UInteger
    Public pvUserData As IntPtr
    Public dwShareMode As UInteger
    Public dwPreferredProtocols As UInteger
    Public dwActiveProtocol As UInteger
    Public lpfnConnect As IntPtr
    Public lpfnCheck As IntPtr
    Public lpfnDisconnect As IntPtr
    Public hCardHandle As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class OPENCARDNAMEW(ctypes.Structure):
    _fields_ = [
        ("dwStructSize", wintypes.DWORD),
        ("hwndOwner", ctypes.c_void_p),
        ("hSCardContext", ctypes.c_size_t),
        ("lpstrGroupNames", ctypes.c_void_p),
        ("nMaxGroupNames", wintypes.DWORD),
        ("lpstrCardNames", ctypes.c_void_p),
        ("nMaxCardNames", wintypes.DWORD),
        ("rgguidInterfaces", ctypes.c_void_p),
        ("cguidInterfaces", wintypes.DWORD),
        ("lpstrRdr", ctypes.c_void_p),
        ("nMaxRdr", wintypes.DWORD),
        ("lpstrCard", ctypes.c_void_p),
        ("nMaxCard", wintypes.DWORD),
        ("lpstrTitle", ctypes.c_void_p),
        ("dwFlags", wintypes.DWORD),
        ("pvUserData", ctypes.c_void_p),
        ("dwShareMode", wintypes.DWORD),
        ("dwPreferredProtocols", wintypes.DWORD),
        ("dwActiveProtocol", wintypes.DWORD),
        ("lpfnConnect", ctypes.c_void_p),
        ("lpfnCheck", ctypes.c_void_p),
        ("lpfnDisconnect", ctypes.c_void_p),
        ("hCardHandle", ctypes.c_size_t),
    ]

#[repr(C)]
pub struct OPENCARDNAMEW {
    pub dwStructSize: u32,
    pub hwndOwner: *mut core::ffi::c_void,
    pub hSCardContext: usize,
    pub lpstrGroupNames: *mut core::ffi::c_void,
    pub nMaxGroupNames: u32,
    pub lpstrCardNames: *mut core::ffi::c_void,
    pub nMaxCardNames: u32,
    pub rgguidInterfaces: *mut core::ffi::c_void,
    pub cguidInterfaces: u32,
    pub lpstrRdr: *mut core::ffi::c_void,
    pub nMaxRdr: u32,
    pub lpstrCard: *mut core::ffi::c_void,
    pub nMaxCard: u32,
    pub lpstrTitle: *mut core::ffi::c_void,
    pub dwFlags: u32,
    pub pvUserData: *mut core::ffi::c_void,
    pub dwShareMode: u32,
    pub dwPreferredProtocols: u32,
    pub dwActiveProtocol: u32,
    pub lpfnConnect: *mut core::ffi::c_void,
    pub lpfnCheck: *mut core::ffi::c_void,
    pub lpfnDisconnect: *mut core::ffi::c_void,
    pub hCardHandle: usize,
}

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

type OPENCARDNAMEW struct {
	dwStructSize uint32
	hwndOwner uintptr
	hSCardContext uintptr
	lpstrGroupNames uintptr
	nMaxGroupNames uint32
	lpstrCardNames uintptr
	nMaxCardNames uint32
	rgguidInterfaces uintptr
	cguidInterfaces uint32
	lpstrRdr uintptr
	nMaxRdr uint32
	lpstrCard uintptr
	nMaxCard uint32
	lpstrTitle uintptr
	dwFlags uint32
	pvUserData uintptr
	dwShareMode uint32
	dwPreferredProtocols uint32
	dwActiveProtocol uint32
	lpfnConnect uintptr
	lpfnCheck uintptr
	lpfnDisconnect uintptr
	hCardHandle uintptr
}

type
  OPENCARDNAMEW = record
    dwStructSize: DWORD;
    hwndOwner: Pointer;
    hSCardContext: NativeUInt;
    lpstrGroupNames: Pointer;
    nMaxGroupNames: DWORD;
    lpstrCardNames: Pointer;
    nMaxCardNames: DWORD;
    rgguidInterfaces: Pointer;
    cguidInterfaces: DWORD;
    lpstrRdr: Pointer;
    nMaxRdr: DWORD;
    lpstrCard: Pointer;
    nMaxCard: DWORD;
    lpstrTitle: Pointer;
    dwFlags: DWORD;
    pvUserData: Pointer;
    dwShareMode: DWORD;
    dwPreferredProtocols: DWORD;
    dwActiveProtocol: DWORD;
    lpfnConnect: Pointer;
    lpfnCheck: Pointer;
    lpfnDisconnect: Pointer;
    hCardHandle: NativeUInt;
  end;

const OPENCARDNAMEW = extern struct {
    dwStructSize: u32,
    hwndOwner: ?*anyopaque,
    hSCardContext: usize,
    lpstrGroupNames: ?*anyopaque,
    nMaxGroupNames: u32,
    lpstrCardNames: ?*anyopaque,
    nMaxCardNames: u32,
    rgguidInterfaces: ?*anyopaque,
    cguidInterfaces: u32,
    lpstrRdr: ?*anyopaque,
    nMaxRdr: u32,
    lpstrCard: ?*anyopaque,
    nMaxCard: u32,
    lpstrTitle: ?*anyopaque,
    dwFlags: u32,
    pvUserData: ?*anyopaque,
    dwShareMode: u32,
    dwPreferredProtocols: u32,
    dwActiveProtocol: u32,
    lpfnConnect: ?*anyopaque,
    lpfnCheck: ?*anyopaque,
    lpfnDisconnect: ?*anyopaque,
    hCardHandle: usize,
};

type
  OPENCARDNAMEW {.bycopy.} = object
    dwStructSize: uint32
    hwndOwner: pointer
    hSCardContext: uint
    lpstrGroupNames: pointer
    nMaxGroupNames: uint32
    lpstrCardNames: pointer
    nMaxCardNames: uint32
    rgguidInterfaces: pointer
    cguidInterfaces: uint32
    lpstrRdr: pointer
    nMaxRdr: uint32
    lpstrCard: pointer
    nMaxCard: uint32
    lpstrTitle: pointer
    dwFlags: uint32
    pvUserData: pointer
    dwShareMode: uint32
    dwPreferredProtocols: uint32
    dwActiveProtocol: uint32
    lpfnConnect: pointer
    lpfnCheck: pointer
    lpfnDisconnect: pointer
    hCardHandle: uint

struct OPENCARDNAMEW
{
    uint dwStructSize;
    void* hwndOwner;
    size_t hSCardContext;
    void* lpstrGroupNames;
    uint nMaxGroupNames;
    void* lpstrCardNames;
    uint nMaxCardNames;
    void* rgguidInterfaces;
    uint cguidInterfaces;
    void* lpstrRdr;
    uint nMaxRdr;
    void* lpstrCard;
    uint nMaxCard;
    void* lpstrTitle;
    uint dwFlags;
    void* pvUserData;
    uint dwShareMode;
    uint dwPreferredProtocols;
    uint dwActiveProtocol;
    void* lpfnConnect;
    void* lpfnCheck;
    void* lpfnDisconnect;
    size_t hCardHandle;
}