SPPHRASEPROPERTY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VARIANT
{
    public _Anonymous_e__Union Anonymous;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPPHRASEPROPERTY
{
    public IntPtr pszName;
    public _Anonymous_e__Union Anonymous;
    public IntPtr pszValue;
    public VARIANT vValue;
    public uint ulFirstElement;
    public uint ulCountOfElements;
    public IntPtr pNextSibling;
    public IntPtr pFirstChild;
    public float SREngineConfidence;
    public sbyte Confidence;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure VARIANT
    Public Anonymous As _Anonymous_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPPHRASEPROPERTY
    Public pszName As IntPtr
    Public Anonymous As _Anonymous_e__Union
    Public pszValue As IntPtr
    Public vValue As VARIANT
    Public ulFirstElement As UInteger
    Public ulCountOfElements As UInteger
    Public pNextSibling As IntPtr
    Public pFirstChild As IntPtr
    Public SREngineConfidence As Single
    Public Confidence As SByte
End Structure

import ctypes
from ctypes import wintypes

class VARIANT(ctypes.Structure):
    _fields_ = [
        ("Anonymous", _Anonymous_e__Union),
    ]

class SPPHRASEPROPERTY(ctypes.Structure):
    _fields_ = [
        ("pszName", ctypes.c_void_p),
        ("Anonymous", _Anonymous_e__Union),
        ("pszValue", ctypes.c_void_p),
        ("vValue", VARIANT),
        ("ulFirstElement", wintypes.DWORD),
        ("ulCountOfElements", wintypes.DWORD),
        ("pNextSibling", ctypes.c_void_p),
        ("pFirstChild", ctypes.c_void_p),
        ("SREngineConfidence", ctypes.c_float),
        ("Confidence", ctypes.c_byte),
    ]

#[repr(C)]
pub struct VARIANT {
    pub Anonymous: _Anonymous_e__Union,
}

#[repr(C)]
pub struct SPPHRASEPROPERTY {
    pub pszName: *mut core::ffi::c_void,
    pub Anonymous: _Anonymous_e__Union,
    pub pszValue: *mut core::ffi::c_void,
    pub vValue: VARIANT,
    pub ulFirstElement: u32,
    pub ulCountOfElements: u32,
    pub pNextSibling: *mut core::ffi::c_void,
    pub pFirstChild: *mut core::ffi::c_void,
    pub SREngineConfidence: f32,
    pub Confidence: i8,
}

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

type VARIANT struct {
	Anonymous _Anonymous_e__Union
}

type SPPHRASEPROPERTY struct {
	pszName uintptr
	Anonymous _Anonymous_e__Union
	pszValue uintptr
	vValue VARIANT
	ulFirstElement uint32
	ulCountOfElements uint32
	pNextSibling uintptr
	pFirstChild uintptr
	SREngineConfidence float32
	Confidence int8
}

type
  VARIANT = record
    Anonymous: _Anonymous_e__Union;
  end;

  SPPHRASEPROPERTY = record
    pszName: Pointer;
    Anonymous: _Anonymous_e__Union;
    pszValue: Pointer;
    vValue: VARIANT;
    ulFirstElement: DWORD;
    ulCountOfElements: DWORD;
    pNextSibling: Pointer;
    pFirstChild: Pointer;
    SREngineConfidence: Single;
    Confidence: Shortint;
  end;

const VARIANT = extern struct {
    Anonymous: _Anonymous_e__Union,
};

const SPPHRASEPROPERTY = extern struct {
    pszName: ?*anyopaque,
    Anonymous: _Anonymous_e__Union,
    pszValue: ?*anyopaque,
    vValue: VARIANT,
    ulFirstElement: u32,
    ulCountOfElements: u32,
    pNextSibling: ?*anyopaque,
    pFirstChild: ?*anyopaque,
    SREngineConfidence: f32,
    Confidence: i8,
};

type
  VARIANT {.bycopy.} = object
    Anonymous: _Anonymous_e__Union

  SPPHRASEPROPERTY {.bycopy.} = object
    pszName: pointer
    Anonymous: _Anonymous_e__Union
    pszValue: pointer
    vValue: VARIANT
    ulFirstElement: uint32
    ulCountOfElements: uint32
    pNextSibling: pointer
    pFirstChild: pointer
    SREngineConfidence: float32
    Confidence: int8

struct VARIANT
{
    _Anonymous_e__Union Anonymous;
}

struct SPPHRASEPROPERTY
{
    void* pszName;
    _Anonymous_e__Union Anonymous;
    void* pszValue;
    VARIANT vValue;
    uint ulFirstElement;
    uint ulCountOfElements;
    void* pNextSibling;
    void* pFirstChild;
    float SREngineConfidence;
    byte Confidence;
}