SPPHRASE_50

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPPHRASERULE
{
    public IntPtr pszName;
    public uint ulId;
    public uint ulFirstElement;
    public uint ulCountOfElements;
    public IntPtr pNextSibling;
    public IntPtr pFirstChild;
    public float SREngineConfidence;
    public sbyte Confidence;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SPPHRASE_50
{
    public uint cbSize;
    public ushort LangID;
    public ushort wHomophoneGroupId;
    public ulong ullGrammarID;
    public ulong ftStartTime;
    public ulong ullAudioStreamPosition;
    public uint ulAudioSizeBytes;
    public uint ulRetainedSizeBytes;
    public uint ulAudioSizeTime;
    public SPPHRASERULE Rule;
    public IntPtr pProperties;
    public IntPtr pElements;
    public uint cReplacements;
    public IntPtr pReplacements;
    public Guid SREngineID;
    public uint ulSREnginePrivateDataSize;
    public IntPtr pSREnginePrivateData;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPPHRASERULE
    Public pszName As IntPtr
    Public ulId As UInteger
    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

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SPPHRASE_50
    Public cbSize As UInteger
    Public LangID As UShort
    Public wHomophoneGroupId As UShort
    Public ullGrammarID As ULong
    Public ftStartTime As ULong
    Public ullAudioStreamPosition As ULong
    Public ulAudioSizeBytes As UInteger
    Public ulRetainedSizeBytes As UInteger
    Public ulAudioSizeTime As UInteger
    Public Rule As SPPHRASERULE
    Public pProperties As IntPtr
    Public pElements As IntPtr
    Public cReplacements As UInteger
    Public pReplacements As IntPtr
    Public SREngineID As Guid
    Public ulSREnginePrivateDataSize As UInteger
    Public pSREnginePrivateData As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class SPPHRASERULE(ctypes.Structure):
    _fields_ = [
        ("pszName", ctypes.c_void_p),
        ("ulId", wintypes.DWORD),
        ("ulFirstElement", wintypes.DWORD),
        ("ulCountOfElements", wintypes.DWORD),
        ("pNextSibling", ctypes.c_void_p),
        ("pFirstChild", ctypes.c_void_p),
        ("SREngineConfidence", ctypes.c_float),
        ("Confidence", ctypes.c_byte),
    ]

class SPPHRASE_50(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("LangID", ctypes.c_ushort),
        ("wHomophoneGroupId", ctypes.c_ushort),
        ("ullGrammarID", ctypes.c_ulonglong),
        ("ftStartTime", ctypes.c_ulonglong),
        ("ullAudioStreamPosition", ctypes.c_ulonglong),
        ("ulAudioSizeBytes", wintypes.DWORD),
        ("ulRetainedSizeBytes", wintypes.DWORD),
        ("ulAudioSizeTime", wintypes.DWORD),
        ("Rule", SPPHRASERULE),
        ("pProperties", ctypes.c_void_p),
        ("pElements", ctypes.c_void_p),
        ("cReplacements", wintypes.DWORD),
        ("pReplacements", ctypes.c_void_p),
        ("SREngineID", GUID),
        ("ulSREnginePrivateDataSize", wintypes.DWORD),
        ("pSREnginePrivateData", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct SPPHRASERULE {
    pub pszName: *mut core::ffi::c_void,
    pub ulId: u32,
    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,
}

#[repr(C)]
pub struct SPPHRASE_50 {
    pub cbSize: u32,
    pub LangID: u16,
    pub wHomophoneGroupId: u16,
    pub ullGrammarID: u64,
    pub ftStartTime: u64,
    pub ullAudioStreamPosition: u64,
    pub ulAudioSizeBytes: u32,
    pub ulRetainedSizeBytes: u32,
    pub ulAudioSizeTime: u32,
    pub Rule: SPPHRASERULE,
    pub pProperties: *mut core::ffi::c_void,
    pub pElements: *mut core::ffi::c_void,
    pub cReplacements: u32,
    pub pReplacements: *mut core::ffi::c_void,
    pub SREngineID: GUID,
    pub ulSREnginePrivateDataSize: u32,
    pub pSREnginePrivateData: *mut core::ffi::c_void,
}

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

type SPPHRASERULE struct {
	pszName uintptr
	ulId uint32
	ulFirstElement uint32
	ulCountOfElements uint32
	pNextSibling uintptr
	pFirstChild uintptr
	SREngineConfidence float32
	Confidence int8
}

type SPPHRASE_50 struct {
	cbSize uint32
	LangID uint16
	wHomophoneGroupId uint16
	ullGrammarID uint64
	ftStartTime uint64
	ullAudioStreamPosition uint64
	ulAudioSizeBytes uint32
	ulRetainedSizeBytes uint32
	ulAudioSizeTime uint32
	Rule SPPHRASERULE
	pProperties uintptr
	pElements uintptr
	cReplacements uint32
	pReplacements uintptr
	SREngineID windows.GUID
	ulSREnginePrivateDataSize uint32
	pSREnginePrivateData uintptr
}

type
  SPPHRASERULE = record
    pszName: Pointer;
    ulId: DWORD;
    ulFirstElement: DWORD;
    ulCountOfElements: DWORD;
    pNextSibling: Pointer;
    pFirstChild: Pointer;
    SREngineConfidence: Single;
    Confidence: Shortint;
  end;

  SPPHRASE_50 = record
    cbSize: DWORD;
    LangID: Word;
    wHomophoneGroupId: Word;
    ullGrammarID: UInt64;
    ftStartTime: UInt64;
    ullAudioStreamPosition: UInt64;
    ulAudioSizeBytes: DWORD;
    ulRetainedSizeBytes: DWORD;
    ulAudioSizeTime: DWORD;
    Rule: SPPHRASERULE;
    pProperties: Pointer;
    pElements: Pointer;
    cReplacements: DWORD;
    pReplacements: Pointer;
    SREngineID: TGUID;
    ulSREnginePrivateDataSize: DWORD;
    pSREnginePrivateData: Pointer;
  end;

const SPPHRASERULE = extern struct {
    pszName: ?*anyopaque,
    ulId: u32,
    ulFirstElement: u32,
    ulCountOfElements: u32,
    pNextSibling: ?*anyopaque,
    pFirstChild: ?*anyopaque,
    SREngineConfidence: f32,
    Confidence: i8,
};

const SPPHRASE_50 = extern struct {
    cbSize: u32,
    LangID: u16,
    wHomophoneGroupId: u16,
    ullGrammarID: u64,
    ftStartTime: u64,
    ullAudioStreamPosition: u64,
    ulAudioSizeBytes: u32,
    ulRetainedSizeBytes: u32,
    ulAudioSizeTime: u32,
    Rule: SPPHRASERULE,
    pProperties: ?*anyopaque,
    pElements: ?*anyopaque,
    cReplacements: u32,
    pReplacements: ?*anyopaque,
    SREngineID: GUID,
    ulSREnginePrivateDataSize: u32,
    pSREnginePrivateData: ?*anyopaque,
};

type
  SPPHRASERULE {.bycopy.} = object
    pszName: pointer
    ulId: uint32
    ulFirstElement: uint32
    ulCountOfElements: uint32
    pNextSibling: pointer
    pFirstChild: pointer
    SREngineConfidence: float32
    Confidence: int8

  SPPHRASE_50 {.bycopy.} = object
    cbSize: uint32
    LangID: uint16
    wHomophoneGroupId: uint16
    ullGrammarID: uint64
    ftStartTime: uint64
    ullAudioStreamPosition: uint64
    ulAudioSizeBytes: uint32
    ulRetainedSizeBytes: uint32
    ulAudioSizeTime: uint32
    Rule: SPPHRASERULE
    pProperties: pointer
    pElements: pointer
    cReplacements: uint32
    pReplacements: pointer
    SREngineID: GUID
    ulSREnginePrivateDataSize: uint32
    pSREnginePrivateData: pointer

struct SPPHRASERULE
{
    void* pszName;
    uint ulId;
    uint ulFirstElement;
    uint ulCountOfElements;
    void* pNextSibling;
    void* pFirstChild;
    float SREngineConfidence;
    byte Confidence;
}

struct SPPHRASE_50
{
    uint cbSize;
    ushort LangID;
    ushort wHomophoneGroupId;
    ulong ullGrammarID;
    ulong ftStartTime;
    ulong ullAudioStreamPosition;
    uint ulAudioSizeBytes;
    uint ulRetainedSizeBytes;
    uint ulAudioSizeTime;
    SPPHRASERULE Rule;
    void* pProperties;
    void* pElements;
    uint cReplacements;
    void* pReplacements;
    GUID SREngineID;
    uint ulSREnginePrivateDataSize;
    void* pSREnginePrivateData;
}