WINBIO_SENSOR_INTERFACE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WINBIO_ADAPTER_INTERFACE_VERSION
{
    public ushort MajorVersion;
    public ushort MinorVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct WINBIO_SENSOR_INTERFACE
{
    public WINBIO_ADAPTER_INTERFACE_VERSION Version;
    public uint Type;
    public UIntPtr Size;
    public Guid AdapterId;
    public IntPtr Attach;
    public IntPtr Detach;
    public IntPtr ClearContext;
    public IntPtr QueryStatus;
    public IntPtr Reset;
    public IntPtr SetMode;
    public IntPtr SetIndicatorStatus;
    public IntPtr GetIndicatorStatus;
    public IntPtr StartCapture;
    public IntPtr FinishCapture;
    public IntPtr ExportSensorData;
    public IntPtr Cancel;
    public IntPtr PushDataToEngine;
    public IntPtr ControlUnit;
    public IntPtr ControlUnitPrivileged;
    public IntPtr NotifyPowerChange;
    public IntPtr PipelineInit;
    public IntPtr PipelineCleanup;
    public IntPtr Activate;
    public IntPtr Deactivate;
    public IntPtr QueryExtendedInfo;
    public IntPtr QueryCalibrationFormats;
    public IntPtr SetCalibrationFormat;
    public IntPtr AcceptCalibrationData;
    public IntPtr AsyncImportRawBuffer;
    public IntPtr AsyncImportSecureBuffer;
    public IntPtr QueryPrivateSensorType;
    public IntPtr ConnectSecure;
    public IntPtr StartCaptureEx;
    public IntPtr StartNotifyWake;
    public IntPtr FinishNotifyWake;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WINBIO_ADAPTER_INTERFACE_VERSION
    Public MajorVersion As UShort
    Public MinorVersion As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure WINBIO_SENSOR_INTERFACE
    Public Version As WINBIO_ADAPTER_INTERFACE_VERSION
    Public Type As UInteger
    Public Size As UIntPtr
    Public AdapterId As Guid
    Public Attach As IntPtr
    Public Detach As IntPtr
    Public ClearContext As IntPtr
    Public QueryStatus As IntPtr
    Public Reset As IntPtr
    Public SetMode As IntPtr
    Public SetIndicatorStatus As IntPtr
    Public GetIndicatorStatus As IntPtr
    Public StartCapture As IntPtr
    Public FinishCapture As IntPtr
    Public ExportSensorData As IntPtr
    Public Cancel As IntPtr
    Public PushDataToEngine As IntPtr
    Public ControlUnit As IntPtr
    Public ControlUnitPrivileged As IntPtr
    Public NotifyPowerChange As IntPtr
    Public PipelineInit As IntPtr
    Public PipelineCleanup As IntPtr
    Public Activate As IntPtr
    Public Deactivate As IntPtr
    Public QueryExtendedInfo As IntPtr
    Public QueryCalibrationFormats As IntPtr
    Public SetCalibrationFormat As IntPtr
    Public AcceptCalibrationData As IntPtr
    Public AsyncImportRawBuffer As IntPtr
    Public AsyncImportSecureBuffer As IntPtr
    Public QueryPrivateSensorType As IntPtr
    Public ConnectSecure As IntPtr
    Public StartCaptureEx As IntPtr
    Public StartNotifyWake As IntPtr
    Public FinishNotifyWake As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class WINBIO_ADAPTER_INTERFACE_VERSION(ctypes.Structure):
    _fields_ = [
        ("MajorVersion", ctypes.c_ushort),
        ("MinorVersion", ctypes.c_ushort),
    ]

class WINBIO_SENSOR_INTERFACE(ctypes.Structure):
    _fields_ = [
        ("Version", WINBIO_ADAPTER_INTERFACE_VERSION),
        ("Type", wintypes.DWORD),
        ("Size", ctypes.c_size_t),
        ("AdapterId", GUID),
        ("Attach", ctypes.c_void_p),
        ("Detach", ctypes.c_void_p),
        ("ClearContext", ctypes.c_void_p),
        ("QueryStatus", ctypes.c_void_p),
        ("Reset", ctypes.c_void_p),
        ("SetMode", ctypes.c_void_p),
        ("SetIndicatorStatus", ctypes.c_void_p),
        ("GetIndicatorStatus", ctypes.c_void_p),
        ("StartCapture", ctypes.c_void_p),
        ("FinishCapture", ctypes.c_void_p),
        ("ExportSensorData", ctypes.c_void_p),
        ("Cancel", ctypes.c_void_p),
        ("PushDataToEngine", ctypes.c_void_p),
        ("ControlUnit", ctypes.c_void_p),
        ("ControlUnitPrivileged", ctypes.c_void_p),
        ("NotifyPowerChange", ctypes.c_void_p),
        ("PipelineInit", ctypes.c_void_p),
        ("PipelineCleanup", ctypes.c_void_p),
        ("Activate", ctypes.c_void_p),
        ("Deactivate", ctypes.c_void_p),
        ("QueryExtendedInfo", ctypes.c_void_p),
        ("QueryCalibrationFormats", ctypes.c_void_p),
        ("SetCalibrationFormat", ctypes.c_void_p),
        ("AcceptCalibrationData", ctypes.c_void_p),
        ("AsyncImportRawBuffer", ctypes.c_void_p),
        ("AsyncImportSecureBuffer", ctypes.c_void_p),
        ("QueryPrivateSensorType", ctypes.c_void_p),
        ("ConnectSecure", ctypes.c_void_p),
        ("StartCaptureEx", ctypes.c_void_p),
        ("StartNotifyWake", ctypes.c_void_p),
        ("FinishNotifyWake", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct WINBIO_ADAPTER_INTERFACE_VERSION {
    pub MajorVersion: u16,
    pub MinorVersion: u16,
}

#[repr(C)]
pub struct WINBIO_SENSOR_INTERFACE {
    pub Version: WINBIO_ADAPTER_INTERFACE_VERSION,
    pub Type: u32,
    pub Size: usize,
    pub AdapterId: GUID,
    pub Attach: *mut core::ffi::c_void,
    pub Detach: *mut core::ffi::c_void,
    pub ClearContext: *mut core::ffi::c_void,
    pub QueryStatus: *mut core::ffi::c_void,
    pub Reset: *mut core::ffi::c_void,
    pub SetMode: *mut core::ffi::c_void,
    pub SetIndicatorStatus: *mut core::ffi::c_void,
    pub GetIndicatorStatus: *mut core::ffi::c_void,
    pub StartCapture: *mut core::ffi::c_void,
    pub FinishCapture: *mut core::ffi::c_void,
    pub ExportSensorData: *mut core::ffi::c_void,
    pub Cancel: *mut core::ffi::c_void,
    pub PushDataToEngine: *mut core::ffi::c_void,
    pub ControlUnit: *mut core::ffi::c_void,
    pub ControlUnitPrivileged: *mut core::ffi::c_void,
    pub NotifyPowerChange: *mut core::ffi::c_void,
    pub PipelineInit: *mut core::ffi::c_void,
    pub PipelineCleanup: *mut core::ffi::c_void,
    pub Activate: *mut core::ffi::c_void,
    pub Deactivate: *mut core::ffi::c_void,
    pub QueryExtendedInfo: *mut core::ffi::c_void,
    pub QueryCalibrationFormats: *mut core::ffi::c_void,
    pub SetCalibrationFormat: *mut core::ffi::c_void,
    pub AcceptCalibrationData: *mut core::ffi::c_void,
    pub AsyncImportRawBuffer: *mut core::ffi::c_void,
    pub AsyncImportSecureBuffer: *mut core::ffi::c_void,
    pub QueryPrivateSensorType: *mut core::ffi::c_void,
    pub ConnectSecure: *mut core::ffi::c_void,
    pub StartCaptureEx: *mut core::ffi::c_void,
    pub StartNotifyWake: *mut core::ffi::c_void,
    pub FinishNotifyWake: *mut core::ffi::c_void,
}

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

type WINBIO_ADAPTER_INTERFACE_VERSION struct {
	MajorVersion uint16
	MinorVersion uint16
}

type WINBIO_SENSOR_INTERFACE struct {
	Version WINBIO_ADAPTER_INTERFACE_VERSION
	Type uint32
	Size uintptr
	AdapterId windows.GUID
	Attach uintptr
	Detach uintptr
	ClearContext uintptr
	QueryStatus uintptr
	Reset uintptr
	SetMode uintptr
	SetIndicatorStatus uintptr
	GetIndicatorStatus uintptr
	StartCapture uintptr
	FinishCapture uintptr
	ExportSensorData uintptr
	Cancel uintptr
	PushDataToEngine uintptr
	ControlUnit uintptr
	ControlUnitPrivileged uintptr
	NotifyPowerChange uintptr
	PipelineInit uintptr
	PipelineCleanup uintptr
	Activate uintptr
	Deactivate uintptr
	QueryExtendedInfo uintptr
	QueryCalibrationFormats uintptr
	SetCalibrationFormat uintptr
	AcceptCalibrationData uintptr
	AsyncImportRawBuffer uintptr
	AsyncImportSecureBuffer uintptr
	QueryPrivateSensorType uintptr
	ConnectSecure uintptr
	StartCaptureEx uintptr
	StartNotifyWake uintptr
	FinishNotifyWake uintptr
}

type
  WINBIO_ADAPTER_INTERFACE_VERSION = record
    MajorVersion: Word;
    MinorVersion: Word;
  end;

  WINBIO_SENSOR_INTERFACE = record
    Version: WINBIO_ADAPTER_INTERFACE_VERSION;
    Type: DWORD;
    Size: NativeUInt;
    AdapterId: TGUID;
    Attach: Pointer;
    Detach: Pointer;
    ClearContext: Pointer;
    QueryStatus: Pointer;
    Reset: Pointer;
    SetMode: Pointer;
    SetIndicatorStatus: Pointer;
    GetIndicatorStatus: Pointer;
    StartCapture: Pointer;
    FinishCapture: Pointer;
    ExportSensorData: Pointer;
    Cancel: Pointer;
    PushDataToEngine: Pointer;
    ControlUnit: Pointer;
    ControlUnitPrivileged: Pointer;
    NotifyPowerChange: Pointer;
    PipelineInit: Pointer;
    PipelineCleanup: Pointer;
    Activate: Pointer;
    Deactivate: Pointer;
    QueryExtendedInfo: Pointer;
    QueryCalibrationFormats: Pointer;
    SetCalibrationFormat: Pointer;
    AcceptCalibrationData: Pointer;
    AsyncImportRawBuffer: Pointer;
    AsyncImportSecureBuffer: Pointer;
    QueryPrivateSensorType: Pointer;
    ConnectSecure: Pointer;
    StartCaptureEx: Pointer;
    StartNotifyWake: Pointer;
    FinishNotifyWake: Pointer;
  end;

const WINBIO_ADAPTER_INTERFACE_VERSION = extern struct {
    MajorVersion: u16,
    MinorVersion: u16,
};

const WINBIO_SENSOR_INTERFACE = extern struct {
    Version: WINBIO_ADAPTER_INTERFACE_VERSION,
    Type: u32,
    Size: usize,
    AdapterId: GUID,
    Attach: ?*anyopaque,
    Detach: ?*anyopaque,
    ClearContext: ?*anyopaque,
    QueryStatus: ?*anyopaque,
    Reset: ?*anyopaque,
    SetMode: ?*anyopaque,
    SetIndicatorStatus: ?*anyopaque,
    GetIndicatorStatus: ?*anyopaque,
    StartCapture: ?*anyopaque,
    FinishCapture: ?*anyopaque,
    ExportSensorData: ?*anyopaque,
    Cancel: ?*anyopaque,
    PushDataToEngine: ?*anyopaque,
    ControlUnit: ?*anyopaque,
    ControlUnitPrivileged: ?*anyopaque,
    NotifyPowerChange: ?*anyopaque,
    PipelineInit: ?*anyopaque,
    PipelineCleanup: ?*anyopaque,
    Activate: ?*anyopaque,
    Deactivate: ?*anyopaque,
    QueryExtendedInfo: ?*anyopaque,
    QueryCalibrationFormats: ?*anyopaque,
    SetCalibrationFormat: ?*anyopaque,
    AcceptCalibrationData: ?*anyopaque,
    AsyncImportRawBuffer: ?*anyopaque,
    AsyncImportSecureBuffer: ?*anyopaque,
    QueryPrivateSensorType: ?*anyopaque,
    ConnectSecure: ?*anyopaque,
    StartCaptureEx: ?*anyopaque,
    StartNotifyWake: ?*anyopaque,
    FinishNotifyWake: ?*anyopaque,
};

type
  WINBIO_ADAPTER_INTERFACE_VERSION {.bycopy.} = object
    MajorVersion: uint16
    MinorVersion: uint16

  WINBIO_SENSOR_INTERFACE {.bycopy.} = object
    Version: WINBIO_ADAPTER_INTERFACE_VERSION
    Type: uint32
    Size: uint
    AdapterId: GUID
    Attach: pointer
    Detach: pointer
    ClearContext: pointer
    QueryStatus: pointer
    Reset: pointer
    SetMode: pointer
    SetIndicatorStatus: pointer
    GetIndicatorStatus: pointer
    StartCapture: pointer
    FinishCapture: pointer
    ExportSensorData: pointer
    Cancel: pointer
    PushDataToEngine: pointer
    ControlUnit: pointer
    ControlUnitPrivileged: pointer
    NotifyPowerChange: pointer
    PipelineInit: pointer
    PipelineCleanup: pointer
    Activate: pointer
    Deactivate: pointer
    QueryExtendedInfo: pointer
    QueryCalibrationFormats: pointer
    SetCalibrationFormat: pointer
    AcceptCalibrationData: pointer
    AsyncImportRawBuffer: pointer
    AsyncImportSecureBuffer: pointer
    QueryPrivateSensorType: pointer
    ConnectSecure: pointer
    StartCaptureEx: pointer
    StartNotifyWake: pointer
    FinishNotifyWake: pointer

struct WINBIO_ADAPTER_INTERFACE_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct WINBIO_SENSOR_INTERFACE
{
    WINBIO_ADAPTER_INTERFACE_VERSION Version;
    uint Type;
    size_t Size;
    GUID AdapterId;
    void* Attach;
    void* Detach;
    void* ClearContext;
    void* QueryStatus;
    void* Reset;
    void* SetMode;
    void* SetIndicatorStatus;
    void* GetIndicatorStatus;
    void* StartCapture;
    void* FinishCapture;
    void* ExportSensorData;
    void* Cancel;
    void* PushDataToEngine;
    void* ControlUnit;
    void* ControlUnitPrivileged;
    void* NotifyPowerChange;
    void* PipelineInit;
    void* PipelineCleanup;
    void* Activate;
    void* Deactivate;
    void* QueryExtendedInfo;
    void* QueryCalibrationFormats;
    void* SetCalibrationFormat;
    void* AcceptCalibrationData;
    void* AsyncImportRawBuffer;
    void* AsyncImportSecureBuffer;
    void* QueryPrivateSensorType;
    void* ConnectSecure;
    void* StartCaptureEx;
    void* StartNotifyWake;
    void* FinishNotifyWake;
}