SPPATHENTRY

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPPHRASEELEMENT
{
    public uint ulAudioTimeOffset;
    public uint ulAudioSizeTime;
    public uint ulAudioStreamOffset;
    public uint ulAudioSizeBytes;
    public uint ulRetainedStreamOffset;
    public uint ulRetainedSizeBytes;
    public IntPtr pszDisplayText;
    public IntPtr pszLexicalForm;
    public IntPtr pszPronunciation;
    public byte bDisplayAttributes;
    public sbyte RequiredConfidence;
    public sbyte ActualConfidence;
    public byte Reserved;
    public float SREngineConfidence;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPPATHENTRY
{
    public IntPtr hTransition;
    public SPPHRASEELEMENT elem;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPPHRASEELEMENT
    Public ulAudioTimeOffset As UInteger
    Public ulAudioSizeTime As UInteger
    Public ulAudioStreamOffset As UInteger
    Public ulAudioSizeBytes As UInteger
    Public ulRetainedStreamOffset As UInteger
    Public ulRetainedSizeBytes As UInteger
    Public pszDisplayText As IntPtr
    Public pszLexicalForm As IntPtr
    Public pszPronunciation As IntPtr
    Public bDisplayAttributes As Byte
    Public RequiredConfidence As SByte
    Public ActualConfidence As SByte
    Public Reserved As Byte
    Public SREngineConfidence As Single
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPPATHENTRY
    Public hTransition As IntPtr
    Public elem As SPPHRASEELEMENT
End Structure

import ctypes
from ctypes import wintypes

class SPPHRASEELEMENT(ctypes.Structure):
    _fields_ = [
        ("ulAudioTimeOffset", wintypes.DWORD),
        ("ulAudioSizeTime", wintypes.DWORD),
        ("ulAudioStreamOffset", wintypes.DWORD),
        ("ulAudioSizeBytes", wintypes.DWORD),
        ("ulRetainedStreamOffset", wintypes.DWORD),
        ("ulRetainedSizeBytes", wintypes.DWORD),
        ("pszDisplayText", ctypes.c_void_p),
        ("pszLexicalForm", ctypes.c_void_p),
        ("pszPronunciation", ctypes.c_void_p),
        ("bDisplayAttributes", ctypes.c_ubyte),
        ("RequiredConfidence", ctypes.c_byte),
        ("ActualConfidence", ctypes.c_byte),
        ("Reserved", ctypes.c_ubyte),
        ("SREngineConfidence", ctypes.c_float),
    ]

class SPPATHENTRY(ctypes.Structure):
    _fields_ = [
        ("hTransition", ctypes.c_void_p),
        ("elem", SPPHRASEELEMENT),
    ]

#[repr(C)]
pub struct SPPHRASEELEMENT {
    pub ulAudioTimeOffset: u32,
    pub ulAudioSizeTime: u32,
    pub ulAudioStreamOffset: u32,
    pub ulAudioSizeBytes: u32,
    pub ulRetainedStreamOffset: u32,
    pub ulRetainedSizeBytes: u32,
    pub pszDisplayText: *mut core::ffi::c_void,
    pub pszLexicalForm: *mut core::ffi::c_void,
    pub pszPronunciation: *mut core::ffi::c_void,
    pub bDisplayAttributes: u8,
    pub RequiredConfidence: i8,
    pub ActualConfidence: i8,
    pub Reserved: u8,
    pub SREngineConfidence: f32,
}

#[repr(C)]
pub struct SPPATHENTRY {
    pub hTransition: *mut core::ffi::c_void,
    pub elem: SPPHRASEELEMENT,
}

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

type SPPHRASEELEMENT struct {
	ulAudioTimeOffset uint32
	ulAudioSizeTime uint32
	ulAudioStreamOffset uint32
	ulAudioSizeBytes uint32
	ulRetainedStreamOffset uint32
	ulRetainedSizeBytes uint32
	pszDisplayText uintptr
	pszLexicalForm uintptr
	pszPronunciation uintptr
	bDisplayAttributes byte
	RequiredConfidence int8
	ActualConfidence int8
	Reserved byte
	SREngineConfidence float32
}

type SPPATHENTRY struct {
	hTransition uintptr
	elem SPPHRASEELEMENT
}

type
  SPPHRASEELEMENT = record
    ulAudioTimeOffset: DWORD;
    ulAudioSizeTime: DWORD;
    ulAudioStreamOffset: DWORD;
    ulAudioSizeBytes: DWORD;
    ulRetainedStreamOffset: DWORD;
    ulRetainedSizeBytes: DWORD;
    pszDisplayText: Pointer;
    pszLexicalForm: Pointer;
    pszPronunciation: Pointer;
    bDisplayAttributes: Byte;
    RequiredConfidence: Shortint;
    ActualConfidence: Shortint;
    Reserved: Byte;
    SREngineConfidence: Single;
  end;

  SPPATHENTRY = record
    hTransition: Pointer;
    elem: SPPHRASEELEMENT;
  end;

const SPPHRASEELEMENT = extern struct {
    ulAudioTimeOffset: u32,
    ulAudioSizeTime: u32,
    ulAudioStreamOffset: u32,
    ulAudioSizeBytes: u32,
    ulRetainedStreamOffset: u32,
    ulRetainedSizeBytes: u32,
    pszDisplayText: ?*anyopaque,
    pszLexicalForm: ?*anyopaque,
    pszPronunciation: ?*anyopaque,
    bDisplayAttributes: u8,
    RequiredConfidence: i8,
    ActualConfidence: i8,
    Reserved: u8,
    SREngineConfidence: f32,
};

const SPPATHENTRY = extern struct {
    hTransition: ?*anyopaque,
    elem: SPPHRASEELEMENT,
};

type
  SPPHRASEELEMENT {.bycopy.} = object
    ulAudioTimeOffset: uint32
    ulAudioSizeTime: uint32
    ulAudioStreamOffset: uint32
    ulAudioSizeBytes: uint32
    ulRetainedStreamOffset: uint32
    ulRetainedSizeBytes: uint32
    pszDisplayText: pointer
    pszLexicalForm: pointer
    pszPronunciation: pointer
    bDisplayAttributes: uint8
    RequiredConfidence: int8
    ActualConfidence: int8
    Reserved: uint8
    SREngineConfidence: float32

  SPPATHENTRY {.bycopy.} = object
    hTransition: pointer
    elem: SPPHRASEELEMENT

struct SPPHRASEELEMENT
{
    uint ulAudioTimeOffset;
    uint ulAudioSizeTime;
    uint ulAudioStreamOffset;
    uint ulAudioSizeBytes;
    uint ulRetainedStreamOffset;
    uint ulRetainedSizeBytes;
    void* pszDisplayText;
    void* pszLexicalForm;
    void* pszPronunciation;
    ubyte bDisplayAttributes;
    byte RequiredConfidence;
    byte ActualConfidence;
    ubyte Reserved;
    float SREngineConfidence;
}

struct SPPATHENTRY
{
    void* hTransition;
    SPPHRASEELEMENT elem;
}