SPPHRASERULE

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;
}

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

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),
    ]

#[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,
}

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
  SPPHRASERULE = record
    pszName: Pointer;
    ulId: DWORD;
    ulFirstElement: DWORD;
    ulCountOfElements: DWORD;
    pNextSibling: Pointer;
    pFirstChild: Pointer;
    SREngineConfidence: Single;
    Confidence: Shortint;
  end;

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

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

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