Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 651 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/sapiddk51.rs b/vendor/winapi/src/um/sapiddk51.rs
new file mode 100644
index 0000000..0607ceb
--- /dev/null
+++ b/vendor/winapi/src/um/sapiddk51.rs
@@ -0,0 +1,651 @@
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// All files in the project carrying such notice may not be copied, modified, or distributed
+// except according to those terms.
+use ctypes::{c_char, c_float, c_long, c_void};
+use shared::guiddef::{CLSID, GUID, IID, REFGUID};
+use shared::minwindef::{BOOL, BYTE, DWORD, ULONG, USHORT, WORD};
+use shared::mmreg::WAVEFORMATEX;
+use shared::windef::HWND;
+use um::oaidl::VARIANT;
+use um::objidlbase::IStream;
+use um::sapi::*;
+use um::unknwnbase::{IUnknown, IUnknownVtbl};
+use um::winnt::{HANDLE, HRESULT, LONG, LPCWSTR, LPWSTR, PVOID, ULONGLONG, WCHAR};
+pub const SPRECOEXTENSION: &'static str = "RecoExtension";
+pub const SPALTERNATESCLSID: &'static str = "AlternatesCLSID";
+RIDL!{#[uuid(0xf8e690f0, 0x39cb, 0x4843, 0xb8, 0xd7, 0xc8, 0x46, 0x96, 0xe1, 0x11, 0x9d)]
+interface ISpTokenUI(ISpTokenUIVtbl): IUnknown(IUnknownVtbl) {
+    fn IsUISupported(
+        pszTypeOfUI: LPCWSTR,
+        pvExtraData: *mut c_void,
+        cbExtraData: ULONG,
+        punkObject: *mut IUnknown,
+        pfSupported: *mut BOOL,
+    ) -> HRESULT,
+    fn DisplayUI(
+        hwndParent: HWND,
+        pszTitle: LPCWSTR,
+        pszTypeOfUI: LPCWSTR,
+        pvExtraData: *mut c_void,
+        cbExtraData: ULONG,
+        pToken: *mut ISpObjectToken,
+        punkObject: *mut IUnknown,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x06b64f9f, 0x7fda, 0x11d2, 0xb4, 0xf2, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
+interface ISpObjectTokenEnumBuilder(ISpObjectTokenEnumBuilderVtbl):
+    IEnumSpObjectTokens(IEnumSpObjectTokensVtbl) {
+    fn SetAttribs(
+        pszReqAttribs: LPCWSTR,
+        pszOptAttribs: LPCWSTR,
+    ) -> HRESULT,
+    fn AddTokens(
+        cTokens: ULONG,
+        pToken: *mut *mut ISpObjectToken,
+    ) -> HRESULT,
+    fn AddTokensFromDataKey(
+        pDataKey: *mut ISpDataKey,
+        pszSubKey: LPCWSTR,
+        pszCategoryId: LPCWSTR,
+    ) -> HRESULT,
+    fn AddTokensFromTokenEnum(
+        pTokenEnum: *mut IEnumSpObjectTokens,
+    ) -> HRESULT,
+    fn Sort(
+        pszTokenIdToListFirst: LPCWSTR,
+    ) -> HRESULT,
+}}
+DECLARE_HANDLE!{SPWORDHANDLE, SPWORDHANDLE__}
+DECLARE_HANDLE!{SPRULEHANDLE, SPRULEHANDLE__}
+DECLARE_HANDLE!{SPGRAMMARHANDLE, SPGRAMMARHANDLE__}
+DECLARE_HANDLE!{SPRECOCONTEXTHANDLE, SPRECOCONTEXTHANDLE__}
+DECLARE_HANDLE!{SPPHRASERULEHANDLE, SPPHRASERULEHANDLE__}
+DECLARE_HANDLE!{SPPHRASEPROPERTYHANDLE, SPPHRASEPROPERTYHANDLE__}
+DECLARE_HANDLE!{SPTRANSITIONID, SPTRANSITIONID__}
+RIDL!{#[uuid(0xf4711347, 0xe608, 0x11d2, 0xa0, 0x86, 0x00, 0xc0, 0x4f, 0x8e, 0xf9, 0xb5)]
+interface ISpErrorLog(ISpErrorLogVtbl): IUnknown(IUnknownVtbl) {
+    fn AddError(
+        lLineNumber: c_long,
+        hr: HRESULT,
+        pszDescription: LPCWSTR,
+        pszHelpFile: LPCWSTR,
+        dwHelpContext: DWORD,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xb1e29d58, 0xa675, 0x11d2, 0x83, 0x02, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpGrammarCompiler(ISpGrammarCompilerVtbl): IUnknown(IUnknownVtbl) {
+    fn CompileStream(
+        pSource: *mut IStream,
+        pDest: *mut IStream,
+        pHeader: *mut IStream,
+        pReserved: *mut IUnknown,
+        pErrorLog: *mut ISpErrorLog,
+        dwFlags: DWORD,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x3ddca27c, 0x665c, 0x4786, 0x9f, 0x97, 0x8c, 0x90, 0xc3, 0x48, 0x8b, 0x61)]
+interface ISpGramCompBackend(ISpGramCompBackendVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) {
+    fn SetSaveObjects(
+        pStream: *mut IStream,
+        pErrorLog: *mut ISpErrorLog,
+    ) -> HRESULT,
+    fn InitFromBinaryGrammar(
+        pBinaryData: *const SPBINARYGRAMMAR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x12d7360f, 0xa1c9, 0x11d3, 0xbc, 0x90, 0x00, 0xc0, 0x4f, 0x72, 0xdf, 0x9f)]
+interface ISpITNProcessor(ISpITNProcessorVtbl): IUnknown(IUnknownVtbl) {
+    fn LoadITNGrammar(
+        pszCLSID: LPWSTR,
+    ) -> HRESULT,
+    fn ITNPhrase(
+        pPhrase: *mut ISpPhraseBuilder,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0x88a3342a, 0x0bed, 0x4834, 0x92, 0x2b, 0x88, 0xd4, 0x31, 0x73, 0x16, 0x2f)]
+interface ISpPhraseBuilder(ISpPhraseBuilderVtbl): ISpPhrase(ISpPhraseVtbl) {
+    fn InitFromPhrase(
+        pPhrase: *const SPPHRASE,
+    ) -> HRESULT,
+    fn InitFromSerializedPhrase(
+        pPhrase: *const SPSERIALIZEDPHRASE,
+    ) -> HRESULT,
+    fn AddElements(
+        cElements: ULONG,
+        pElement: *const SPPHRASEELEMENT,
+    ) -> HRESULT,
+    fn AddRules(
+        hParent: SPPHRASERULEHANDLE,
+        pRule: *const SPPHRASERULE,
+        phNewRule: *mut SPPHRASERULEHANDLE,
+    ) -> HRESULT,
+    fn AddProperties(
+        hParent: SPPHRASEPROPERTYHANDLE,
+        pProperty: *const SPPHRASEPROPERTY,
+        phNewProperty: *mut SPPHRASEPROPERTYHANDLE,
+    ) -> HRESULT,
+    fn AddReplacements(
+        cReplacements: ULONG,
+        pReplacements: *const SPPHRASEREPLACEMENT,
+    ) -> HRESULT,
+}}
+pub type ISpTask = *mut c_void;
+pub type ISpThreadTask = *mut c_void;
+RIDL!{#[uuid(0xa6be4d73, 0x4403, 0x4358, 0xb2, 0x2d, 0x03, 0x46, 0xe2, 0x3b, 0x17, 0x64)]
+interface ISpThreadControl(ISpThreadControlVtbl): ISpNotifySink(ISpNotifySinkVtbl) {
+    fn StartThread(
+        dwFlags: DWORD,
+        phwnd: *mut HWND,
+    ) -> HRESULT,
+    fn WaitForThreadDone(
+        fForceStop: BOOL,
+        phrThreadResult: *mut HRESULT,
+        msTimeOut: ULONG,
+    ) -> HRESULT,
+    fn TerminateThread() -> HRESULT,
+    fn ThreadHandle() -> HANDLE,
+    fn ThreadId() -> DWORD,
+    fn NotifyEvent() -> HANDLE,
+    fn WindowHandle() -> HWND,
+    fn ThreadCompleteEvent() -> HANDLE,
+    fn ExitThreadEvent() -> HANDLE,
+}}
+STRUCT!{struct SPTMTHREADINFO {
+    lPoolSize: c_long,
+    lPriority: c_long,
+    ulConcurrencyLimit: ULONG,
+    ulMaxQuickAllocThreads: ULONG,
+}}
+RIDL!{#[uuid(0x2baeef81, 0x2ca3, 0x4331, 0x98, 0xf3, 0x26, 0xec, 0x5a, 0xbe, 0xfb, 0x03)]
+interface ISpTaskManager(ISpTaskManagerVtbl): IUnknown(IUnknownVtbl) {
+    fn SetThreadPoolInfo(
+        pPoolInfo: *const SPTMTHREADINFO,
+    ) -> HRESULT,
+    fn GetThreadPoolInfo(
+        pPoolInfo: *mut SPTMTHREADINFO,
+    ) -> HRESULT,
+    fn QueueTask(
+        pTask: *mut ISpTask,
+        pvTaskData: *mut c_void,
+        hCompEvent: HANDLE,
+        pdwGroupId: *mut DWORD,
+        pTaskID: *mut DWORD,
+    ) -> HRESULT,
+    fn CreateReoccurringTask(
+        pTask: *mut ISpTask,
+        pvTaskData: *mut c_void,
+        hCompEvent: HANDLE,
+        ppTaskCtrl: *mut *mut ISpNotifySink,
+    ) -> HRESULT,
+    fn CreateThreadControl(
+        pTask: *mut ISpThreadTask,
+        pvTaskData: *mut c_void,
+        nPriority: c_long,
+        ppTaskCtrl: *mut *mut ISpThreadControl,
+    ) -> HRESULT,
+    fn TerminateTask(
+        dwGroupId: DWORD,
+        ulWaitPeriod: ULONG,
+    ) -> HRESULT,
+}}
+ENUM!{enum SPVSKIPTYPE {
+    SPVST_SENTENCE = 1 << 0,
+}}
+ENUM!{enum SPVESACTIONS {
+    SPVES_CONTINUE = 0,
+    SPVES_ABORT = 1 << 0,
+    SPVES_SKIP = 1 << 1,
+    SPVES_RATE = 1 << 2,
+    SPVES_VOLUME = 1 << 3,
+}}
+RIDL!{#[uuid(0x9880499b, 0xcce9, 0x11d2, 0xb5, 0x03, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
+interface ISpTTSEngineSite(ISpTTSEngineSiteVtbl): ISpEventSink(ISpEventSinkVtbl) {
+    fn GetActions() -> DWORD,
+    fn Write(
+        pBuff: *const c_void,
+        cb: ULONG,
+        pcbWritten: *mut ULONG,
+    ) -> HRESULT,
+    fn GetRate(
+        pRateAdjust: *mut c_long,
+    ) -> HRESULT,
+    fn GetVolume(pusVolume: *mut USHORT,
+    ) -> HRESULT,
+    fn GetSkipInfo(
+        peType: *mut SPVSKIPTYPE,
+        plNumItems: *mut c_long,
+    ) -> HRESULT,
+    fn CompleteSkip(
+        ulNumSkipped: c_long,
+    ) -> HRESULT,
+}}
+STRUCT!{struct SPVTEXTFRAG {
+    pNext: *mut SPVTEXTFRAG,
+    State: SPVSTATE,
+    pTextStart: LPCWSTR,
+    ulTextLen: ULONG,
+    ulTextSrcOffset: ULONG,
+}}
+RIDL!{#[uuid(0xa74d7c8e, 0x4cc5, 0x4f2f, 0xa6, 0xeb, 0x80, 0x4d, 0xee, 0x18, 0x50, 0x0e)]
+interface ISpTTSEngine(ISpTTSEngineVtbl): IUnknown(IUnknownVtbl) {
+    fn Speak(
+        dwSpeakFlags: DWORD,
+        rguidFormatId: REFGUID,
+        pWaveFormatEx: *const WAVEFORMATEX,
+        pTextFragList: *const SPVTEXTFRAG,
+        pOutputSite: *mut ISpTTSEngineSite,
+    ) -> HRESULT,
+    fn GetOutputFormat(
+        pTargetFmtId: *const GUID,
+        pTargetWaveFormatEx: *const WAVEFORMATEX,
+        pOutputFormatId: *mut GUID,
+        ppCoMemOutputWaveFormatEx: *mut WAVEFORMATEX,
+    ) -> HRESULT,
+}}
+STRUCT!{struct SPWORDENTRY {
+    hWord: SPWORDHANDLE,
+    LangID: WORD,
+    pszDisplayText: *mut WCHAR,
+    pszLexicalForm: *mut WCHAR,
+    aPhoneId: *mut SPPHONEID,
+    pvClientContext: *mut c_void,
+}}
+STRUCT!{struct SPRULEENTRY {
+    hRule: SPRULEHANDLE,
+    hInitialState: SPSTATEHANDLE,
+    Attributes: DWORD,
+    pvClientRuleContext: *mut c_void,
+    pvClientGrammarContext: *mut c_void,
+}}
+ENUM!{enum SPTRANSITIONTYPE {
+    SPTRANSEPSILON = 0,
+    SPTRANSWORD,
+    SPTRANSRULE,
+    SPTRANSTEXTBUF,
+    SPTRANSWILDCARD,
+    SPTRANSDICTATION,
+}}
+STRUCT!{struct SPTRANSITIONENTRY_u_s1 {
+    hRuleInitialState: SPSTATEHANDLE,
+    hRule: SPRULEHANDLE,
+    pvClientRuleContext: *mut c_void,
+}}
+STRUCT!{struct SPTRANSITIONENTRY_u_s2 {
+    hWord: SPWORDHANDLE,
+    pvClientWordContext: *mut c_void,
+}}
+UNION!{union SPTRANSITIONENTRY_u {
+    [usize; 3],
+    s1 s1_mut: SPTRANSITIONENTRY_u_s1,
+    s2 s2_mut: SPTRANSITIONENTRY_u_s2,
+    pvGrammarCookie pvGrammarCookie_mut: *mut c_void,
+}}
+STRUCT!{struct SPTRANSITIONENTRY {
+    ID: SPTRANSITIONID,
+    hNextState: SPSTATEHANDLE,
+    Type: BYTE,
+    RequiredConfidence: c_char,
+    fHasProperty: DWORD,
+    Weight: c_float,
+    u: SPTRANSITIONENTRY_u,
+}}
+STRUCT!{struct SPTRANSITIONPROPERTY {
+    pszName: LPCWSTR,
+    ulId: ULONG,
+    pszValue: LPCWSTR,
+    vValue: VARIANT,
+}}
+STRUCT!{struct SPSTATEINFO {
+    cAllocatedEntries: ULONG,
+    pTransitions: *mut SPTRANSITIONENTRY,
+    cEpsilons: ULONG,
+    cRules: ULONG,
+    cWords: ULONG,
+    cSpecialTransitions: ULONG,
+}}
+STRUCT!{struct SPPATHENTRY {
+    hTransition: SPTRANSITIONID,
+    elem: SPPHRASEELEMENT,
+}}
+RIDL!{#[uuid(0x6a6ffad8, 0x78b6, 0x473d, 0xb8, 0x44, 0x98, 0x15, 0x2e, 0x4f, 0xb1, 0x6b)]
+interface ISpCFGInterpreterSite(ISpCFGInterpreterSiteVtbl): IUnknown(IUnknownVtbl) {
+    fn AddTextReplacement(
+        pReplace: *mut SPPHRASEREPLACEMENT,
+    ) -> HRESULT,
+    fn AddProperty(
+        pProperty: *const SPPHRASEPROPERTY,
+    ) -> HRESULT,
+    fn GetResourceValue(
+        pszResourceName: LPCWSTR,
+        ppCoMemResource: *mut LPWSTR,
+    ) -> HRESULT,
+}}
+RIDL!{#[uuid(0xf3d3f926, 0x11fc, 0x11d3, 0xbb, 0x97, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
+interface ISpCFGInterpreter(ISpCFGInterpreterVtbl): IUnknown(IUnknownVtbl) {
+    fn InitGrammar(
+        pszGrammarName: LPCWSTR,
+        pvGrammarData: *mut *const c_void,
+    ) -> HRESULT,
+    fn Interpret(
+        pPhrase: *mut ISpPhraseBuilder,
+        ulFirstElement: *const ULONG,
+        ulCountOfElements: *const ULONG,
+        pSite: *mut ISpCFGInterpreterSite,
+    ) -> HRESULT,
+}}
+ENUM!{enum SPCFGNOTIFY {
+    SPCFGN_ADD,
+    SPCFGN_REMOVE,
+    SPCFGN_INVALIDATE,
+    SPCFGN_ACTIVATE,
+    SPCFGN_DEACTIVATE,
+}}
+ENUM!{enum SPRESULTTYPE {
+    SPRT_CFG = 0,
+    SPRT_SLM = 1,
+    SPRT_PROPRIETARY = 2,
+    SPRT_FALSE_RECOGNITION = 1 << 2,
+}}
+STRUCT!{struct SPPHRASEALT {
+    pPhrase: *mut ISpPhraseBuilder,
+    ulStartElementInParent: ULONG,
+    cElementsInParent: ULONG,
+    cElementsInAlternate: ULONG,
+    pvAltExtra: *mut c_void,
+    cbAltExtra: ULONG,
+}}
+STRUCT!{struct SPRECORESULTINFO {
+    cbSize: ULONG,
+    eResultType: SPRESULTTYPE,
+    fHypothesis: BOOL,
+    fProprietaryAutoPause: BOOL,
+    ullStreamPosStart: ULONGLONG,
+    ullStreamPosEnd: ULONGLONG,
+    hGrammar: SPGRAMMARHANDLE,
+    ulSizeEngineData: ULONG,
+    pvEngineData: *mut c_void,
+    pPhrase: *mut ISpPhraseBuilder,
+    aPhraseAlts: *mut SPPHRASEALT,
+    ulNumAlts: ULONG,
+}}
+ENUM!{enum SPWORDINFOOPT {
+    SPWIO_NONE = 0,
+    SPWIO_WANT_TEXT = 1,
+}}
+ENUM!{enum SPRULEINFOOPT {
+    SPRIO_NONE = 0,
+}}
+STRUCT!{struct SPPARSEINFO {
+    cbSize: ULONG,
+    hRule: SPRULEHANDLE,
+    ullAudioStreamPosition: ULONGLONG,
+    ulAudioSize: ULONG,
+    cTransitions: ULONG,
+    pPath: *mut SPPATHENTRY,
+    SREngineID: GUID,
+    ulSREnginePrivateDataSize: ULONG,
+    pSREnginePrivateData: *const BYTE,
+    fHypothesis: BOOL,
+}}
+RIDL!{#[uuid(0x3b414aec, 0x720c, 0x4883, 0xb9, 0xef, 0x17, 0x8c, 0xd3, 0x94, 0xfb, 0x3a)]
+interface ISpSREngineSite(ISpSREngineSiteVtbl): IUnknown(IUnknownVtbl) {
+    fn Read(
+        pv: *mut c_void,
+        cb: ULONG,
+        pcbRead: *mut ULONG,
+    ) -> HRESULT,
+    fn DataAvailable(
+        pcb: *mut ULONG,
+    ) -> HRESULT,
+    fn SetBufferNotifySize(
+        cbSize: ULONG,
+    ) -> HRESULT,
+    fn ParseFromTransitions(
+        pParseInfo: *const SPPARSEINFO,
+        ppNewPhrase: *mut *mut ISpPhraseBuilder,
+    ) -> HRESULT,
+    fn Recognition(
+        pResultInfo: *const SPRECORESULTINFO,
+    ) -> HRESULT,
+    fn AddEvent(
+        pEvent: *const SPEVENT,
+        hSAPIRecoContext: SPRECOCONTEXTHANDLE,
+    ) -> HRESULT,
+    fn Synchronize(
+        ullProcessedThruPos: ULONGLONG,
+    ) -> HRESULT,
+    fn GetWordInfo(
+        pWordEntry: *mut SPWORDENTRY,
+        Options: SPWORDINFOOPT,
+    ) -> HRESULT,
+    fn SetWordClientContext(
+        hWord: SPWORDHANDLE,
+        pvClientContext: *mut c_void,
+    ) -> HRESULT,
+    fn GetRuleInfo(
+        pRuleEntry: *mut SPRULEENTRY,
+        Options: SPRULEINFOOPT,
+    ) -> HRESULT,
+    fn SetRuleClientContext(
+        hRule: SPRULEHANDLE,
+        pvClientContext: *mut c_void,
+    ) -> HRESULT,
+    fn GetStateInfo(
+        hState: SPSTATEHANDLE,
+        pStateInfo: *mut SPSTATEINFO,
+    ) -> HRESULT,
+    fn GetResource(
+        hRule: SPRULEHANDLE,
+        pszResourceName: LPCWSTR,
+        ppCoMemResource: *mut LPWSTR,
+    ) -> HRESULT,
+    fn GetTransitionProperty(
+        ID: SPTRANSITIONID,
+        ppCoMemProperty: *mut *mut SPTRANSITIONPROPERTY,
+    ) -> HRESULT,
+    fn IsAlternate(
+        hRule: SPRULEHANDLE,
+        hAltRule: SPRULEHANDLE,
+    ) -> HRESULT,
+    fn GetMaxAlternates(
+        hRule: SPRULEHANDLE,
+        pulNumAlts: *mut ULONG,
+    ) -> HRESULT,
+    fn GetContextMaxAlternates(
+        hContext: SPRECOCONTEXTHANDLE,
+        pulNumAlts: *mut ULONG,
+    ) -> HRESULT,
+    fn UpdateRecoPos(
+        ullCurrentRecoPos: ULONGLONG,
+    ) -> HRESULT,
+}}
+ENUM!{enum SPPROPSRC {
+    SPPROPSRC_RECO_INST,
+    SPPROPSRC_RECO_CTX,
+    SPPROPSRC_RECO_GRAMMAR,
+}}
+RIDL!{#[uuid(0x2f472991, 0x854b, 0x4465, 0xb6, 0x13, 0xfb, 0xaf, 0xb3, 0xad, 0x8e, 0xd8)]
+interface ISpSREngine(ISpSREngineVtbl): IUnknown(IUnknownVtbl) {
+    fn SetSite(
+        pSite: *mut ISpSREngineSite,
+    ) -> HRESULT,
+    fn GetInputAudioFormat(
+        pguidSourceFormatId: *const GUID,
+        pSourceWaveFormatEx: *const WAVEFORMATEX,
+        pguidDesiredFormatId: *mut GUID,
+        ppCoMemDesiredWaveFormatEx: *mut WAVEFORMATEX,
+    ) -> HRESULT,
+    fn RecognizeStream(
+        rguidFmtId: REFGUID,
+        pWaveFormatEx: *const WAVEFORMATEX,
+        hRequestSync: HANDLE,
+        hDataAvailable: HANDLE,
+        hExit: HANDLE,
+        fNewAudioStream: BOOL,
+        fRealTimeAudio: BOOL,
+        pAudioObjectToken: *mut ISpObjectToken,
+    ) -> HRESULT,
+    fn SetRecoProfile(
+        pProfile: *mut ISpObjectToken,
+    ) -> HRESULT,
+    fn OnCreateGrammar(
+        pvEngineRecoContext: *mut c_void,
+        hSAPIGrammar: SPGRAMMARHANDLE,
+        ppvEngineGrammarContext: *mut *mut c_void,
+    ) -> HRESULT,
+    fn OnDeleteGrammar(
+        pvEngineGrammar: *mut c_void,
+    ) -> HRESULT,
+    fn LoadProprietaryGrammar(
+        pvEngineGrammar: *mut c_void,
+        rguidParam: REFGUID,
+        pszStringParam: LPCWSTR,
+        pvDataParam: *const c_void,
+        ulDataSize: ULONG,
+        Options: SPLOADOPTIONS,
+    ) -> HRESULT,
+    fn UnloadProprietaryGrammar(
+        pvEngineGrammar: *mut c_void,
+    ) -> HRESULT,
+    fn SetProprietaryRuleState(
+        pvEngineGrammar: *mut c_void,
+        pszName: LPCWSTR,
+        pReserved: *mut c_void,
+        NewState: SPRULESTATE,
+        pcRulesChanged: *mut ULONG,
+    ) -> HRESULT,
+    fn SetProprietaryRuleIdState(
+        pvEngineGrammar: *mut c_void,
+        dwRuleId: DWORD,
+        NewState: SPRULESTATE,
+    ) -> HRESULT,
+    fn LoadSLM(
+        pvEngineGrammar: *mut c_void,
+        pszTopicName: LPCWSTR,
+    ) -> HRESULT,
+    fn UnloadSLM(
+        pvEngineGrammar: *mut c_void,
+    ) -> HRESULT,
+    fn SetSLMState(
+        pvEngineGrammar: *mut c_void,
+        NewState: SPRULESTATE,
+    ) -> HRESULT,
+    fn SetWordSequenceData(
+        pvEngineGrammar: *mut c_void,
+        pText: *const WCHAR,
+        cchText: ULONG,
+        pInfo: *const SPTEXTSELECTIONINFO,
+    ) -> HRESULT,
+    fn SetTextSelection(
+        pvEngineGrammar: *mut c_void,
+        pInfo: *const SPTEXTSELECTIONINFO,
+    ) -> HRESULT,
+    fn IsPronounceable(
+        pvEngineGrammar: *mut c_void,
+        pszWord: LPCWSTR,
+        pWordPronounceable: *mut SPWORDPRONOUNCEABLE,
+    ) -> HRESULT,
+    fn OnCreateRecoContext(
+        hSAPIRecoContext: SPRECOCONTEXTHANDLE,
+        ppvEngineContext: *mut *mut c_void,
+    ) -> HRESULT,
+    fn OnDeleteRecoContext(
+        pvEngineContext: *mut c_void,
+    ) -> HRESULT,
+    fn OnPrivateCall(
+        pvEngineContext: *mut c_void,
+        pCallFrame: PVOID,
+        ulCallFrameSize: ULONG,
+    ) -> HRESULT,
+    fn SetAdaptationData(
+        pvEngineContext: *mut c_void,
+        pAdaptationData: *const WCHAR,
+        cch: ULONG,
+    ) -> HRESULT,
+    fn SetPropertyNum(
+        eSrc: SPPROPSRC,
+        pvSrcObj: *mut c_void,
+        pName: *const WCHAR,
+        lValue: LONG,
+    ) -> HRESULT,
+    fn GetPropertyNum(
+        eSrc: SPPROPSRC,
+        pvSrcObj: *mut c_void,
+        pName: *const WCHAR,
+        lValue: *mut LONG,
+    ) -> HRESULT,
+    fn SetPropertyString(
+        eSrc: SPPROPSRC,
+        pvSrcObj: *mut c_void,
+        pName: LPCWSTR,
+        pValue: LPCWSTR,
+    ) -> HRESULT,
+    fn GetPropertyString(
+        eSrc: SPPROPSRC,
+        pvSrcObj: *mut c_void,
+        pName: LPCWSTR,
+        ppCoMemValue: *mut LPWSTR,
+    ) -> HRESULT,
+    fn SetGrammarState(
+        pvEngineGrammar: *mut c_void,
+        eGrammarState: SPGRAMMARSTATE,
+    ) -> HRESULT,
+    fn WordNotify(
+        Action: SPCFGNOTIFY,
+        cWords: ULONG,
+        pWords: *const SPWORDENTRY,
+    ) -> HRESULT,
+    fn RuleNotify(
+        Action: SPCFGNOTIFY,
+        cRules: ULONG,
+        pRules: *const SPRULEENTRY,
+    ) -> HRESULT,
+    fn PrivateCallEx(
+        pvEngineContext: *mut c_void,
+        pInCallFrame: *const c_void,
+        ulInCallFrameSize: ULONG,
+        ppvCoMemResponse: *mut *mut c_void,
+        pulResponseSize: *mut ULONG,
+    ) -> HRESULT,
+    fn SetContextState(
+        pvEngineContext: *mut c_void,
+        eContextState: SPCONTEXTSTATE,
+    ) -> HRESULT,
+}}
+STRUCT!{struct SPPHRASEALTREQUEST {
+    ulStartElement: ULONG,
+    cElements: ULONG,
+    ulRequestAltCount: ULONG,
+    pvResultExtra: *mut c_void,
+    cbResultExtra: ULONG,
+    pPhrase: *mut ISpPhrase,
+    pRecoContext: *mut ISpRecoContext,
+}}
+RIDL!{#[uuid(0x8e7c791e, 0x4467, 0x11d3, 0x97, 0x23, 0x00, 0xc0, 0x4f, 0x72, 0xdb, 0x08)]
+interface _ISpPrivateEngineCall(_ISpPrivateEngineCallVtbl): IUnknown(IUnknownVtbl) {
+    fn CallEngine(
+        pCallFrame: *mut c_void,
+        ulCallFrameSize: ULONG,
+    ) -> HRESULT,
+    fn CallEngineEx(
+        pInFrame: *const c_void,
+        ulInFrameSize: ULONG,
+        ppCoMemOutFrame: *mut *mut c_void,
+        pulOutFrameSize: *mut ULONG,
+    ) -> HRESULT,
+}}
+extern {
+    pub static LIBID_SpeechDDKLib: IID;
+    pub static CLSID_SpDataKey: CLSID;
+}
+RIDL!{#[uuid(0xd9f6ee60, 0x58c9, 0x458b, 0x88, 0xe1, 0x2f, 0x90, 0x8f, 0xd7, 0xf8, 0x7c)]
+class SpDataKey;}
+extern {
+    pub static CLSID_SpObjectTokenEnum: CLSID;
+    pub static CLSID_SpPhraseBuilder: CLSID;
+    pub static CLSID_SpITNProcessor: CLSID;
+    pub static CLSID_SpGrammarCompiler: CLSID;
+    pub static CLSID_SpGramCompBackend: CLSID;
+}