HDV_PCI_DEVICE_INTERFACE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct HDV_PCI_DEVICE_INTERFACE
{
    public int Version;
    public IntPtr Initialize;
    public IntPtr Teardown;
    public IntPtr SetConfiguration;
    public IntPtr GetDetails;
    public IntPtr Start;
    public IntPtr Stop;
    public IntPtr ReadConfigSpace;
    public IntPtr WriteConfigSpace;
    public IntPtr ReadInterceptedMemory;
    public IntPtr WriteInterceptedMemory;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure HDV_PCI_DEVICE_INTERFACE
    Public Version As Integer
    Public Initialize As IntPtr
    Public Teardown As IntPtr
    Public SetConfiguration As IntPtr
    Public GetDetails As IntPtr
    Public Start As IntPtr
    Public Stop As IntPtr
    Public ReadConfigSpace As IntPtr
    Public WriteConfigSpace As IntPtr
    Public ReadInterceptedMemory As IntPtr
    Public WriteInterceptedMemory As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class HDV_PCI_DEVICE_INTERFACE(ctypes.Structure):
    _fields_ = [
        ("Version", ctypes.c_int),
        ("Initialize", ctypes.c_void_p),
        ("Teardown", ctypes.c_void_p),
        ("SetConfiguration", ctypes.c_void_p),
        ("GetDetails", ctypes.c_void_p),
        ("Start", ctypes.c_void_p),
        ("Stop", ctypes.c_void_p),
        ("ReadConfigSpace", ctypes.c_void_p),
        ("WriteConfigSpace", ctypes.c_void_p),
        ("ReadInterceptedMemory", ctypes.c_void_p),
        ("WriteInterceptedMemory", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct HDV_PCI_DEVICE_INTERFACE {
    pub Version: i32,
    pub Initialize: *mut core::ffi::c_void,
    pub Teardown: *mut core::ffi::c_void,
    pub SetConfiguration: *mut core::ffi::c_void,
    pub GetDetails: *mut core::ffi::c_void,
    pub Start: *mut core::ffi::c_void,
    pub Stop: *mut core::ffi::c_void,
    pub ReadConfigSpace: *mut core::ffi::c_void,
    pub WriteConfigSpace: *mut core::ffi::c_void,
    pub ReadInterceptedMemory: *mut core::ffi::c_void,
    pub WriteInterceptedMemory: *mut core::ffi::c_void,
}

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

type HDV_PCI_DEVICE_INTERFACE struct {
	Version int32
	Initialize uintptr
	Teardown uintptr
	SetConfiguration uintptr
	GetDetails uintptr
	Start uintptr
	Stop uintptr
	ReadConfigSpace uintptr
	WriteConfigSpace uintptr
	ReadInterceptedMemory uintptr
	WriteInterceptedMemory uintptr
}

type
  HDV_PCI_DEVICE_INTERFACE = record
    Version: Integer;
    Initialize: Pointer;
    Teardown: Pointer;
    SetConfiguration: Pointer;
    GetDetails: Pointer;
    Start: Pointer;
    Stop: Pointer;
    ReadConfigSpace: Pointer;
    WriteConfigSpace: Pointer;
    ReadInterceptedMemory: Pointer;
    WriteInterceptedMemory: Pointer;
  end;

const HDV_PCI_DEVICE_INTERFACE = extern struct {
    Version: i32,
    Initialize: ?*anyopaque,
    Teardown: ?*anyopaque,
    SetConfiguration: ?*anyopaque,
    GetDetails: ?*anyopaque,
    Start: ?*anyopaque,
    Stop: ?*anyopaque,
    ReadConfigSpace: ?*anyopaque,
    WriteConfigSpace: ?*anyopaque,
    ReadInterceptedMemory: ?*anyopaque,
    WriteInterceptedMemory: ?*anyopaque,
};

type
  HDV_PCI_DEVICE_INTERFACE {.bycopy.} = object
    Version: int32
    Initialize: pointer
    Teardown: pointer
    SetConfiguration: pointer
    GetDetails: pointer
    Start: pointer
    Stop: pointer
    ReadConfigSpace: pointer
    WriteConfigSpace: pointer
    ReadInterceptedMemory: pointer
    WriteInterceptedMemory: pointer

struct HDV_PCI_DEVICE_INTERFACE
{
    int Version;
    void* Initialize;
    void* Teardown;
    void* SetConfiguration;
    void* GetDetails;
    void* Start;
    void* Stop;
    void* ReadConfigSpace;
    void* WriteConfigSpace;
    void* ReadInterceptedMemory;
    void* WriteInterceptedMemory;
}