vendor/winapi-0.3.8/src/um/sapi51.rs - toolchain/rustc - Git at Google

 // 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.
 //! SAPI 5.1 definitions
 use ctypes::{c_char, c_float, c_long, c_short, c_ushort, c_void};
 use shared::guiddef::{CLSID, GUID, IID, REFCLSID, REFGUID, REFIID};
 use shared::minwindef::{
     BOOL, BYTE, DWORD, FILETIME, HKEY, HMODULE, LPARAM, UINT, ULONG, USHORT, WORD, WPARAM
 };
 use shared::mmreg::WAVEFORMATEX;
 use shared::rpcndr::byte;
 use shared::windef::HWND;
 use shared::wtypes::{BSTR, VARIANT_BOOL};
 use shared::wtypesbase::{
     CLSCTX_INPROC_HANDLER, CLSCTX_INPROC_SERVER, CLSCTX_LOCAL_SERVER, CLSCTX_REMOTE_SERVER
 };
 use um::oaidl::{DISPID_NEWENUM, DISPID_VALUE, IDispatch, IDispatchVtbl, VARIANT};
 use um::objidlbase::{IStream, IStreamVtbl, STREAM_SEEK_CUR, STREAM_SEEK_END, STREAM_SEEK_SET};
 use um::servprov::{IServiceProvider, IServiceProviderVtbl};
 use um::unknwnbase::{IUnknown, IUnknownVtbl};
 use um::winnt::{HANDLE, HRESULT, LONG, LONGLONG, LPCWSTR, LPWSTR, ULONGLONG, WCHAR};
 ENUM!{enum SPDATAKEYLOCATION {
     SPDKL_DefaultLocation = 0,
     SPDKL_CurrentUser = 1,
     SPDKL_LocalMachine = 2,
     SPDKL_CurrentConfig = 5,
 }}
 pub const SPDUI_EngineProperties: &'static str = "EngineProperties";
 pub const SPDUI_AddRemoveWord: &'static str = "AddRemoveWord";
 pub const SPDUI_UserTraining: &'static str = "UserTraining";
 pub const SPDUI_MicTraining: &'static str = "MicTraining";
 pub const SPDUI_RecoProfileProperties: &'static str = "RecoProfileProperties";
 pub const SPDUI_AudioProperties: &'static str = "AudioProperties";
 pub const SPDUI_AudioVolume: &'static str = "AudioVolume";
 pub const SPDUI_UserEnrollment: &'static str = "UserEnrollment";
 pub const SPDUI_ShareData: &'static str = "ShareData";
 pub const SPDUI_Tutorial: &'static str = "Tutorial";
 ENUM!{enum SPSTREAMFORMAT {
     SPSF_Default = -1i32 as u32,
     SPSF_NoAssignedFormat = 0,
     SPSF_Text = 1,
     SPSF_NonStandardFormat = 2,
     SPSF_ExtendedAudioFormat = 3,
     SPSF_8kHz8BitMono = 4,
     SPSF_8kHz8BitStereo = 5,
     SPSF_8kHz16BitMono = 6,
     SPSF_8kHz16BitStereo = 7,
     SPSF_11kHz8BitMono = 8,
     SPSF_11kHz8BitStereo = 9,
     SPSF_11kHz16BitMono = 10,
     SPSF_11kHz16BitStereo = 11,
     SPSF_12kHz8BitMono = 12,
     SPSF_12kHz8BitStereo = 13,
     SPSF_12kHz16BitMono = 14,
     SPSF_12kHz16BitStereo = 15,
     SPSF_16kHz8BitMono = 16,
     SPSF_16kHz8BitStereo = 17,
     SPSF_16kHz16BitMono = 18,
     SPSF_16kHz16BitStereo = 19,
     SPSF_22kHz8BitMono = 20,
     SPSF_22kHz8BitStereo = 21,
     SPSF_22kHz16BitMono = 22,
     SPSF_22kHz16BitStereo = 23,
     SPSF_24kHz8BitMono = 24,
     SPSF_24kHz8BitStereo = 25,
     SPSF_24kHz16BitMono = 26,
     SPSF_24kHz16BitStereo = 27,
     SPSF_32kHz8BitMono = 28,
     SPSF_32kHz8BitStereo = 29,
     SPSF_32kHz16BitMono = 30,
     SPSF_32kHz16BitStereo = 31,
     SPSF_44kHz8BitMono = 32,
     SPSF_44kHz8BitStereo = 33,
     SPSF_44kHz16BitMono = 34,
     SPSF_44kHz16BitStereo = 35,
     SPSF_48kHz8BitMono = 36,
     SPSF_48kHz8BitStereo = 37,
     SPSF_48kHz16BitMono = 38,
     SPSF_48kHz16BitStereo = 39,
     SPSF_TrueSpeech_8kHz1BitMono = 40,
     SPSF_CCITT_ALaw_8kHzMono = 41,
     SPSF_CCITT_ALaw_8kHzStereo = 42,
     SPSF_CCITT_ALaw_11kHzMono = 43,
     SPSF_CCITT_ALaw_11kHzStereo = 44,
     SPSF_CCITT_ALaw_22kHzMono = 45,
     SPSF_CCITT_ALaw_22kHzStereo = 46,
     SPSF_CCITT_ALaw_44kHzMono = 47,
     SPSF_CCITT_ALaw_44kHzStereo = 48,
     SPSF_CCITT_uLaw_8kHzMono = 49,
     SPSF_CCITT_uLaw_8kHzStereo = 50,
     SPSF_CCITT_uLaw_11kHzMono = 51,
     SPSF_CCITT_uLaw_11kHzStereo = 52,
     SPSF_CCITT_uLaw_22kHzMono = 53,
     SPSF_CCITT_uLaw_22kHzStereo = 54,
     SPSF_CCITT_uLaw_44kHzMono = 55,
     SPSF_CCITT_uLaw_44kHzStereo = 56,
     SPSF_ADPCM_8kHzMono = 57,
     SPSF_ADPCM_8kHzStereo = 58,
     SPSF_ADPCM_11kHzMono = 59,
     SPSF_ADPCM_11kHzStereo = 60,
     SPSF_ADPCM_22kHzMono = 61,
     SPSF_ADPCM_22kHzStereo = 62,
     SPSF_ADPCM_44kHzMono = 63,
     SPSF_ADPCM_44kHzStereo = 64,
     SPSF_GSM610_8kHzMono = 65,
     SPSF_GSM610_11kHzMono = 66,
     SPSF_GSM610_22kHzMono = 67,
     SPSF_GSM610_44kHzMono = 68,
     SPSF_NUM_FORMATS = 69,
 }}
 extern {
     pub static SPDFID_Text: GUID;
     pub static SPDFID_WaveFormatEx: GUID;
 }
 pub const SPREG_USER_ROOT: &'static str = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech";
 pub const SPREG_LOCAL_MACHINE_ROOT: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech";
 pub const SPCAT_AUDIOOUT: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput";
 pub const SPCAT_AUDIOIN: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput";
 pub const SPCAT_VOICES: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices";
 pub const SPCAT_RECOGNIZERS: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Recognizers";
 pub const SPCAT_APPLEXICONS: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AppLexicons";
 pub const SPCAT_PHONECONVERTERS: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\PhoneConverters";
 pub const SPCAT_TEXTNORMALIZERS: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\TextNormalizers";
 pub const SPCAT_RECOPROFILES: &'static str
     = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\RecoProfiles";
 pub const SPMMSYS_AUDIO_IN_TOKEN_ID: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput\\TokenEnums\\MMAudioIn\\";
 pub const SPMMSYS_AUDIO_OUT_TOKEN_ID: &'static str
     = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput\\TokenEnums\\MMAudioOut\\";
 pub const SPCURRENT_USER_LEXICON_TOKEN_ID: &'static str
     = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserLexicon";
 pub const SPCURRENT_USER_SHORTCUT_TOKEN_ID: &'static str
     = "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserShortcut";
 pub const SPTOKENVALUE_CLSID: &'static str = "CLSID";
 pub const SPTOKENKEY_FILES: &'static str = "Files";
 pub const SPTOKENKEY_UI: &'static str = "UI";
 pub const SPTOKENKEY_ATTRIBUTES: &'static str = "Attributes";
 pub const SPVOICECATEGORY_TTSRATE: &'static str = "DefaultTTSRate";
 pub const SPPROP_RESOURCE_USAGE: &'static str = "ResourceUsage";
 pub const SPPROP_HIGH_CONFIDENCE_THRESHOLD: &'static str = "HighConfidenceThreshold";
 pub const SPPROP_NORMAL_CONFIDENCE_THRESHOLD: &'static str = "NormalConfidenceThreshold";
 pub const SPPROP_LOW_CONFIDENCE_THRESHOLD: &'static str = "LowConfidenceThreshold";
 pub const SPPROP_RESPONSE_SPEED: &'static str = "ResponseSpeed";
 pub const SPPROP_COMPLEX_RESPONSE_SPEED: &'static str = "ComplexResponseSpeed";
 pub const SPPROP_ADAPTATION_ON: &'static str = "AdaptationOn";
 pub const SPPROP_PERSISTED_BACKGROUND_ADAPTATION: &'static str = "PersistedBackgroundAdaptation";
 pub const SPPROP_PERSISTED_LANGUAGE_MODEL_ADAPTATION: &'static str
     = "PersistedLanguageModelAdaptation";
 pub const SPPROP_UX_IS_LISTENING: &'static str = "UXIsListening";
 pub const SPTOPIC_SPELLING: &'static str = "Spelling";
 pub const SPWILDCARD: &'static str = "...";
 pub const SPDICTATION: &'static str = "*";
 pub const SPINFDICTATION: &'static str = "*+";
 pub const SP_LOW_CONFIDENCE: c_char = -1;
 pub const SP_NORMAL_CONFIDENCE: c_char = 0;
 pub const SP_HIGH_CONFIDENCE: c_char = 1;
 pub const DEFAULT_WEIGHT: c_float = 1.0;
 pub const SP_MAX_WORD_LENGTH: ULONG = 128;
 pub const SP_MAX_PRON_LENGTH: ULONG = 384;
 RIDL!{#[uuid(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]
 interface ISpNotifyCallback(ISpNotifyCallbackVtbl) {
     fn NotifyCallback(
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
 }}
 FN!{stdcall SPNOTIFYCALLBACK(
     wParam: WPARAM,
     lParam: LPARAM,
 ) -> ()}
 RIDL!{#[uuid(0x5eff4aef, 0x8487, 0x11d2, 0x96, 0x1c, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
 interface ISpNotifySource(ISpNotifySourceVtbl): IUnknown(IUnknownVtbl) {
     fn SetNotifySink(
         pNotifySink: *mut ISpNotifySink,
     ) -> HRESULT,
     fn SetNotifyWindowMessage(
         hWnd: HWND,
         Msg: UINT,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn SetNotifyCallbackFunction(
         pfnCallback: SPNOTIFYCALLBACK,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn SetNotifyCallbackInterface(
         pSpCallback: *mut ISpNotifyCallback,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn SetNotifyWin32Event() -> HRESULT,
     fn WaitForNotifyEvent(
         dwMilliseconds: DWORD,
     ) -> HRESULT,
     fn GetNotifyEventHandle() -> HANDLE,
 }}
 RIDL!{#[uuid(0x259684dc, 0x37c3, 0x11d2, 0x96, 0x03, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
 interface ISpNotifySink(ISpNotifySinkVtbl): IUnknown(IUnknownVtbl) {
     fn Notify() -> HRESULT,
 }}
 RIDL!{#[uuid(0xaca16614, 0x5d3d, 0x11d2, 0x96, 0x0e, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
 interface ISpNotifyTranslator(ISpNotifyTranslatorVtbl): ISpNotifySink(ISpNotifySinkVtbl) {
     fn InitWindowMessage(
         hWnd: HWND,
         Msg: UINT,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn InitCallback(
         pfnCallback: SPNOTIFYCALLBACK,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn InitSpNotifyCallback(
         pSpCallback: *mut ISpNotifyCallback,
         wParam: WPARAM,
         lParam: LPARAM,
     ) -> HRESULT,
     fn InitWin32Event(
         hEvent: HANDLE,
         fCloseHandleOnRelease: BOOL,
     ) -> HRESULT,
     fn Wait(
         dwMilliseconds: DWORD,
     ) -> HRESULT,
     fn GetEventHandle() -> HANDLE,
 }}
 RIDL!{#[uuid(0x14056581, 0xe16c, 0x11d2, 0xbb, 0x90, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
 interface ISpDataKey(ISpDataKeyVtbl): IUnknown(IUnknownVtbl) {
     fn SetData(
         pszValueName: LPCWSTR,
         cbData: ULONG,
         pData: *const BYTE,
     ) -> HRESULT,
     fn GetData(
         pszValueName: LPCWSTR,
         pcbData: *mut ULONG,
         pData: *mut BYTE,
     ) -> HRESULT,
     fn SetStringValue(
         pszValueName: LPCWSTR,
         pszValue: LPCWSTR,
     ) -> HRESULT,
     fn GetStringValue(
         pszValueName: LPCWSTR,
         ppszValue: *mut LPWSTR,
     ) -> HRESULT,
     fn SetDWORD(
         pszValueName: LPCWSTR,
         dwValue: DWORD,
     ) -> HRESULT,
     fn GetDWORD(
         pszValueName: LPCWSTR,
         pdwValue: *mut DWORD,
     ) -> HRESULT,
     fn OpenKey(
         pszSubKeyName: LPCWSTR,
         ppSubKey: *mut *mut ISpDataKey,
     ) -> HRESULT,
     fn CreateKey(
         pszSubKey: LPCWSTR,
         ppSubKey: *mut *mut ISpDataKey,
     ) -> HRESULT,
     fn DeleteKey(
         pszSubKey: LPCWSTR,
     ) -> HRESULT,
     fn DeleteValue(
         pszValueName: LPCWSTR,
     ) -> HRESULT,
     fn EnumKeys(
         Index: ULONG,
         ppszSubKeyName: *mut LPWSTR,
     ) -> HRESULT,
     fn EnumValues(
         Index: ULONG,
         ppszValueName: *mut LPWSTR,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x92a66e2b, 0xc830, 0x4149, 0x83, 0xdf, 0x6f, 0xc2, 0xba, 0x1e, 0x7a, 0x5b)]
 interface ISpRegDataKey(ISpRegDataKeyVtbl): ISpDataKey(ISpDataKeyVtbl) {
     fn SetKey(
         hkey: HKEY,
         fReadOnly: BOOL,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x2d3d3845, 0x39af, 0x4850, 0xbb, 0xf9, 0x40, 0xb4, 0x97, 0x80, 0x01, 0x1d)]
 interface ISpObjectTokenCategory(ISpObjectTokenCategoryVtbl): ISpDataKey(ISpDataKeyVtbl) {
     fn SetId(
         pszCategoryId: LPCWSTR,
         fCreateIfNotExist: BOOL,
     ) -> HRESULT,
     fn GetId(
         ppszCoMemCategoryId: *mut LPWSTR,
     ) -> HRESULT,
     fn GetDataKey(
         spdkl: SPDATAKEYLOCATION,
         pppDataKey: *mut *mut ISpDataKey,
     ) -> HRESULT,
     fn EnumTokens(
         pzsReqAttribs: LPCWSTR,
         pszOptAttribs: LPCWSTR,
         ppEnum: *mut *mut IEnumSpObjectTokens,
     ) -> HRESULT,
     fn SetDefaultTokenId(
         pszTokenId: LPCWSTR,
     ) -> HRESULT,
     fn GetDefaultTokenId(
         ppszCoMemTokenId: *mut LPWSTR,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x14056589, 0xe16c, 0x11d2, 0xbb, 0x90, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
 interface ISpObjectToken(ISpObjectTokenVtbl): ISpDataKey(ISpDataKeyVtbl) {
     fn SetId(
         pszCategoryId: LPCWSTR,
         pszTokenId: LPCWSTR,
         fCreateIfNotExist: BOOL,
     ) -> HRESULT,
     fn GetId(
         ppszCoMemTokenId: *mut LPWSTR,
     ) -> HRESULT,
     fn GetCategory(
         ppTokenCategory: *mut *mut ISpObjectTokenCategory,
     ) -> HRESULT,
     fn CreateInstance(
         pUnkOuter: *mut IUnknown,
         dwClsContext: DWORD,
         riid: REFIID,
         ppvObject: *mut *mut c_void,
     ) -> HRESULT,
     fn GetStorageFileName(
         clsidCaller: REFCLSID,
         pszValueName: LPCWSTR,
         pszFileNameSpecifier: LPCWSTR,
         nFolder: ULONG,
         ppszFilePath: *mut LPWSTR,
     ) -> HRESULT,
     fn RemoveStorageFileName(
         pszKeyName: LPCWSTR,
         fDeleteFile: BOOL,
     ) -> HRESULT,
     fn Remove(
         pclsidCaller: *const CLSID,
     ) -> HRESULT,
     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,
         punkObject: *mut IUnknown,
     ) -> HRESULT,
     fn MatchesAttributes(
         pszAttributes: LPCWSTR,
         pfMatches: *mut BOOL,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xb8aab0cf, 0x346f, 0x49d8, 0x94, 0x99, 0xc8, 0xb0, 0x3f, 0x16, 0x1d, 0x51)]
 interface ISpObjectTokenInit(ISpObjectTokenInitVtbl): ISpObjectToken(ISpObjectTokenVtbl) {
     fn InitFromDataKey(
         pszCategoryId: LPCWSTR,
         pszTokenId: LPCWSTR,
         pDataKey: *mut ISpDataKey,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x06b64f9e, 0x7fda, 0x11d2, 0xb4, 0xf2, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
 interface IEnumSpObjectTokens(IEnumSpObjectTokensVtbl): IUnknown(IUnknownVtbl) {
     fn Next(
         celt: ULONG,
         pelt: *mut *mut ISpObjectToken,
         pceltFetched: *mut ULONG,
     ) -> HRESULT,
     fn Skip(
         celt: ULONG,
     ) -> HRESULT,
     fn Reset() -> HRESULT,
     fn Clone(
         ppEnum: *mut *mut IEnumSpObjectTokens,
     ) -> HRESULT,
     fn Item(
         Index: ULONG,
         ppToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetCount(
         pCount: *mut ULONG,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x5b559f40, 0xe952, 0x11d2, 0xbb, 0x91, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
 interface ISpObjectWithToken(ISpObjectWithTokenVtbl): IUnknown(IUnknownVtbl) {
     fn SetObjectToken(
         pToken: *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetObjectToken(
         ppToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x93384e18, 0x5014, 0x43d5, 0xad, 0xbb, 0xa7, 0x8e, 0x05, 0x59, 0x26, 0xbd)]
 interface ISpResourceManager(ISpResourceManagerVtbl): IServiceProvider(IServiceProviderVtbl) {
     fn SetObject(
         guidServiceId: REFGUID,
         pUnkObject: *mut IUnknown,
     ) -> HRESULT,
     fn GetObject(
         guidServiceId: REFGUID,
         ObjectCLSID: REFCLSID,
         ObjectIID: REFIID,
         fReleaseWhenLastExternalRefReleased: BOOL,
         ppObject: *mut *mut c_void,
     ) -> HRESULT,
 }}
 ENUM!{enum SPEVENTLPARAMTYPE {
     SPET_LPARAM_IS_UNDEFINED = 0,
     SPET_LPARAM_IS_TOKEN,
     SPET_LPARAM_IS_OBJECT,
     SPET_LPARAM_IS_POINTER,
     SPET_LPARAM_IS_STRING,
 }}
 ENUM!{enum SPEVENTENUM {
     SPEI_UNDEFINED = 0,
     SPEI_START_INPUT_STREAM = 1,
     SPEI_END_INPUT_STREAM = 2,
     SPEI_VOICE_CHANGE = 3,
     SPEI_TTS_BOOKMARK = 4,
     SPEI_WORD_BOUNDARY = 5,
     SPEI_PHONEME = 6,
     SPEI_SENTENCE_BOUNDARY = 7,
     SPEI_VISEME = 8,
     SPEI_TTS_AUDIO_LEVEL = 9,
     SPEI_TTS_PRIVATE = 15,
     SPEI_MIN_TTS = 1,
     SPEI_MAX_TTS = 15,
     SPEI_END_SR_STREAM = 34,
     SPEI_SOUND_START = 35,
     SPEI_SOUND_END = 36,
     SPEI_PHRASE_START = 37,
     SPEI_RECOGNITION = 38,
     SPEI_HYPOTHESIS = 39,
     SPEI_SR_BOOKMARK = 40,
     SPEI_PROPERTY_NUM_CHANGE = 41,
     SPEI_PROPERTY_STRING_CHANGE = 42,
     SPEI_FALSE_RECOGNITION = 43,
     SPEI_INTERFERENCE = 44,
     SPEI_REQUEST_UI = 45,
     SPEI_RECO_STATE_CHANGE = 46,
     SPEI_ADAPTATION = 47,
     SPEI_START_SR_STREAM = 48,
     SPEI_RECO_OTHER_CONTEXT = 49,
     SPEI_SR_AUDIO_LEVEL = 50,
     SPEI_SR_PRIVATE = 52,
     SPEI_MIN_SR = 34,
     SPEI_MAX_SR = 52,
     SPEI_RESERVED1 = 30,
     SPEI_RESERVED2 = 33,
     SPEI_RESERVED3 = 63,
 }}
 pub const SPFEI_FLAGCHECK: ULONGLONG = (1 << SPEI_RESERVED1) | (1 << SPEI_RESERVED2);
 pub const SPFEI_ALL_TTS_EVENTS: ULONGLONG = 0x000000000000FFFE | SPFEI_FLAGCHECK;
 pub const SPFEI_ALL_SR_EVENTS: ULONGLONG = 0x003FFFFC00000000 | SPFEI_FLAGCHECK;
 pub const SPFEI_ALL_EVENTS: ULONGLONG = 0xEFFFFFFFFFFFFFFF;
 #[inline]
 pub fn SPFEI(
         SPEI_ord: SPEVENTENUM,
     ) -> ULONGLONG {
     (1 << SPEI_ord) | SPFEI_FLAGCHECK
 }
 STRUCT!{struct SPEVENT {
     bitfields: DWORD,
     ulStreamNum: ULONG,
     ullAudioStreamOffset: ULONGLONG,
     wParam: WPARAM,
     lParam: LPARAM,
 }}
 BITFIELD!{SPEVENT bitfields: SPEVENTENUM [ eEventId set_eEventId[0..16], ]}
 BITFIELD!{SPEVENT bitfields: SPEVENTLPARAMTYPE [ elParamType set_elParamType[16..32], ]}
 STRUCT!{struct SPSERIALIZEDEVENT {
     bitfields: DWORD,
     ulStreamNum: ULONG,
     ullAudioStreamOffset: ULONGLONG,
     SerializedwParam: ULONG,
     SerializedlParam: LONG,
 }}
 BITFIELD!{SPSERIALIZEDEVENT bitfields: SPEVENTENUM [ eEventId set_eEventId[0..16], ]}
 BITFIELD!{SPSERIALIZEDEVENT bitfields: SPEVENTLPARAMTYPE [ elParamType set_elParamType[16..32], ]}
 STRUCT!{struct SPSERIALIZEDEVENT64 {
     bitfields: DWORD,
     ulStreamNum: ULONG,
     ullAudioStreamOffset: ULONGLONG,
     SerializedwParam: ULONGLONG,
     SerializedlParam: LONGLONG,
 }}
 BITFIELD!{SPSERIALIZEDEVENT64 bitfields: SPEVENTENUM [
     eEventId set_eEventId[0..16],
 ]}
 BITFIELD!{SPSERIALIZEDEVENT64 bitfields: SPEVENTLPARAMTYPE [
     elParamType set_elParamType[16..32],
 ]}
 ENUM!{enum SPINTERFERENCE {
     SPINTERFERENCE_NONE = 0,
     SPINTERFERENCE_NOISE,
     SPINTERFERENCE_NOSIGNAL,
     SPINTERFERENCE_TOOLOUD,
     SPINTERFERENCE_TOOQUIET,
     SPINTERFERENCE_TOOFAST,
     SPINTERFERENCE_TOOSLOW,
     SPINTERFERENCE_LATENCY_WARNING,
     SPINTERFERENCE_LATENCY_TRUNCATE_BEGIN ,
     SPINTERFERENCE_LATENCY_TRUNCATE_END,
 }}
 ENUM!{enum SPENDSRSTREAMFLAGS {
     SPESF_NONE = 0,
     SPESF_STREAM_RELEASED = 1 << 0,
     SPESF_EMULATED = 1 << 1,
 }}
 ENUM!{enum SPVFEATURE {
     SPVFEATURE_STRESSED = 1 << 0,
     SPVFEATURE_EMPHASIS = 1 << 1,
 }}
 ENUM!{enum SPVISEMES {
     SP_VISEME_0 = 0,
     SP_VISEME_1,
     SP_VISEME_2,
     SP_VISEME_3,
     SP_VISEME_4,
     SP_VISEME_5,
     SP_VISEME_6,
     SP_VISEME_7,
     SP_VISEME_8,
     SP_VISEME_9,
     SP_VISEME_10,
     SP_VISEME_11,
     SP_VISEME_12,
     SP_VISEME_13,
     SP_VISEME_14,
     SP_VISEME_15,
     SP_VISEME_16,
     SP_VISEME_17,
     SP_VISEME_18,
     SP_VISEME_19,
     SP_VISEME_20,
     SP_VISEME_21,
 }}
 STRUCT!{struct SPEVENTSOURCEINFO {
     ullEventInterest: ULONGLONG,
     ullQueuedInterest: ULONGLONG,
     ulCount: ULONG,
 }}
 RIDL!{#[uuid(0xbe7a9cce, 0x5f9e, 0x11d2, 0x96, 0x0f, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
 interface ISpEventSource(ISpEventSourceVtbl): ISpNotifySource(ISpNotifySourceVtbl) {
     fn SetInterest(
         ullEventInterest: ULONGLONG,
         ullQueuedInterest: ULONGLONG,
     ) -> HRESULT,
     fn GetEvents(
         ulCount: ULONG,
         pEventArray: *mut SPEVENT,
         pulFetched: *mut ULONG,
     ) -> HRESULT,
     fn GetInfo(
         pInfo: *mut SPEVENTSOURCEINFO,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xbe7a9cc9, 0x5f9e, 0x11d2, 0x96, 0x0f, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0x28)]
 interface ISpEventSink(ISpEventSinkVtbl): IUnknown(IUnknownVtbl) {
     fn AddEvents(
         pEventArray: *const SPEVENT,
         ulCount: ULONG,
     ) -> HRESULT,
     fn GetEventInterest(
         pullEventInterest: *mut ULONGLONG,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xbed530be, 0x2606, 0x4f4d, 0xa1, 0xc0, 0x54, 0xc5, 0xcd, 0xa5, 0x56, 0x6f)]
 interface ISpStreamFormat(ISpStreamFormatVtbl): IStream(IStreamVtbl) {
     fn GetFormat(
         pguidFormatId: *mut GUID,
         ppCoMemWaveFormatEx: *mut *mut WAVEFORMATEX,
     ) -> HRESULT,
 }}
 ENUM!{enum SPFILEMODE {
     SPFM_OPEN_READONLY,
     SPFM_OPEN_READWRITE,
     SPFM_CREATE,
     SPFM_CREATE_ALWAYS,
     SPFM_NUM_MODES,
 }}
 RIDL!{#[uuid(0x12e3cca9, 0x7518, 0x44c5, 0xa5, 0xe7, 0xba, 0x5a, 0x79, 0xcb, 0x92, 0x9e)]
 interface ISpStream(ISpStreamVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
     fn SetBaseStream(
         pStream: *mut IStream,
         rguidFormat: REFGUID,
         pWaveFormatEx: *const WAVEFORMATEX,
     ) -> HRESULT,
     fn GetBaseStream(
         ppStream: *mut *mut IStream,
     ) -> HRESULT,
     fn BindToFile(
         pszFileName: LPCWSTR,
         eMode: SPFILEMODE,
         pFormatId: *const GUID,
         pWaveFormatEx: *const WAVEFORMATEX,
         ullEventInterest: ULONGLONG,
     ) -> HRESULT,
     fn Close() -> HRESULT,
 }}
 RIDL!{#[uuid(0x678a932c, 0xea71, 0x4446, 0x9b, 0x41, 0x78, 0xfd, 0xa6, 0x28, 0x0a, 0x29)]
 interface ISpStreamFormatConverter(ISpStreamFormatConverterVtbl):
     ISpStreamFormat(ISpStreamFormatVtbl) {
     fn SetBaseStream(
         pStream: *mut ISpStreamFormat,
         fSetFormatToBaseStreamFormat: BOOL,
         fWriteToBaseStream: BOOL,
     ) -> HRESULT,
     fn GetBaseStream(
         ppStream: *mut *mut ISpStreamFormat,
     ) -> HRESULT,
     fn SetFormat(
         rguidFormatIdOfConvertedStream: REFGUID,
         pWaveFormatExOfConvertedStream: *const WAVEFORMATEX,
     ) -> HRESULT,
     fn ResetSeekPosition() -> HRESULT,
     fn ScaleConvertedToBaseOffset(
         ullOffsetConvertedStream: ULONGLONG,
         pullOffsetBaseStream: *mut ULONGLONG,
     ) -> HRESULT,
     fn ScaleBaseToConvertedOffset(
         ullOffsetBaseStream: ULONGLONG,
         pullOffsetConvertedStream: *mut ULONGLONG,
     ) -> HRESULT,
 }}
 ENUM!{enum SPAUDIOSTATE {
     SPAS_CLOSED,
     SPAS_STOP,
     SPAS_PAUSE,
     SPAS_RUN,
 }}
 STRUCT!{struct SPAUDIOSTATUS {
     cbFreeBuffSpace: c_long,
     cbNonBlockingIO: ULONG,
     State: SPAUDIOSTATE,
     CurSeekPos: ULONGLONG,
     CurDevicePos: ULONGLONG,
     dwAudioLevel: DWORD,
     dwReserved2: DWORD,
 }}
 STRUCT!{struct SPAUDIOBUFFERINFO {
     ulMsMinNotification: ULONG,
     ulMsBufferSize: ULONG,
     ulMsEventBias: ULONG,
 }}
 RIDL!{#[uuid(0xc05c768f, 0xfae8, 0x4ec2, 0x8e, 0x07, 0x33, 0x83, 0x21, 0xc1, 0x24, 0x52)]
 interface ISpAudio(ISpAudioVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
     fn SetState(
         NewState: SPAUDIOSTATE,
         ullReserved: ULONGLONG,
     ) -> HRESULT,
     fn SetFormat(
         rguidFmtId: REFGUID,
         pWaveFormatEx: *const WAVEFORMATEX,
     ) -> HRESULT,
     fn GetStatus(
         pStatus: *mut SPAUDIOSTATUS,
     ) -> HRESULT,
     fn SetBufferInfo(
         pBuffInfo: *const SPAUDIOBUFFERINFO,
     ) -> HRESULT,
     fn GetBufferInfo(
         pBuffInfo: *mut SPAUDIOBUFFERINFO,
     ) -> HRESULT,
     fn GetDefaultFormat(
         pFormatId: *mut GUID,
         ppCoMemWaveFormatEx: *mut *mut WAVEFORMATEX,
     ) -> HRESULT,
     fn EventHandle() -> HANDLE,
     fn GetVolumeLevel(
         pLevel: *mut ULONG,
     ) -> HRESULT,
     fn SetVolumeLevel(
         Level: ULONG,
     ) -> HRESULT,
     fn GetBufferNotifySize(
         pcbSize: *mut ULONG,
     ) -> HRESULT,
     fn SetBufferNotifySize(
         cbSize: ULONG,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x15806f6e, 0x1d70, 0x4b48, 0x98, 0xe6, 0x3b, 0x1a, 0x00, 0x75, 0x09, 0xab)]
 interface ISpMMSysAudio(ISpMMSysAudioVtbl): ISpAudio(ISpAudioVtbl) {
     fn GetDeviceId(
         puDeviceId: *mut UINT,
     ) -> HRESULT,
     fn SetDeviceId(
         uDeviceId: UINT,
     ) -> HRESULT,
     fn GetMMHandle(
         pHandle: *mut *mut c_void,
     ) -> HRESULT,
     fn GetLineId(
         puLineId: *mut UINT,
     ) -> HRESULT,
     fn SetLineId(
         uLineId: UINT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x10f63bce, 0x201a, 0x11d3, 0xac, 0x70, 0x00, 0xc0, 0x4f, 0x8e, 0xe6, 0xc0)]
 interface ISpTranscript(ISpTranscriptVtbl): IUnknown(IUnknownVtbl) {
     fn GetTranscript(
         ppszTranscript: *mut LPWSTR,
     ) -> HRESULT,
     fn AppendTranscript(
         pszTranscript: LPCWSTR,
     ) -> HRESULT,
 }}
 ENUM!{enum SPDISPLAYATTRIBUTES {
     SPAF_ONE_TRAILING_SPACE = 0x2,
     SPAF_TWO_TRAILING_SPACES = 0x4,
     SPAF_CONSUME_LEADING_SPACES = 0x8,
     SPAF_ALL = 0xf,
 }}
 pub type SPPHONEID = WCHAR;
 pub type PSPPHONEID = LPWSTR;
 pub type PCSPPHONEID = LPCWSTR;
 STRUCT!{struct SPPHRASEELEMENT {
     ulAudioTimeOffset: ULONG,
     ulAudioSizeTime: ULONG,
     ulAudioStreamOffset: ULONG,
     ulAudioSizeBytes: ULONG,
     ulRetainedStreamOffset: ULONG,
     ulRetainedSizeBytes: ULONG,
     pszDisplayText: LPCWSTR,
     pszLexicalForm: LPCWSTR,
     pszPronunciation: *const SPPHONEID,
     bDisplayAttributes: BYTE,
     RequiredConfidence: c_char,
     ActualConfidence: c_char,
     Reserved: BYTE,
     SREngineConfidence: c_float,
 }}
 STRUCT!{struct SPPHRASERULE {
     pszName: LPCWSTR,
     ulId: ULONG,
     ulFirstElement: ULONG,
     ulCountOfElements: ULONG,
     pNextSibling: *const SPPHRASERULE,
     pFirstChild: *const SPPHRASERULE,
     SREngineConfidence: c_float,
     Confidence: c_char,
 }}
 ENUM!{enum SPPHRASEPROPERTYUNIONTYPE {
     SPPPUT_UNUSED = 0,
     SPPPUT_ARRAY_INDEX,
 }}
 STRUCT!{struct SPPHRASEPROPERTY_u_s {
     bType: byte,
     bReserved: byte,
     usArrayIndex: c_ushort,
 }}
 UNION!{union SPPHRASEPROPERTY_u {
     [u32; 1],
     ulId ulId_mut: ULONG,
     s s_mut: SPPHRASEPROPERTY_u_s,
 }}
 STRUCT!{struct SPPHRASEPROPERTY {
     pszName: LPCWSTR,
     u: SPPHRASEPROPERTY_u_s,
     pszValue: LPCWSTR,
     vValue: VARIANT,
     ulFirstElement: ULONG,
     ulCountOfElements: ULONG,
     pNextSibling: *const SPPHRASEPROPERTY,
     pFirstChild: *const SPPHRASEPROPERTY,
     SREngineConfidence: c_float,
     Confidence: c_char,
 }}
 STRUCT!{struct SPPHRASEREPLACEMENT {
     bDisplayAttributes: BYTE,
     pszReplacementText: LPCWSTR,
     ulFirstElement: ULONG,
     ulCountOfElements: ULONG,
 }}
 STRUCT!{struct SPPHRASE {
     cbSize: ULONG,
     LangID: WORD,
     wHomophoneGroupId: WORD,
     ullGrammarID: ULONGLONG,
     ftStartTime: ULONGLONG,
     ullAudioStreamPosition: ULONGLONG,
     ulAudioSizeBytes: ULONG,
     ulRetainedSizeBytes: ULONG,
     ulAudioSizeTime: ULONG,
     Rule: SPPHRASERULE,
     pProperties: *const SPPHRASEPROPERTY,
     pElements: *const SPPHRASEELEMENT,
     cReplacements: ULONG,
     pReplacements: *const SPPHRASEREPLACEMENT,
     SREngineID: GUID,
     ulSREnginePrivateDataSize: ULONG,
     pSREnginePrivateData: *const BYTE,
 }}
 STRUCT!{struct SPSERIALIZEDPHRASE {
     ulSerializedSize: ULONG,
 }}
 ENUM!{enum SPVALUETYPE {
     SPDF_PROPERTY = 0x1,
     SPDF_REPLACEMENT = 0x2,
     SPDF_RULE = 0x4,
     SPDF_DISPLAYTEXT = 0x8,
     SPDF_LEXICALFORM = 0x10,
     SPDF_PRONUNCIATION = 0x20,
     SPDF_AUDIO = 0x40,
     SPDF_ALTERNATES = 0x80,
     SPDF_ALL = 0xff,
 }}
 STRUCT!{struct SPBINARYGRAMMAR {
     ulTotalSerializedSize: ULONG,
 }}
 ENUM!{enum SPPHRASERNG {
     SPPR_ALL_ELEMENTS = -1i32 as u32,
 }}
 pub const SP_GETWHOLEPHRASE: SPPHRASERNG = SPPR_ALL_ELEMENTS;
 pub const SPRR_ALL_ELEMENTS: SPPHRASERNG = SPPR_ALL_ELEMENTS;
 DECLARE_HANDLE!{SPSTATEHANDLE, SPSTATEHANDLE__}
 ENUM!{enum SPRECOEVENTFLAGS {
     SPREF_AutoPause = 1 << 0,
     SPREF_Emulated = 1 << 1,
 }}
 ENUM!{enum SPPARTOFSPEECH {
     SPPS_NotOverriden = -1i32 as u32,
     SPPS_Unknown = 0,
     SPPS_Noun = 0x1000,
     SPPS_Verb = 0x2000,
     SPPS_Modifier = 0x3000,
     SPPS_Function = 0x4000,
     SPPS_Interjection = 0x5000,
 }}
 ENUM!{enum SPLEXICONTYPE {
     eLEXTYPE_USER = 1 << 0,
     eLEXTYPE_APP = 1 << 1,
     eLEXTYPE_VENDORLEXICON = 1 << 2,
     eLEXTYPE_LETTERTOSOUND = 1 << 3,
     eLEXTYPE_MORPHOLOGY = 1 << 4,
     eLEXTYPE_RESERVED4 = 1 << 5,
     eLEXTYPE_USER_SHORTCUT = 1 << 6,
     eLEXTYPE_RESERVED6 = 1 << 7,
     eLEXTYPE_RESERVED7 = 1 << 8,
     eLEXTYPE_RESERVED8 = 1 << 9,
     eLEXTYPE_RESERVED9 = 1 << 10,
     eLEXTYPE_RESERVED10 = 1 << 11,
     eLEXTYPE_PRIVATE1 = 1 << 12,
     eLEXTYPE_PRIVATE2 = 1 << 13,
     eLEXTYPE_PRIVATE3 = 1 << 14,
     eLEXTYPE_PRIVATE4 = 1 << 15,
     eLEXTYPE_PRIVATE5 = 1 << 16,
     eLEXTYPE_PRIVATE6 = 1 << 17,
     eLEXTYPE_PRIVATE7 = 1 << 18,
     eLEXTYPE_PRIVATE8 = 1 << 19,
     eLEXTYPE_PRIVATE9 = 1 << 20,
     eLEXTYPE_PRIVATE10 = 1 << 21,
     eLEXTYPE_PRIVATE11 = 1 << 22,
     eLEXTYPE_PRIVATE12 = 1 << 23,
     eLEXTYPE_PRIVATE13 = 1 << 24,
     eLEXTYPE_PRIVATE14 = 1 << 25,
     eLEXTYPE_PRIVATE15 = 1 << 26,
     eLEXTYPE_PRIVATE16 = 1 << 27,
     eLEXTYPE_PRIVATE17 = 1 << 28,
     eLEXTYPE_PRIVATE18 = 1 << 29,
     eLEXTYPE_PRIVATE19 = 1 << 30,
     eLEXTYPE_PRIVATE20 = 1 << 31,
 }}
 ENUM!{enum SPWORDTYPE {
     eWORDTYPE_ADDED = 1 << 0,
     eWORDTYPE_DELETED = 1 << 1,
 }}
 STRUCT!{struct SPWORDPRONUNCIATION {
     pNextWordPronunciation: *mut SPWORDPRONUNCIATION,
     eLexiconType: SPLEXICONTYPE,
     LangID: WORD,
     wPronunciationFlags: WORD,
     ePartOfSpeech: SPPARTOFSPEECH,
     szPronunciation: [SPPHONEID; 1],
 }}
 STRUCT!{struct SPWORDPRONUNCIATIONLIST {
     ulSize: ULONG,
     pvBuffer: *mut BYTE,
     pFirstWordPronunciation: *mut SPWORDPRONUNCIATION,
 }}
 STRUCT!{struct SPWORD {
     pNextWord: *mut SPWORD,
     LangID: WORD,
     wReserved: WORD,
     eWordType: SPWORDTYPE,
     pszWord: LPWSTR,
     pFirstWordPronunciation: *mut SPWORDPRONUNCIATION,
 }}
 STRUCT!{struct SPWORDLIST {
     ulSize: ULONG,
     pvBuffer: *mut BYTE,
     pFirstWord: *mut SPWORD,
 }}
 RIDL!{#[uuid(0xda41a7c2, 0x5383, 0x4db2, 0x91, 0x6b, 0x6c, 0x17, 0x19, 0xe3, 0xdb, 0x58)]
 interface ISpLexicon(ISpLexiconVtbl): IUnknown(IUnknownVtbl) {
     fn GetPronunciations(
         pszWord: LPCWSTR,
         LangID: WORD,
         dwFlags: DWORD,
         pWordPronunciationList: *mut SPWORDPRONUNCIATIONLIST,
     ) -> HRESULT,
     fn AddPronunciation(
         pszWord: LPCWSTR,
         LangID: WORD,
         ePartOfSpeech: SPPARTOFSPEECH,
         pszPronunciation: PCSPPHONEID,
     ) -> HRESULT,
     fn RemovePronunciation(
         pszWord: LPCWSTR,
         LangID: WORD,
         ePartOfSpeech: SPPARTOFSPEECH,
         pszPronunciation: PCSPPHONEID,
     ) -> HRESULT,
     fn GetGeneration(
         pdwGeneration: *mut DWORD,
     ) -> HRESULT,
     fn GetGenerationChange(
         dwFlags: DWORD,
         pdwGeneration: *mut DWORD,
         pWordList: *mut SPWORDLIST,
     ) -> HRESULT,
     fn GetWords(
         dwFlags: DWORD,
         pdwGeneration: *mut DWORD,
         pdwCookie: *mut DWORD,
         pWordList: *mut SPWORDLIST,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x8565572f, 0xc094, 0x41cc, 0xb5, 0x6e, 0x10, 0xbd, 0x9c, 0x3f, 0xf0, 0x44)]
 interface ISpContainerLexicon(ISpContainerLexiconVtbl): ISpLexicon(ISpLexiconVtbl) {
     fn AddLexicon(
         pAddLexicon: *mut ISpLexicon,
         dwFlags: DWORD,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x8445c581, 0x0cac, 0x4a38, 0xab, 0xfe, 0x9b, 0x2c, 0xe2, 0x82, 0x64, 0x55)]
 interface ISpPhoneConverter(ISpPhoneConverterVtbl): ISpObjectWithToken(ISpObjectWithTokenVtbl) {
     fn PhoneToId(
         pszPhone: LPCWSTR,
         pId: *mut SPPHONEID,
     ) -> HRESULT,
     fn IdToPhone(
         pId: PCSPPHONEID,
         pszPhone: *mut WCHAR,
     ) -> HRESULT,
 }}
 STRUCT!{struct SPVPITCH {
     MiddleAdj: c_long,
     RangeAdj: c_long,
 }}
 ENUM!{enum SPVACTIONS {
     SPVA_Speak = 0,
     SPVA_Silence,
     SPVA_Pronounce,
     SPVA_Bookmark,
     SPVA_SpellOut,
     SPVA_Section,
     SPVA_ParseUnknownTag,
 }}
 STRUCT!{struct SPVCONTEXT {
     pCategory: LPCWSTR,
     pBefore: LPCWSTR,
     pAfter: LPCWSTR,
 }}
 STRUCT!{struct SPVSTATE {
     eAction: SPVACTIONS,
     LangID: WORD,
     wReserved: WORD,
     EmphAdj: c_long,
     RateAdj: c_long,
     Volume: ULONG,
     PitchAdj: SPVPITCH,
     SilenceMSecs: ULONG,
     pPhoneIds: *mut SPPHONEID,
     ePartOfSpeech: SPPARTOFSPEECH,
     Context: SPVCONTEXT,
 }}
 ENUM!{enum SPRUNSTATE {
     SPRS_DONE = 1 << 0,
     SPRS_IS_SPEAKING = 1 << 1,
 }}
 ENUM!{enum SPVLIMITS {
     SPMIN_VOLUME = 0,
     SPMAX_VOLUME = 100,
     SPMIN_RATE = -10i32 as u32,
     SPMAX_RATE = 10,
 }}
 ENUM!{enum SPVPRIORITY {
     SPVPRI_NORMAL = 0,
     SPVPRI_ALERT = 1 << 0,
     SPVPRI_OVER = 1 << 1,
 }}
 STRUCT!{struct SPVOICESTATUS {
     ulCurrentStream: ULONG,
     ulLastStreamQueued: ULONG,
     hrLastResult: HRESULT,
     dwRunningState: DWORD,
     ulInputWordPos: ULONG,
     ulInputWordLen: ULONG,
     ulInputSentPos: ULONG,
     ulInputSentLen: ULONG,
     lBookmarkId: LONG,
     PhonemeId: SPPHONEID,
     VisemeId: SPVISEMES,
     dwReserved1: DWORD,
     dwReserved2: DWORD,
 }}
 ENUM!{enum SPEAKFLAGS {
     SPF_DEFAULT = 0,
     SPF_ASYNC = 1 << 0,
     SPF_PURGEBEFORESPEAK = 1 << 1,
     SPF_IS_FILENAME = 1 << 2,
     SPF_IS_XML = 1 << 3,
     SPF_IS_NOT_XML = 1 << 4,
     SPF_PERSIST_XML = 1 << 5,
     SPF_NLP_SPEAK_PUNC = 1 << 6,
     SPF_NLP_MASK = SPF_NLP_SPEAK_PUNC,
     SPF_VOICE_MASK = SPF_ASYNC | SPF_PURGEBEFORESPEAK
         | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML
         | SPF_NLP_MASK | SPF_PERSIST_XML,
     SPF_UNUSED_FLAGS = !SPF_VOICE_MASK,
 }}
 RIDL!{#[uuid(0x6c44df74, 0x72b9, 0x4992, 0xa1, 0xec, 0xef, 0x99, 0x6e, 0x04, 0x22, 0xd4)]
 interface ISpVoice(ISpVoiceVtbl): ISpEventSource(ISpEventSourceVtbl) {
     fn SetOutput(
         pUnkOutput: *mut IUnknown,
         fAllowFormatChanges: BOOL,
     ) -> HRESULT,
     fn GetOutputObjectToken(
         ppObjectToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetOutputStream(
         ppStream: *mut *mut ISpStreamFormat,
     ) -> HRESULT,
     fn Pause() -> HRESULT,
     fn Resume() -> HRESULT,
     fn SetVoice(
         pToken: *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetVoice(
         ppToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn Speak(
         pwcs: LPCWSTR,
         dwFlags: DWORD,
         pulStreamNumber: *mut ULONG,
     ) -> HRESULT,
     fn SpeakStream(
         pStream: *mut IStream,
         dwFlags: DWORD,
         pulStreamNumber: *mut ULONG,
     ) -> HRESULT,
     fn GetStatus(
         pStatus: *mut SPVOICESTATUS,
         ppszLastBookmark: *mut LPWSTR,
     ) -> HRESULT,
     fn Skip(
         pItemType: LPCWSTR,
         lNumItems: c_long,
         pulNumSkipped: *mut ULONG,
     ) -> HRESULT,
     fn SetPriority(
         ePriority: SPVPRIORITY,
     ) -> HRESULT,
     fn GetPriority(
         pePriority: *mut SPVPRIORITY,
     ) -> HRESULT,
     fn SetAlertBoundary(
         eBoundary: SPEVENTENUM,
     ) -> HRESULT,
     fn GetAlertBoundary(
         peBoundary: *mut SPEVENTENUM,
     ) -> HRESULT,
     fn SetRate(
         RateAdjust: c_long,
     ) -> HRESULT,
     fn GetRate(
         pRateAdjust: *mut c_long,
     ) -> HRESULT,
     fn SetVolume(
         usVolume: USHORT,
     ) -> HRESULT,
     fn GetVolume(
         pusVolume: *mut USHORT,
     ) -> HRESULT,
     fn WaitUntilDone(
         msTimeout: ULONG,
     ) -> HRESULT,
     fn SetSyncSpeakTimeout(
         msTimeout: ULONG,
     ) -> HRESULT,
     fn GetSyncSpeakTimeout(
         pmsTimeout: *mut ULONG,
     ) -> HRESULT,
     fn SpeakCompleteEvent() -> HANDLE,
     fn IsUISupported(
         pszTypeOfUI: LPCWSTR,
         pvExtraData: *mut c_void,
         cbExtraData: ULONG,
         pfSupported: *mut BOOL,
     ) -> HRESULT,
     fn DisplayUI(
         hwndParent: HWND,
         pszTitle: LPCWSTR,
         pszTypeOfUI: LPCWSTR,
         pvExtraData: *mut c_void,
         cbExtraData: ULONG,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x1a5c0354, 0xb621, 0x4b5a, 0x87, 0x91, 0xd3, 0x06, 0xed, 0x37, 0x9e, 0x53)]
 interface ISpPhrase(ISpPhraseVtbl): IUnknown(IUnknownVtbl) {
     fn GetPhrase(
         ppCoMemPhrase: *mut *mut SPPHRASE,
     ) -> HRESULT,
     fn GetSerializedPhrase(
         ppCoMemPhrase: *mut *mut SPSERIALIZEDPHRASE,
     ) -> HRESULT,
     fn GetText(
         ulStart: ULONG,
         ulCount: ULONG,
         fUseTextReplacements: BOOL,
         ppszCoMemText: *mut LPWSTR,
         pbDisplayAttributes: *mut BYTE,
     ) -> HRESULT,
     fn Discard(
         dwValueTypes: DWORD,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x8fcebc98, 0x4e49, 0x4067, 0x9c, 0x6c, 0xd8, 0x6a, 0x0e, 0x09, 0x2e, 0x3d)]
 interface ISpPhraseAlt(ISpPhraseAltVtbl): ISpPhrase(ISpPhraseVtbl) {
     fn GetAltInfo(
         pParent: *mut *mut ISpPhrase,
         pulStartElementInParent: *mut ULONG,
         pcElementsInParent: *mut ULONG,
         pcElementsInAlt: *mut ULONG,
     ) -> HRESULT,
     fn Commit() -> HRESULT,
 }}
 STRUCT!{struct SPRECORESULTTIMES {
     ftStreamTime: FILETIME,
     ullLength: ULONGLONG,
     dwTickCount: DWORD,
     ullStart: ULONGLONG,
 }}
 STRUCT!{struct SPSERIALIZEDRESULT {
     ulSerializedSize: ULONG,
 }}
 RIDL!{#[uuid(0x20b053be, 0xe235, 0x43cd, 0x9a, 0x2a, 0x8d, 0x17, 0xa4, 0x8b, 0x78, 0x42)]
 interface ISpRecoResult(ISpRecoResultVtbl): ISpPhrase(ISpPhraseVtbl) {
     fn GetResultTimes(
         pTimes: *mut SPRECORESULTTIMES,
     ) -> HRESULT,
     fn GetAlternates(
         ulStartElement: ULONG,
         cElements: ULONG,
         ulRequestCount: ULONG,
         ppPhrases: *mut *mut ISpPhraseAlt,
         pcPhrasesReturned: *mut ULONG,
     ) -> HRESULT,
     fn GetAudio(
         ulStartElement: ULONG,
         cElements: ULONG,
         ppStream: *mut *mut ISpStreamFormat,
     ) -> HRESULT,
     fn SpeakAudio(
         ulStartElement: ULONG,
         cElements: ULONG,
         dwFlags: DWORD,
         pulStreamNumber: *mut ULONG,
     ) -> HRESULT,
     fn Serialize(
         ppCoMemSerializedResult: *mut *mut SPSERIALIZEDRESULT,
     ) -> HRESULT,
     fn ScaleAudio(
         pAudioFormatId: *const GUID,
         pWaveFormatEx: *const WAVEFORMATEX,
     ) -> HRESULT,
     fn GetRecoContext(
         ppRecoContext: *mut *mut ISpRecoContext,
     ) -> HRESULT,
 }}
 STRUCT!{struct SPTEXTSELECTIONINFO {
     ulStartActiveOffset: ULONG,
     cchActiveChars: ULONG,
     ulStartSelection: ULONG,
     cchSelection: ULONG,
 }}
 ENUM!{enum SPWORDPRONOUNCEABLE {
     SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0,
     SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1,
     SPWP_KNOWN_WORD_PRONOUNCEABLE = 2,
 }}
 ENUM!{enum SPGRAMMARSTATE {
     SPGS_DISABLED = 0,
     SPGS_ENABLED = 1,
     SPGS_EXCLUSIVE = 3,
 }}
 ENUM!{enum SPCONTEXTSTATE {
     SPCS_DISABLED = 0,
     SPCS_ENABLED = 1,
 }}
 ENUM!{enum SPRULESTATE {
     SPRS_INACTIVE = 0,
     SPRS_ACTIVE = 1,
     SPRS_ACTIVE_WITH_AUTO_PAUSE = 3,
 }}
 pub const SP_STREAMPOS_ASAP: ULONGLONG = 0;
 pub const SP_STREAMPOS_REALTIME: ULONGLONG = -1i64 as u64;
 pub const SPRULETRANS_TEXTBUFFER: SPSTATEHANDLE = -1isize as SPSTATEHANDLE;
 pub const SPRULETRANS_WILDCARD: SPSTATEHANDLE = -2isize as SPSTATEHANDLE;
 pub const SPRULETRANS_DICTATION: SPSTATEHANDLE = -3isize as SPSTATEHANDLE;
 ENUM!{enum SPGRAMMARWORDTYPE {
     SPWT_DISPLAY,
     SPWT_LEXICAL,
     SPWT_PRONUNCIATION,
     SPWT_LEXICAL_NO_SPECIAL_CHARS,
 }}
 STRUCT!{struct SPPROPERTYINFO {
     pszName: LPCWSTR,
     ulId: ULONG,
     pszValue: LPCWSTR,
     vValue: VARIANT,
 }}
 ENUM!{enum SPCFGRULEATTRIBUTES {
     SPRAF_TopLevel = 1 << 0,
     SPRAF_Active = 1 << 1,
     SPRAF_Export = 1 << 2,
     SPRAF_Import = 1 << 3,
     SPRAF_Interpreter = 1 << 4,
     SPRAF_Dynamic = 1 << 5,
     SPRAF_AutoPause = 1 << 16,
 }}
 RIDL!{#[uuid(0x8137828f, 0x591a, 0x4a42, 0xbe, 0x58, 0x49, 0xea, 0x7e, 0xba, 0xac, 0x68)]
 interface ISpGrammarBuilder(ISpGrammarBuilderVtbl): IUnknown(IUnknownVtbl) {
     fn ResetGrammar(
         NewLanguage: WORD,
     ) -> HRESULT,
     fn GetRule(
         pszRuleName: LPCWSTR,
         dwRuleId: DWORD,
         dwAttributes: DWORD,
         fCreateIfNotExist: BOOL,
         phInitialState: *mut SPSTATEHANDLE,
     ) -> HRESULT,
     fn ClearRule(
         hState: SPSTATEHANDLE,
     ) -> HRESULT,
     fn CreateNewState(
         hState: SPSTATEHANDLE,
         phState: *mut SPSTATEHANDLE,
     ) -> HRESULT,
     fn AddWordTransition(
         hFromState: SPSTATEHANDLE,
         hToState: SPSTATEHANDLE,
         psz: LPCWSTR,
         pszSeparators: LPCWSTR,
         eWordType: SPGRAMMARWORDTYPE,
         Weight: c_float,
         pPropInfo: *const SPPROPERTYINFO,
     ) -> HRESULT,
     fn AddRuleTransition(
         hFromState: SPSTATEHANDLE,
         hToState: SPSTATEHANDLE,
         hRule: SPSTATEHANDLE,
         Weight: c_float,
         pPropInfo: *const SPPROPERTYINFO,
     ) -> HRESULT,
     fn AddResource(
         hRuleState: SPSTATEHANDLE,
         pszResourceName: LPCWSTR,
         pszResourceValue: LPCWSTR,
     ) -> HRESULT,
     fn Commit(
         dwReserved: DWORD,
     ) -> HRESULT,
 }}
 ENUM!{enum SPLOADOPTIONS {
     SPLO_STATIC = 0,
     SPLO_DYNAMIC = 1,
 }}
 RIDL!{#[uuid(0x2177db29, 0x7f45, 0x47d0, 0x85, 0x54, 0x06, 0x7e, 0x91, 0xc8, 0x05, 0x02)]
 interface ISpRecoGrammar(ISpRecoGrammarVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) {
     fn GetGrammarId(
         pullGrammarId: *mut ULONGLONG,
     ) -> HRESULT,
     fn GetRecoContext(
         ppRecoCtxt: *mut *mut ISpRecoContext,
     ) -> HRESULT,
     fn LoadCmdFromFile(
         pszFileName: LPCWSTR,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn LoadCmdFromObject(
         rcid: REFCLSID,
         pszGrammarName: LPCWSTR,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn LoadCmdFromResource(
         hModule: HMODULE,
         pszResourceName: LPCWSTR,
         pszResourceType: LPCWSTR,
         wLanguage: WORD,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn LoadCmdFromMemory(
         pGrammar: *const SPBINARYGRAMMAR,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn LoadCmdFromProprietaryGrammar(
         rguidParam: REFGUID,
         pszStringParam: LPCWSTR,
         pvDataPrarm: *const c_void,
         cbDataSize: ULONG,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn SetRuleState(
         pszName: LPCWSTR,
         pReserved: *mut c_void,
         NewState: SPRULESTATE,
     ) -> HRESULT,
     fn SetRuleIdState(
         ulRuleId: ULONG,
         NewState: SPRULESTATE,
     ) -> HRESULT,
     fn LoadDictation(
         pszTopicName: LPCWSTR,
         Options: SPLOADOPTIONS,
     ) -> HRESULT,
     fn UnloadDictation() -> HRESULT,
     fn SetDictationState(
         NewState: SPRULESTATE,
     ) -> HRESULT,
     fn SetWordSequenceData(
         pText: *const WCHAR,
         cchText: ULONG,
         pInfo: *const SPTEXTSELECTIONINFO,
     ) -> HRESULT,
     fn SetTextSelection(
         pInfo: *const SPTEXTSELECTIONINFO,
     ) -> HRESULT,
     fn IsPronounceable(
         pszWord: LPCWSTR,
         pWordPronounceable: *mut SPWORDPRONOUNCEABLE,
     ) -> HRESULT,
     fn SetGrammarState(
         eGrammarState: SPGRAMMARSTATE,
     ) -> HRESULT,
     fn SaveCmd(
         pStream: *mut IStream,
         ppszCoMemErrorText: *mut LPWSTR,
     ) -> HRESULT,
     fn GetGrammarState(
         peGrammarState: *mut SPGRAMMARSTATE,
     ) -> HRESULT,
 }}
 STRUCT!{struct SPRECOCONTEXTSTATUS {
     eInterference: SPINTERFERENCE,
     szRequestTypeOfUI: [WCHAR; 255],
     dwReserved1: DWORD,
     dwReserved2: DWORD,
 }}
 ENUM!{enum SPBOOKMARKOPTIONS {
     SPBO_NONE = 0,
     SPBO_PAUSE = 1 << 0,
 }}
 ENUM!{enum SPAUDIOOPTIONS {
     SPAO_NONE = 0,
     SPAO_RETAIN_AUDIO = 1 << 0,
 }}
 RIDL!{#[uuid(0xf740a62f, 0x7c15, 0x489e, 0x82, 0x34, 0x94, 0x0a, 0x33, 0xd9, 0x27, 0x2d)]
 interface ISpRecoContext(ISpRecoContextVtbl): ISpEventSource(ISpEventSourceVtbl) {
     fn GetRecognizer(
         ppRecognizer: *mut *mut ISpRecognizer,
     ) -> HRESULT,
     fn CreateGrammer(
         ullGrammarId: ULONGLONG,
         ppGrammar: *mut *mut ISpRecoGrammar,
     ) -> HRESULT,
     fn GetStatus(
         pState: *mut SPRECOCONTEXTSTATUS,
     ) -> HRESULT,
     fn GetMaxAlternates(
         pcAlternates: *mut ULONG,
     ) -> HRESULT,
     fn SetMaxAlternates(
         cAlternates: ULONG,
     ) -> HRESULT,
     fn SetAudioOptions(
         Options: SPAUDIOOPTIONS,
         pAudioFormatId: *const GUID,
         pWaveFormatEx: *const WAVEFORMATEX,
     ) -> HRESULT,
     fn GetAudioOptions(
         pOptions: *mut SPAUDIOOPTIONS,
         pAudioFormatId: *mut GUID,
         ppCoMemWFEX: *mut *mut WAVEFORMATEX,
     ) -> HRESULT,
     fn DeserializeResult(
         pSerializedResult: *const SPSERIALIZEDRESULT,
         ppResult: *mut *mut ISpRecoResult,
     ) -> HRESULT,
     fn Bookmark(
         Options: SPBOOKMARKOPTIONS,
         ullStreamPosition: ULONGLONG,
         lparamEvent: LPARAM,
     ) -> HRESULT,
     fn SetAdaptionData(
         pAdaptionData: LPCWSTR,
         cch: ULONG,
     ) -> HRESULT,
     fn Pause(
         dwReserved: DWORD,
     ) -> HRESULT,
     fn Resume(
         dwReserved: DWORD,
     ) -> HRESULT,
     fn SetVoice(
         pVoice: *mut ISpVoice,
         fAllowFormatChanges: BOOL,
     ) -> HRESULT,
     fn GetVoice(
         ppVoice: *mut *mut ISpVoice,
     ) -> HRESULT,
     fn SetVoicePurgeEvent(
         ullEventIntereset: ULONGLONG,
     ) -> HRESULT,
     fn GetVoicePurgeEvent(
         pullEventIntereset: *mut ULONGLONG,
     ) -> HRESULT,
     fn SetContextState(
         eContextState: SPCONTEXTSTATE,
     ) -> HRESULT,
     fn GetContextState(
         peContextState: *mut SPCONTEXTSTATE,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x5b4fb971, 0xb115, 0x4de1, 0xad, 0x97, 0xe4, 0x82, 0xe3, 0xbf, 0x6e, 0xe4)]
 interface ISpProperties(ISpPropertiesVtbl): IUnknown(IUnknownVtbl) {
     fn SetPropertyNum(
         pName: LPCWSTR,
         lValue: LONG,
     ) -> HRESULT,
     fn GetPropertyNum(
         pName: LPCWSTR,
         plValue: *mut LONG,
     ) -> HRESULT,
     fn SetPropertyString(
         pName: LPCWSTR,
         pValue: LPCWSTR,
     ) -> HRESULT,
     fn GetPropertyString(
         pName: LPCWSTR,
         ppCoMemValue: *mut LPWSTR,
     ) -> HRESULT,
 }}
 pub const SP_MAX_LANGIDS: usize = 20;
 STRUCT!{struct SPRECOGNIZERSTATUS {
     AudioStatus: SPAUDIOSTATUS,
     ullRecognitionStreamPos: ULONGLONG,
     ulStreamNumber: ULONG,
     ulNumActive: ULONG,
     clsidEngine: CLSID,
     cLangIDs: ULONG,
     aLangID: [WORD; SP_MAX_LANGIDS],
     ullRecognitionStreamTime: ULONGLONG,
 }}
 ENUM!{enum SPWAVEFORMATTYPE {
     SPWF_INPUT,
     SPWF_SRENGINE,
 }}
 pub type SPSTREAMFORMATTYPE = SPWAVEFORMATTYPE;
 ENUM!{enum SPRECOSTATE {
     SPRST_INACTIVE,
     SPRST_ACTIVE,
     SPRST_ACTIVE_ALWAYS,
     SPRST_INACTIVE_WITH_PURGE,
     SPRST_NUM_STATES,
 }}
 RIDL!{#[uuid(0xc2b5f241, 0xdaa0, 0x4507, 0x9e, 0x16, 0x5a, 0x1e, 0xaa, 0x2b, 0x7a, 0x5c)]
 interface ISpRecognizer(ISpRecognizerVtbl): ISpProperties(ISpPropertiesVtbl) {
     fn SetRecognizer(
         pRecognizer: *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetRecognizer(
         ppRecognizer: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn SetInput(
         pUnkInput: *mut IUnknown,
         fAllowFormatChanges: BOOL,
     ) -> HRESULT,
     fn GetInputObjectToken(
         ppToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn GetInputStream(
         ppStream: *mut *mut ISpStreamFormat,
     ) -> HRESULT,
     fn CreateRecoContext(
         ppNewCtxt: *mut *mut ISpRecoContext,
     ) -> HRESULT,
     fn GetRecoProfile(
         ppToken: *mut *mut ISpObjectToken,
     ) -> HRESULT,
     fn SetRecoProfile(
         pToken: *mut ISpObjectToken,
     ) -> HRESULT,
     fn IsSharedInstance() -> HRESULT,
     fn GetRecoState(
         pState: *mut SPRECOSTATE,
     ) -> HRESULT,
     fn SetRecoState(
         NewState: SPRECOSTATE,
     ) -> HRESULT,
     fn GetStatus(
         pStatus: *mut SPRECOGNIZERSTATUS,
     ) -> HRESULT,
     fn GetFormat(
         WaveFormatType: SPSTREAMFORMATTYPE,
         pFormatId: *mut GUID,
         ppCoMemWFEX: *mut WAVEFORMATEX,
     ) -> HRESULT,
     fn IsUISupported(
         pszTypeOfUI: LPCWSTR,
         pvExtraData: *mut c_void,
         cbExtraData: ULONG,
         pfSupported: *mut BOOL,
     ) -> HRESULT,
     fn DisplayUI(
         hwndParent: HWND,
         pszTitle: LPCWSTR,
         pszTypeOfUI: LPCWSTR,
         pvExtraData: *mut c_void,
         cbExtraData: ULONG,
     ) -> HRESULT,
     fn EmulateRecognition(
         pPhrase: *mut ISpPhrase,
     ) -> HRESULT,
 }}
 pub type SpeechLanguageId = c_long;
 ENUM!{enum DISPID_SpeechDataKey {
     DISPID_SDKSetBinaryValue = 1,
     DISPID_SDKGetBinaryValue,
     DISPID_SDKSetStringValue,
     DISPID_SDKGetStringValue,
     DISPID_SDKSetLongValue,
     DISPID_SDKGetlongValue,
     DISPID_SDKOpenKey,
     DISPID_SDKCreateKey,
     DISPID_SDKDeleteKey,
     DISPID_SDKDeleteValue,
     DISPID_SDKEnumKeys,
     DISPID_SDKEnumValues,
 }}
 ENUM!{enum DISPID_SpeechObjectToken {
     DISPID_SOTId = 1,
     DISPID_SOTDataKey,
     DISPID_SOTCategory,
     DISPID_SOTGetDescription,
     DISPID_SOTSetId,
     DISPID_SOTGetAttribute,
     DISPID_SOTCreateInstance,
     DISPID_SOTRemove,
     DISPID_SOTGetStorageFileName,
     DISPID_SOTRemoveStorageFileName,
     DISPID_SOTIsUISupported,
     DISPID_SOTDisplayUI,
     DISPID_SOTMatchesAttributes,
 }}
 ENUM!{enum SpeechDataKeyLocation {
     SDKLDefaultLocation = SPDKL_DefaultLocation,
     SDKLCurrentUser = SPDKL_CurrentUser,
     SDKLLocalMachine = SPDKL_LocalMachine,
     SDKLCurrentConfig = SPDKL_CurrentConfig,
 }}
 ENUM!{enum SpeechTokenContext {
     STCInprocServer = CLSCTX_INPROC_SERVER,
     STCInprocHandler = CLSCTX_INPROC_HANDLER,
     STCLocalServer = CLSCTX_LOCAL_SERVER,
     STCRemoteServer = CLSCTX_REMOTE_SERVER,
     STCAll = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
         | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
 }}
 ENUM!{enum SpeechTokenShellFolder {
     STSF_AppData = 0x1a,
     STSF_LocalAppData = 0x1c,
     STSF_CommonAppData = 0x23,
     STSF_FlagCreate = 0x8000,
 }}
 ENUM!{enum DISPID_SpeechObjectTokens {
     DISPID_SOTsCount = 1,
     DISPID_SOTsItem = DISPID_VALUE as u32,
     DISPID_SOTs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechObjectTokenCategory {
     DISPID_SOTCId = 1,
     DISPID_SOTCDefault,
     DISPID_SOTCSetId,
     DISPID_SOTCGetDataKey,
     DISPID_SOTCEnumerateTokens,
 }}
 ENUM!{enum SpeechAudioFormatType {
     SAFTDefault = -1i32 as u32,
     SAFTNoAssignedFormat = 0,
     SAFTText = 1,
     SAFTNonStandardFormat = 2,
     SAFTExtendedAudioFormat = 3,
     SAFT8kHz8BitMono = 4,
     SAFT8kHz8BitStereo = 5,
     SAFT8kHz16BitMono = 6,
     SAFT8kHz16BitStereo = 7,
     SAFT11kHz8BitMono = 8,
     SAFT11kHz8BitStereo = 9,
     SAFT11kHz16BitMono = 10,
     SAFT11kHz16BitStereo = 11,
     SAFT12kHz8BitMono = 12,
     SAFT12kHz8BitStereo = 13,
     SAFT12kHz16BitMono = 14,
     SAFT12kHz16BitStereo = 15,
     SAFT16kHz8BitMono = 16,
     SAFT16kHz8BitStereo = 17,
     SAFT16kHz16BitMono = 18,
     SAFT16kHz16BitStereo = 19,
     SAFT22kHz8BitMono = 20,
     SAFT22kHz8BitStereo = 21,
     SAFT22kHz16BitMono = 22,
     SAFT22kHz16BitStereo = 23,
     SAFT24kHz8BitMono = 24,
     SAFT24kHz8BitStereo = 25,
     SAFT24kHz16BitMono = 26,
     SAFT24kHz16BitStereo = 27,
     SAFT32kHz8BitMono = 28,
     SAFT32kHz8BitStereo = 29,
     SAFT32kHz16BitMono = 30,
     SAFT32kHz16BitStereo = 31,
     SAFT44kHz8BitMono = 32,
     SAFT44kHz8BitStereo = 33,
     SAFT44kHz16BitMono = 34,
     SAFT44kHz16BitStereo = 35,
     SAFT48kHz8BitMono = 36,
     SAFT48kHz8BitStereo = 37,
     SAFT48kHz16BitMono = 38,
     SAFT48kHz16BitStereo = 39,
     SAFTTrueSpeech_8kHz1BitMono = 40,
     SAFTCCITT_ALaw_8kHzMono = 41,
     SAFTCCITT_ALaw_8kHzStereo = 42,
     SAFTCCITT_ALaw_11kHzMono = 43,
     SAFTCCITT_ALaw_11kHzStereo = 44,
     SAFTCCITT_ALaw_22kHzMono = 45,
     SAFTCCITT_ALaw_22kHzStereo = 46,
     SAFTCCITT_ALaw_44kHzMono = 47,
     SAFTCCITT_ALaw_44kHzStereo = 48,
     SAFTCCITT_uLaw_8kHzMono = 49,
     SAFTCCITT_uLaw_8kHzStereo = 50,
     SAFTCCITT_uLaw_11kHzMono = 51,
     SAFTCCITT_uLaw_11kHzStereo = 52,
     SAFTCCITT_uLaw_22kHzMono = 53,
     SAFTCCITT_uLaw_22kHzStereo = 54,
     SAFTCCITT_uLaw_44kHzMono = 55,
     SAFTCCITT_uLaw_44kHzStereo = 56,
     SAFTADPCM_8kHzMono = 57,
     SAFTADPCM_8kHzStereo = 58,
     SAFTADPCM_11kHzMono = 59,
     SAFTADPCM_11kHzStereo = 60,
     SAFTADPCM_22kHzMono = 61,
     SAFTADPCM_22kHzStereo = 62,
     SAFTADPCM_44kHzMono = 63,
     SAFTADPCM_44kHzStereo = 64,
     SAFTGSM610_8kHzMono = 65,
     SAFTGSM610_11kHzMono = 66,
     SAFTGSM610_22kHzMono = 67,
     SAFTGSM610_44kHzMono = 68,
 }}
 ENUM!{enum DISPID_SpeechAudioFormat {
     DISPID_SAFType = 1,
     DISPID_SAFGuid,
     DISPID_SAFGetWaveFormatEx,
     DISPID_SAFSetWaveFormatEx,
 }}
 ENUM!{enum DISPID_SpeechBaseStream {
     DISPID_SBSFormat = 1,
     DISPID_SBSRead,
     DISPID_SBSWrite,
     DISPID_SBSSeek,
 }}
 ENUM!{enum SpeechStreamSeekPositionType {
     SSSPTRelativeToStart = STREAM_SEEK_SET,
     SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR,
     SSSPTRelativeToEnd = STREAM_SEEK_END,
 }}
 ENUM!{enum DISPID_SpeechAudio {
     DISPID_SAStatus = 200,
     DISPID_SABufferInfo,
     DISPID_SADefaultFormat,
     DISPID_SAVolume,
     DISPID_SABufferNotifySize,
     DISPID_SAEventHandle,
     DISPID_SASetState,
 }}
 ENUM!{enum SpeechAudioState {
     SASClosed = SPAS_CLOSED,
     SASStop = SPAS_STOP,
     SASPause = SPAS_PAUSE,
     SASRun = SPAS_RUN,
 }}
 ENUM!{enum DISPID_SpeechMMSysAudio {
     DISPID_SMSADeviceId = 300,
     DISPID_SMSALineId,
     DISPID_SMSAMMHandle,
 }}
 ENUM!{enum DISPID_SpeechFileStream {
     DISPID_SFSOpen = 100,
     DISPID_SFSClose,
 }}
 ENUM!{enum SpeechStreamFileMode {
     SSFMOpenForRead = SPFM_OPEN_READONLY,
     SSFMOpenReadWrite = SPFM_OPEN_READWRITE,
     SSFMCreate = SPFM_CREATE,
     SSFMCreateForWrite = SPFM_CREATE_ALWAYS,
 }}
 ENUM!{enum DISPID_SpeechCustomStream {
     DISPID_SCSBaseStream = 100,
 }}
 ENUM!{enum DISPID_SpeechMemoryStream {
     DISPID_SMSSetData = 100,
     DISPID_SMSGetData,
 }}
 ENUM!{enum DISPID_SpeechAudioStatus {
     DISPID_SASFreeBufferSpace = 1,
     DISPID_SASNonBlockingIO,
     DISPID_SASState,
     DISPID_SASCurrentSeekPosition,
     DISPID_SASCurrentDevicePosition,
 }}
 ENUM!{enum DISPID_SpeechAudioBufferInfo {
     DISPID_SABIMinNotification = 1,
     DISPID_SABIBufferSize,
     DISPID_SABIEventBias,
 }}
 ENUM!{enum DISPID_SpeechWaveFormatEx {
     DISPID_SWFEFormatTag = 1,
     DISPID_SWFEChannels,
     DISPID_SWFESamplesPerSec,
     DISPID_SWFEAvgBytesPerSec,
     DISPID_SWFEBlockAlign,
     DISPID_SWFEBitsPerSample,
     DISPID_SWFEExtraData,
 }}
 ENUM!{enum DISPID_SpeechVoice {
     DISPID_SVStatus = 1,
     DISPID_SVVoice,
     DISPID_SVAudioOutput,
     DISPID_SVAudioOutputStream,
     DISPID_SVRate,
     DISPID_SVVolume,
     DISPID_SVAllowAudioOuputFormatChangesOnNextSet,
     DISPID_SVEventInterests,
     DISPID_SVPriority,
     DISPID_SVAlertBoundary,
     DISPID_SVSyncronousSpeakTimeout,
     DISPID_SVSpeak,
     DISPID_SVSpeakStream,
     DISPID_SVPause,
     DISPID_SVResume,
     DISPID_SVSkip,
     DISPID_SVGetVoices,
     DISPID_SVGetAudioOutputs,
     DISPID_SVWaitUntilDone,
     DISPID_SVSpeakCompleteEvent,
     DISPID_SVIsUISupported,
     DISPID_SVDisplayUI,
 }}
 ENUM!{enum SpeechVoicePriority {
     SVPNormal = SPVPRI_NORMAL,
     SVPAlert = SPVPRI_ALERT,
     SVPOver = SPVPRI_OVER,
 }}
 ENUM!{enum SpeechVoiceSpeakFlags {
     SVSFDefault = SPF_DEFAULT,
     SVSFlagsAsync = SPF_ASYNC,
     SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK,
     SVSFIsFilename = SPF_IS_FILENAME,
     SVSFIsXML = SPF_IS_XML,
     SVSFIsNotXML = SPF_IS_NOT_XML,
     SVSFPersistXML = SPF_PERSIST_XML,
     SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC,
     SVSFNLPMask = SPF_NLP_MASK,
     SVSFVoiceMask = SPF_VOICE_MASK as u32,
     SVSFUnusedFlags = SPF_UNUSED_FLAGS as u32,
 }}
 ENUM!{enum SpeechVoiceEvents {
     SVEStartInputStream = 1 << 1,
     SVEEndInputStream = 1 << 2,
     SVEVoiceChange = 1 << 3,
     SVEBookmark = 1 << 4,
     SVEWordBoundary = 1 << 5,
     SVEPhoneme = 1 << 6,
     SVESentenceBoundary = 1 << 7,
     SVEViseme = 1 << 8,
     SVEAudioLevel = 1 << 9,
     SVEPrivate = 1 << 15,
     SVEAllEvents = 0x83fe,
 }}
 ENUM!{enum DISPID_SpeechVoiceStatus {
     DISPID_SVSCurrentStreamNumber = 1,
     DISPID_SVSLastStreamNumberQueued,
     DISPID_SVSLastResult,
     DISPID_SVSRunningState,
     DISPID_SVSInputWordPosition,
     DISPID_SVSInputWordLength,
     DISPID_SVSInputSentencePosition,
     DISPID_SVSInputSentenceLength,
     DISPID_SVSLastBookmark,
     DISPID_SVSLastBookmarkId,
     DISPID_SVSPhonemeId,
     DISPID_SVSVisemeId,
 }}
 ENUM!{enum SpeechRunState {
     SRSEDone = SPRS_DONE,
     SRSEIsSpeaking = SPRS_IS_SPEAKING,
 }}
 ENUM!{enum SpeechVisemeType {
     SVP_0 = 0,
     SVP_1,
     SVP_2,
     SVP_3,
     SVP_4,
     SVP_5,
     SVP_6,
     SVP_7,
     SVP_8,
     SVP_9,
     SVP_10,
     SVP_11,
     SVP_12,
     SVP_13,
     SVP_14,
     SVP_15,
     SVP_16,
     SVP_17,
     SVP_18,
     SVP_19,
     SVP_20,
     SVP_21,
 }}
 ENUM!{enum SpeechVisemeFeature {
     SVF_None = 0,
     SVF_Stressed = SPVFEATURE_STRESSED,
     SVF_Emphasis = SPVFEATURE_EMPHASIS,
 }}
 ENUM!{enum DISPID_SpeechVoiceEvent {
     DISPID_SVEStreamStart = 1,
     DISPID_SVEStreamEnd,
     DISPID_SVEVoiceChange,
     DISPID_SVEBookmark,
     DISPID_SVEWord,
     DISPID_SVEPhoneme,
     DISPID_SVESentenceBoundary,
     DISPID_SVEViseme,
     DISPID_SVEAudioLevel,
     DISPID_SVEEnginePrivate,
 }}
 ENUM!{enum DISPID_SpeechRecognizer {
     DISPID_SRRecognizer = 1,
     DISPID_SRAllowAudioInputFormatChangesOnNextSet,
     DISPID_SRAudioInput,
     DISPID_SRAudioInputStream,
     DISPID_SRIsShared,
     DISPID_SRState,
     DISPID_SRStatus,
     DISPID_SRProfile,
     DISPID_SREmulateRecognition,
     DISPID_SRCreateRecoContext,
     DISPID_SRGetFormat,
     DISPID_SRSetPropertyNumber,
     DISPID_SRGetPropertyNumber,
     DISPID_SRSetPropertyString,
     DISPID_SRGetPropertyString,
     DISPID_SRIsUISupported,
     DISPID_SRDisplayUI,
     DISPID_SRGetRecognizers,
     DISPID_SVGetAudioInputs,
     DISPID_SVGetProfiles,
 }}
 ENUM!{enum SpeechRecognizerState {
     SRSInactive = SPRST_INACTIVE,
     SRSActive = SPRST_ACTIVE,
     SRSActiveAlways = SPRST_ACTIVE_ALWAYS,
     SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE,
 }}
 ENUM!{enum SpeechDisplayAttributes {
     SDA_No_Trailing_Space = 0,
     SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE,
     SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES,
     SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES,
 }}
 ENUM!{enum SpeechFormatType {
     SFTInput = SPWF_INPUT,
     SFTSREngine = SPWF_SRENGINE,
 }}
 ENUM!{enum DISPID_SpeechRecognizerStatus {
     DISPID_SRSAudioStatus = 1,
     DISPID_SRSCurrentStreamPosition,
     DISPID_SRSCurrentStreamNumber,
     DISPID_SRSNumberOfActiveRules,
     DISPID_SRSClsidEngine,
     DISPID_SRSSupportedLanguages,
 }}
 ENUM!{enum DISPID_SpeechRecoContext {
     DISPID_SRCRecognizer = 1,
     DISPID_SRCAudioInInterferenceStatus,
     DISPID_SRCRequestedUIType,
     DISPID_SRCVoice,
     DISPID_SRAllowVoiceFormatMatchingOnNextSet,
     DISPID_SRCVoicePurgeEvent,
     DISPID_SRCEventInterests,
     DISPID_SRCCmdMaxAlternates,
     DISPID_SRCState,
     DISPID_SRCRetainedAudio,
     DISPID_SRCRetainedAudioFormat,
     DISPID_SRCPause,
     DISPID_SRCResume,
     DISPID_SRCCreateGrammar,
     DISPID_SRCCreateResultFromMemory,
     DISPID_SRCBookmark,
     DISPID_SRCSetAdaptationData,
 }}
 ENUM!{enum SpeechRetainedAudioOptions {
     SRAONone = SPAO_NONE,
     SRAORetainAudio = SPAO_RETAIN_AUDIO,
 }}
 ENUM!{enum SpeechBookmarkOptions {
     SBONone = SPBO_NONE,
     SBOPause = SPBO_PAUSE,
 }}
 ENUM!{enum SpeechInterference {
     SINone = SPINTERFERENCE_NONE,
     SINoise = SPINTERFERENCE_NOISE,
     SINoSignal = SPINTERFERENCE_NOSIGNAL,
     SITooLoud = SPINTERFERENCE_TOOLOUD,
     SITooQuiet = SPINTERFERENCE_TOOQUIET,
     SITooFast = SPINTERFERENCE_TOOFAST,
     SITooSlow = SPINTERFERENCE_TOOSLOW,
 }}
 ENUM!{enum SpeechRecoEvents {
     SREStreamEnd = 1 << 0,
     SRESoundStart = 1 << 1,
     SRESoundEnd = 1 << 2,
     SREPhraseStart = 1 << 3,
     SRERecognition = 1 << 4,
     SREHypothesis = 1 << 5,
     SREBookmark = 1 << 6,
     SREPropertyNumChange = 1 << 7,
     SREPropertyStringChange = 1 << 8,
     SREFalseRecognition = 1 << 9,
     SREInterference = 1 << 10,
     SRERequestUI = 1 << 11,
     SREStateChange = 1 << 12,
     SREAdaptation = 1 << 13,
     SREStreamStart = 1 << 14,
     SRERecoOtherContext = 1 << 15,
     SREAudioLevel = 1 << 16,
     SREPrivate = 1 << 18,
     SREAllEvents = 0x5ffff,
 }}
 ENUM!{enum SpeechRecoContextState {
     SRCS_Disabled = SPCS_DISABLED,
     SRCS_Enabled = SPCS_ENABLED,
 }}
 ENUM!{enum DISPIDSPRG {
     DISPID_SRGId = 1,
     DISPID_SRGRecoContext,
     DISPID_SRGState,
     DISPID_SRGRules,
     DISPID_SRGReset,
     DISPID_SRGCommit,
     DISPID_SRGCmdLoadFromFile,
     DISPID_SRGCmdLoadFromObject,
     DISPID_SRGCmdLoadFromResource,
     DISPID_SRGCmdLoadFromMemory,
     DISPID_SRGCmdLoadFromProprietaryGrammar,
     DISPID_SRGCmdSetRuleState,
     DISPID_SRGCmdSetRuleIdState,
     DISPID_SRGDictationLoad,
     DISPID_SRGDictationUnload,
     DISPID_SRGDictationSetState,
     DISPID_SRGSetWordSequenceData,
     DISPID_SRGSetTextSelection,
     DISPID_SRGIsPronounceable,
 }}
 ENUM!{enum SpeechLoadOption {
     SLOStatic = SPLO_STATIC,
     SLODynamic = SPLO_DYNAMIC,
 }}
 ENUM!{enum SpeechWordPronounceable {
     SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE,
     SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE,
     SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE,
 }}
 ENUM!{enum SpeechGrammarState {
     SGSEnabled = SPGS_ENABLED,
     SGSDisabled = SPGS_DISABLED,
     SGSExclusive = SPGS_EXCLUSIVE,
 }}
 ENUM!{enum SpeechRuleState {
     SGDSInactive = SPRS_INACTIVE,
     SGDSActive = SPRS_ACTIVE,
     SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE,
 }}
 ENUM!{enum SpeechRuleAttributes {
     SRATopLevel = SPRAF_TopLevel,
     SRADefaultToActive = SPRAF_Active,
     SRAExport = SPRAF_Export,
     SRAImport = SPRAF_Import,
     SRAInterpreter = SPRAF_Interpreter,
     SRADynamic = SPRAF_Dynamic,
 }}
 ENUM!{enum SpeechGrammarWordType {
     SGDisplay = SPWT_DISPLAY,
     SGLexical = SPWT_LEXICAL,
     SGPronounciation = SPWT_PRONUNCIATION,
 }}
 ENUM!{enum DISPID_SpeechRecoContextEvents {
     DISPID_SRCEStartStream = 1,
     DISPID_SRCEEndStream,
     DISPID_SRCEBookmark,
     DISPID_SRCESoundStart,
     DISPID_SRCESoundEnd,
     DISPID_SRCEPhraseStart,
     DISPID_SRCERecognition,
     DISPID_SRCEHypothesis,
     DISPID_SRCEPropertyNumberChange,
     DISPID_SRCEPropertyStringChange,
     DISPID_SRCEFalseRecognition,
     DISPID_SRCEInterference,
     DISPID_SRCERequestUI,
     DISPID_SRCERecognizerStateChange,
     DISPID_SRCEAdaptation,
     DISPID_SRCERecognitionForOtherContext,
     DISPID_SRCEAudioLevel,
     DISPID_SRCEEnginePrivate,
 }}
 ENUM!{enum SpeechRecognitionType {
     SRTStandard = 0,
     SRTAutopause = SPREF_AutoPause,
     SRTEmulated = SPREF_Emulated,
 }}
 ENUM!{enum DISPID_SpeechGrammarRule {
     DISPID_SGRAttributes = 1,
     DISPID_SGRInitialState,
     DISPID_SGRName,
     DISPID_SGRId,
     DISPID_SGRClear,
     DISPID_SGRAddResource,
     DISPID_SGRAddState,
 }}
 ENUM!{enum DISPID_SpeechGrammarRules {
     DISPID_SGRsCount = 1,
     DISPID_SGRsDynamic,
     DISPID_SGRsAdd,
     DISPID_SGRsCommit,
     DISPID_SGRsCommitAndSave,
     DISPID_SGRsFindRule,
     DISPID_SGRsItem = DISPID_VALUE as u32,
     DISPID_SGRs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechGrammarRuleState {
     DISPID_SGRSRule = 1,
     DISPID_SGRSTransitions,
     DISPID_SGRSAddWordTransition,
     DISPID_SGRSAddRuleTransition,
     DISPID_SGRSAddSpecialTransition,
 }}
 ENUM!{enum SpeechSpecialTransitionType {
     SSTTWildcard = 1,
     SSTTDictation,
     SSTTTextBuffer,
 }}
 ENUM!{enum DISPID_SpeechGrammarRuleStateTransitions {
     DISPID_SGRSTsCount = 1,
     DISPID_SGRSTsItem = DISPID_VALUE as u32,
     DISPID_SGRSTs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechGrammarRuleStateTransition {
     DISPID_SGRSTType = 1,
     DISPID_SGRSTText,
     DISPID_SGRSTRule,
     DISPID_SGRSTWeight,
     DISPID_SGRSTPropertyName,
     DISPID_SGRSTPropertyId,
     DISPID_SGRSTPropertyValue,
     DISPID_SGRSTNextState,
 }}
 ENUM!{enum SpeechGrammarRuleStateTransitionType {
     SGRSTTEpsilon = 0,
     SGRSTTWord,
     SGRSTTRule,
     SGRSTTDictation,
     SGRSTTWildcard,
     SGRSTTTextBuffer,
 }}
 ENUM!{enum DISPIDSPTSI {
     DISPIDSPTSI_ActiveOffset = 1,
     DISPIDSPTSI_ActiveLength,
     DISPIDSPTSI_SelectionOffset,
     DISPIDSPTSI_SelectionLength,
 }}
 ENUM!{enum DISPID_SpeechRecoResult {
     DISPID_SRRRecoContext = 1,
     DISPID_SRRTimes,
     DISPID_SRRAudioFormat,
     DISPID_SRRPhraseInfo,
     DISPID_SRRAlternates,
     DISPID_SRRAudio,
     DISPID_SRRSpeakAudio,
     DISPID_SRRSaveToMemory,
     DISPID_SRRDiscardResultInfo,
 }}
 ENUM!{enum SpeechDiscardType {
     SDTProperty = SPDF_PROPERTY,
     SDTReplacement = SPDF_REPLACEMENT,
     SDTRule = SPDF_RULE,
     SDTDisplayText = SPDF_DISPLAYTEXT,
     SDTLexicalForm = SPDF_LEXICALFORM,
     SDTPronunciation = SPDF_PRONUNCIATION,
     SDTAudio = SPDF_AUDIO,
     SDTAlternates = SPDF_ALTERNATES,
     SDTAll = SPDF_ALL,
 }}
 ENUM!{enum DISPID_SpeechPhraseBuilder {
     DISPID_SPPBRestorePhraseFromMemory = 1,
 }}
 ENUM!{enum DISPID_SpeechRecoResultTimes {
     DISPID_SRRTStreamTime = 1,
     DISPID_SRRTLength,
     DISPID_SRRTTickCount,
     DISPID_SRRTOffsetFromStart,
 }}
 ENUM!{enum DISPID_SpeechPhraseAlternate {
     DISPID_SPARecoResult = 1,
     DISPID_SPAStartElementInResult,
     DISPID_SPANumberOfElementsInResult,
     DISPID_SPAPhraseInfo,
     DISPID_SPACommit,
 }}
 ENUM!{enum DISPID_SpeechPhraseAlternates {
     DISPID_SPAsCount = 1,
     DISPID_SPAsItem = DISPID_VALUE as u32,
     DISPID_SPAs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechPhraseInfo {
     DISPID_SPILanguageId = 1,
     DISPID_SPIGrammarId,
     DISPID_SPIStartTime,
     DISPID_SPIAudioStreamPosition,
     DISPID_SPIAudioSizeBytes,
     DISPID_SPIRetainedSizeBytes,
     DISPID_SPIAudioSizeTime,
     DISPID_SPIRule,
     DISPID_SPIProperties,
     DISPID_SPIElements,
     DISPID_SPIReplacements,
     DISPID_SPIEngineId,
     DISPID_SPIEnginePrivateData,
     DISPID_SPISaveToMemory,
     DISPID_SPIGetText,
     DISPID_SPIGetDisplayAttributes,
 }}
 ENUM!{enum DISPID_SpeechPhraseElement {
     DISPID_SPEAudioTimeOffset = 1,
     DISPID_SPEAudioSizeTime,
     DISPID_SPEAudioStreamOffset,
     DISPID_SPEAudioSizeBytes,
     DISPID_SPERetainedStreamOffset,
     DISPID_SPERetainedSizeBytes,
     DISPID_SPEDisplayText,
     DISPID_SPELexicalForm,
     DISPID_SPEPronunciation,
     DISPID_SPEDisplayAttributes,
     DISPID_SPERequiredConfidence,
     DISPID_SPEActualConfidence,
     DISPID_SPEEngineConfidence,
 }}
 ENUM!{enum SpeechEngineConfidence {
     SECLowConfidence = -1i32 as u32,
     SECNormalConfidence = 0,
     SECHighConfidence = 1,
 }}
 ENUM!{enum DISPID_SpeechPhraseElements {
     DISPID_SPEsCount = 1,
     DISPID_SPEsItem = DISPID_VALUE as u32,
     DISPID_SPEs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechPhraseReplacement {
     DISPID_SPRDisplayAttributes = 1,
     DISPID_SPRText,
     DISPID_SPRFirstElement,
     DISPID_SPRNumberOfElements,
 }}
 ENUM!{enum DISPID_SpeechPhraseReplacements {
     DISPID_SPRsCount = 1,
     DISPID_SPRsItem = DISPID_VALUE as u32,
     DISPID_SPRs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechPhraseProperty {
     DISPID_SPPName = 1,
     DISPID_SPPId,
     DISPID_SPPValue,
     DISPID_SPPFirstElement,
     DISPID_SPPNumberOfElements,
     DISPID_SPPEngineConfidence,
     DISPID_SPPConfidence,
     DISPID_SPPParent,
     DISPID_SPPChildren,
 }}
 ENUM!{enum DISPID_SpeechPhraseProperties {
     DISPID_SPPsCount = 1,
     DISPID_SPPsItem = DISPID_VALUE as u32,
     DISPID_SPPs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechPhraseRule {
     DISPID_SPRuleName = 1,
     DISPID_SPRuleId,
     DISPID_SPRuleFirstElement,
     DISPID_SPRuleNumberOfElements,
     DISPID_SPRuleParent,
     DISPID_SPRuleChildren,
     DISPID_SPRuleConfidence,
     DISPID_SPRuleEngineConfidence,
 }}
 ENUM!{enum DISPID_SpeechPhraseRules {
     DISPID_SPRulesCount = 1,
     DISPID_SPRulesItem = DISPID_VALUE as u32,
     DISPID_SPRules_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechLexicon {
     DISPID_SLGenerationId = 1,
     DISPID_SLGetWords,
     DISPID_SLAddPronunciation,
     DISPID_SLAddPronunciationByPhoneIds,
     DISPID_SLRemovePronunciation,
     DISPID_SLRemovePronunciationByPhoneIds,
     DISPID_SLGetPronunciations,
     DISPID_SLGetGenerationChange,
 }}
 ENUM!{enum SpeechLexiconType {
     SLTUser = eLEXTYPE_USER,
     SLTApp = eLEXTYPE_APP,
 }}
 ENUM!{enum SpeechPartOfSpeech {
     SPSNotOverriden = SPPS_NotOverriden,
     SPSUnknown = SPPS_Unknown,
     SPSNoun = SPPS_Noun,
     SPSVerb = SPPS_Verb,
     SPSModifier = SPPS_Modifier,
     SPSFunction = SPPS_Function,
     SPSInterjection = SPPS_Interjection,
 }}
 ENUM!{enum DISPID_SpeechLexiconWords {
     DISPID_SLWsCount = 1,
     DISPID_SLWsItem = DISPID_VALUE as u32,
     DISPID_SLWs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum SpeechWordType {
     SWTAdded = eWORDTYPE_ADDED,
     SWTDeleted = eWORDTYPE_DELETED,
 }}
 ENUM!{enum DISPID_SpeechLexiconWord {
     DISPID_SLWLangId = 1,
     DISPID_SLWType,
     DISPID_SLWWord,
     DISPID_SLWPronunciations,
 }}
 ENUM!{enum DISPID_SpeechLexiconProns {
     DISPID_SLPsCount = 1,
     DISPID_SLPsItem = DISPID_VALUE as u32,
     DISPID_SLPs_NewEnum = DISPID_NEWENUM as u32,
 }}
 ENUM!{enum DISPID_SpeechLexiconPronunciation {
     DISPID_SLPType = 1,
     DISPID_SLPLangId,
     DISPID_SLPPartOfSpeech,
     DISPID_SLPPhoneIds,
     DISPID_SLPSymbolic,
 }}
 ENUM!{enum DISPID_SpeechPhoneConverter {
     DISPID_SPCLangId = 1,
     DISPID_SPCPhoneToId,
     DISPID_SPCIdToPhone,
 }}
 extern {
     pub static LIBID_SpeechLib: IID;
 }
 RIDL!{#[uuid(0xce17c09b, 0x4efa, 0x44d5, 0xa4, 0xc9, 0x59, 0xd9, 0x58, 0x5a, 0xb0, 0xcd)]
 interface ISpeechDataKey(ISpeechDataKeyVtbl): IDispatch(IDispatchVtbl) {
     fn SetBinaryValue(
         ValueName: BSTR,
         Value: VARIANT,
     ) -> HRESULT,
     fn GetBinaryValue(
         ValueName: BSTR,
         Value: *mut VARIANT,
     ) -> HRESULT,
     fn SetStringValue(
         ValueName: BSTR,
         Value: BSTR,
     ) -> HRESULT,
     fn GetStringValue(
         ValueName: BSTR,
         Value: *mut BSTR,
     ) -> HRESULT,
     fn SetLongValue(
         ValueName: BSTR,
         Value: c_long,
     ) -> HRESULT,
     fn GetLongValue(
         ValueName: BSTR,
         Value: *mut c_long,
     ) -> HRESULT,
     fn OpenKey(
         SubKeyName: BSTR,
         SubKey: *mut *mut ISpeechDataKey,
     ) -> HRESULT,
     fn CreateKey(
         SubKeyName: BSTR,
         SubKey: *mut *mut ISpeechDataKey,
     ) -> HRESULT,
     fn DeleteKey(
         SubKeyName: BSTR,
     ) -> HRESULT,
     fn DeleteValue(
         ValueName: BSTR,
     ) -> HRESULT,
     fn EnumKeys(
         Index: c_long,
         SubKeyName: *mut BSTR,
     ) -> HRESULT,
     fn EnumValues(
         Index: c_long,
         ValueName: *mut BSTR,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xc74a3adc, 0xb727, 0x4500, 0xa8, 0x4a, 0xb5, 0x26, 0x72, 0x1c, 0x8b, 0x8c)]
 interface ISpeechObjectToken(ISpeechObjectTokenVtbl): IDispatch(IDispatchVtbl) {
     fn get_Id(
         ObjectId: *mut BSTR,
     ) -> HRESULT,
     fn get_DataKey(
         DataKey: *mut *mut ISpeechDataKey,
     ) -> HRESULT,
     fn get_Category(
         Category: *mut *mut ISpeechObjectTokenCategory,
     ) -> HRESULT,
     fn GetDescription(
         Locale: c_long,
         Description: *mut BSTR,
     ) -> HRESULT,
     fn SetId(
         Id: BSTR,
         CategoryId: BSTR,
         CreateIfNotExist: VARIANT_BOOL,
     ) -> HRESULT,
     fn GetAttribute(
         AttributeName: BSTR,
         AttributeValue: *mut BSTR,
     ) -> HRESULT,
     fn CreateInstance(
         pUnkOuter: *mut IUnknown,
         ClsContext: SpeechTokenContext,
         Object: *mut *mut IUnknown,
     ) -> HRESULT,
     fn Remove(
         ObjectStorageCLSID: BSTR,
     ) -> HRESULT,
     fn GetStorageFileName(
         ObjectStorageCLSID: BSTR,
         KeyName: BSTR,
         FileName: BSTR,
         Folder: BSTR,
         FilePath: *mut BSTR,
     ) -> HRESULT,
     fn RemoveStorageFileName(
         ObjectStorageCLSID: BSTR,
         KeyName: BSTR,
         DeleteFile: VARIANT_BOOL,
     ) -> HRESULT,
     fn IsUISupported(
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
         Object: *mut IUnknown,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn DisplayUI(
         hWnd: c_long,
         Title: BSTR,
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
         Object: *mut IUnknown,
     ) -> HRESULT,
     fn MatchesAttributes(
         Attributes: BSTR,
         Matches: *mut VARIANT_BOOL,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x9285b776, 0x2e7b, 0x4bc0, 0xb5, 0x3e, 0x58, 0x0e, 0xb6, 0xfa, 0x96, 0x7f)]
 interface ISpeechObjectTokens(ISpeechObjectTokensVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Token: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get__NewEnum(
         ppEnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xca7eac50, 0x2d01, 0x4145, 0x86, 0xd4, 0x5a, 0xe7, 0xd7, 0x0f, 0x44, 0x69)]
 interface ISpeechObjectTokenCategory(ISpeechObjectTokenCategoryVtbl): IDispatch(IDispatchVtbl) {
     fn get_Id(
         Id: *mut BSTR,
     ) -> HRESULT,
     fn put_Default(
         TokenId: BSTR,
     ) -> HRESULT,
     fn get_Default(
         TokenId: *mut BSTR,
     ) -> HRESULT,
     fn SetId(
         Id: BSTR,
         CreateIfNotExist: VARIANT_BOOL,
     ) -> HRESULT,
     fn GetDataKey(
         Location: SpeechDataKeyLocation,
         DataKey: *mut *mut ISpeechDataKey,
     ) -> HRESULT,
     fn EnumerateTokens(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         Tokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x11b103d8, 0x1142, 0x4edf, 0xa0, 0x93, 0x82, 0xfb, 0x39, 0x15, 0xf8, 0xcc)]
 interface ISpeechAudioBufferInfo(ISpeechAudioBufferInfoVtbl): IDispatch(IDispatchVtbl) {
     fn get_MinNotification(
         MinNotification: *mut c_long,
     ) -> HRESULT,
     fn put_MinNotification(
         MinNotification: c_long,
     ) -> HRESULT,
     fn get_BufferSize(
         BufferSize: *mut c_long,
     ) -> HRESULT,
     fn put_BufferSize(
         BufferSize: c_long,
     ) -> HRESULT,
     fn get_EventBias(
         EventBias: *mut c_long,
     ) -> HRESULT,
     fn put_EventBias(
         EventBias: c_long,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xc62d9c91, 0x7458, 0x47f6, 0x86, 0x2d, 0x1e, 0xf8, 0x6f, 0xb0, 0xb2, 0x78)]
 interface ISpeechAudioStatus(ISpeechAudioStatusVtbl): IDispatch(IDispatchVtbl) {
     fn get_FreeBufferSpace(
         FreeBufferSpace: *mut c_long,
     ) -> HRESULT,
     fn get_NonBlockingIO(
         NonBlockingIO: *mut c_long,
     ) -> HRESULT,
     fn get_State(
         State: *mut SpeechAudioState,
     ) -> HRESULT,
     fn get_CurrentSeekPosition(
         CurrentSeekPosition: *mut VARIANT,
     ) -> HRESULT,
     fn get_CurrentDevicePosition(
         CurrentDevicePosition: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xe6e9c590, 0x3e18, 0x40e3, 0x82, 0x99, 0x06, 0x1f, 0x98, 0xbd, 0xe7, 0xc7)]
 interface ISpeechAudioFormat(ISpeechAudioFormatVtbl): IDispatch(IDispatchVtbl) {
     fn get_Type(
         AudioFormat: *mut SpeechAudioFormatType,
     ) -> HRESULT,
     fn put_Type(
         AudioFormat: SpeechAudioFormatType,
     ) -> HRESULT,
     fn get_Guid(
         Guid: *mut BSTR,
     ) -> HRESULT,
     fn put_Guid(
         Guid: BSTR,
     ) -> HRESULT,
     fn GetWaveFormatEx(
         SpeechWaveFormatEx: *mut *mut ISpeechWaveFormatEx,
     ) -> HRESULT,
     fn SetWaveFormatEx(
         SpeechWaveFormatEx: *mut ISpeechWaveFormatEx,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x7a1ef0d5, 0x1581, 0x4741, 0x88, 0xe4, 0x20, 0x9a, 0x49, 0xf1, 0x1a, 0x10)]
 interface ISpeechWaveFormatEx(ISpeechWaveFormatExVtbl): IDispatch(IDispatchVtbl) {
     fn get_FormatTag(
         FormatTag: *mut c_short,
     ) -> HRESULT,
     fn put_FormatTag(
         FormatTag: c_short,
     ) -> HRESULT,
     fn get_Channels(
         Channels: *mut c_short,
     ) -> HRESULT,
     fn put_Channels(
         Channels: c_short,
     ) -> HRESULT,
     fn get_SamplesPerSec(
         SamplesPerSec: *mut c_long,
     ) -> HRESULT,
     fn put_SamplesPerSec(
         SamplesPerSec: c_long,
     ) -> HRESULT,
     fn get_AvgBytesPerSec(
         AvgBytesPerSec: *mut c_long,
     ) -> HRESULT,
     fn put_AvgBytesPerSec(
         AvgBytesPerSec: c_long,
     ) -> HRESULT,
     fn get_BlockAlign(
         BlockAlign: *mut c_short,
     ) -> HRESULT,
     fn put_BlockAlign(
         BlockAlign: c_short,
     ) -> HRESULT,
     fn get_BitsPerSample(
         BitsPerSample: *mut c_short,
     ) -> HRESULT,
     fn put_BitsPerSample(
         BitsPerSample: c_short,
     ) -> HRESULT,
     fn get_ExtraData(
         ExtraData: *mut VARIANT,
     ) -> HRESULT,
     fn put_ExtraData(
         ExtraData: VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x6450336f, 0x7d49, 0x4ced, 0x80, 0x97, 0x49, 0xd6, 0xde, 0xe3, 0x72, 0x94)]
 interface ISpeechBaseStream(ISpeechBaseStreamVtbl): IDispatch(IDispatchVtbl) {
     fn get_Format(
         AudioFormat: *mut *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn putref_Format(
         AudioFormat: *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn Read(
         Buffer: *mut VARIANT,
         NumberOfBytes: c_long,
         BytesRead: *mut c_long,
     ) -> HRESULT,
     fn Write(
         Buffer: VARIANT,
         BytesWritten: *mut c_long,
     ) -> HRESULT,
     fn Seek(
         Position: VARIANT,
         Origin: SpeechStreamSeekPositionType,
         NewPosition: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xaf67f125, 0xab39, 0x4e93, 0xb4, 0xa2, 0xcc, 0x2e, 0x66, 0xe1, 0x82, 0xa7)]
 interface ISpeechFileStream(ISpeechFileStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
     fn Open(
         FileName: BSTR,
         FileMode: SpeechStreamFileMode,
         DoEvents: VARIANT_BOOL,
     ) -> HRESULT,
     fn Close() -> HRESULT,
 }}
 RIDL!{#[uuid(0xeeb14b68, 0x808b, 0x4abe, 0xa5, 0xea, 0xb5, 0x1d, 0xa7, 0x58, 0x80, 0x08)]
 interface ISpeechMemoryStream(ISpeechMemoryStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
     fn SetData(
         Data: VARIANT,
     ) -> HRESULT,
     fn GetData(
         pData: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x1a9e9f4f, 0x104f, 0x4db8, 0xa1, 0x15, 0xef, 0xd7, 0xfd, 0x0c, 0x97, 0xae)]
 interface ISpeechCustomStream(ISpeechCustomStreamVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
     fn get_BaseStream(
         ppUnkStream: *mut *mut IUnknown,
     ) -> HRESULT,
     fn putref_BaseStream(
         pUnkStream: *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xcff8e175, 0x019e, 0x11d3, 0xa0, 0x8e, 0x00, 0xc0, 0x4f, 0x8e, 0xf9, 0xb5)]
 interface ISpeechAudio(ISpeechAudioVtbl): ISpeechBaseStream(ISpeechBaseStreamVtbl) {
     fn get_Status(
         Status: *mut *mut ISpeechAudioStatus,
     ) -> HRESULT,
     fn get_BufferInfo(
         BufferInfo: *mut *mut ISpeechAudioBufferInfo,
     ) -> HRESULT,
     fn get_DefaultFormat(
         StreamFormat: *mut *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn get_Volume(
         Volume: *mut c_long,
     ) -> HRESULT,
     fn put_Volume(
         Volume: c_long,
     ) -> HRESULT,
     fn get_BufferNotifySize(
         BufferNotifySize: *mut c_long,
     ) -> HRESULT,
     fn put_BufferNotifySize(
         BufferNotifySize: c_long,
     ) -> HRESULT,
     fn get_EventHandle(
         EventHandle: *mut c_long,
     ) -> HRESULT,
     fn SetState(
         State: SpeechAudioState,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x3c76af6d, 0x1fd7, 0x4831, 0x81, 0xd1, 0x3b, 0x71, 0xd5, 0xa1, 0x3c, 0x44)]
 interface ISpeechMMSysAudio(ISpeechMMSysAudioVtbl): ISpeechAudio(ISpeechAudioVtbl) {
     fn get_DeviceId(
         DeviceId: *mut c_long,
     ) -> HRESULT,
     fn put_DeviceId(
         DeviceId: c_long,
     ) -> HRESULT,
     fn get_LineId(
         LineId: *mut c_long,
     ) -> HRESULT,
     fn put_LineId(
         LineId: c_long,
     ) -> HRESULT,
     fn get_MMHandle(
         Handle: *mut c_long,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x269316d8, 0x57bd, 0x11d2, 0x9e, 0xee, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
 interface ISpeechVoice(ISpeechVoiceVtbl): IDispatch(IDispatchVtbl) {
     fn get_Status(
         Status: *mut *mut ISpeechVoiceStatus,
     ) -> HRESULT,
     fn get_Voice(
         Voice: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn putref_Voice(
         Voice: *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get_AudioOutput(
         AudioOutput: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn putref_AudioOutput(
         AudioOutput: *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get_AudioOutputStream(
         AudioOutputStream: *mut *mut ISpeechBaseStream,
     ) -> HRESULT,
     fn putref_AudioOutputStream(
         AudioOutputStream: *mut ISpeechBaseStream,
     ) -> HRESULT,
     fn get_Rate(
         Rate: *mut c_long,
     ) -> HRESULT,
     fn put_Rate(
         Rate: c_long,
     ) -> HRESULT,
     fn get_Volume(
         Volume: *mut c_long,
     ) -> HRESULT,
     fn put_Volume(
         Volume: c_long,
     ) -> HRESULT,
     fn put_AllowAudioOutputFormatChangesOnNextSet(
         Allow: VARIANT_BOOL,
     ) -> HRESULT,
     fn get_AllowAudioOutputFormatChangesOnNextSet(
         Allow: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn get_EventInterests(
         EventInterestFlags: *mut SpeechVoiceEvents,
     ) -> HRESULT,
     fn put_EventInterests(
         EventInterestFlags: SpeechVoiceEvents,
     ) -> HRESULT,
     fn put_Priority(
         Priority: SpeechVoicePriority,
     ) -> HRESULT,
     fn get_Priority(
         Priority: *mut SpeechVoicePriority,
     ) -> HRESULT,
     fn put_AlertBoundary(
         Boundary: SpeechVoiceEvents,
     ) -> HRESULT,
     fn get_AlertBoundary(
         Boundary: *mut SpeechVoiceEvents,
     ) -> HRESULT,
     fn put_SynchronousSpeakTimeout(
         msTimeout: c_long,
     ) -> HRESULT,
     fn get_SynchronousSpeakTimeout(
         msTimeOut: *mut c_long,
     ) -> HRESULT,
     fn Speak(
         Text: BSTR,
         Flags: SpeechVoiceSpeakFlags,
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn SpeakStream(
         Stream: *mut ISpeechBaseStream,
         Flags: SpeechVoiceSpeakFlags,
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn Pause() -> HRESULT,
     fn Resume() -> HRESULT,
     fn Skip(
         Type: BSTR,
         NumItems: c_long,
         NumSkipped: c_long,
     ) -> HRESULT,
     fn GetVoices(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         ObjectTokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
     fn GetAudioOutputs(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         ObjectTokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
     fn WaitUntilDone(
         msTimeout: c_long,
         Done: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn SpeakCompleteEvent(
         Handle: *mut c_long,
     ) -> HRESULT,
     fn IsUISupported(
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn DisplayUI(
         hWndParent: c_long,
         Title: BSTR,
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x8be47b07, 0x57f6, 0x11d2, 0x9e, 0xee, 0x00, 0xc0, 0x4f, 0x79, 0x73, 0x96)]
 interface ISpeechVoiceStatus(ISpeechVoiceStatusVtbl): IDispatch(IDispatchVtbl) {
     fn get_CurrentStreamNumber(
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn get_LastStreamNumberQueued(
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn get_LastHResult(
         HResult: *mut c_long,
     ) -> HRESULT,
     fn get_RunningState(
         State: *mut SpeechRunState,
     ) -> HRESULT,
     fn get_InputWordPosition(
         Position: *mut c_long,
     ) -> HRESULT,
     fn get_InputWordLength(
         Length: *mut c_long,
     ) -> HRESULT,
     fn get_InputSentencePosition(
         Position: *mut c_long,
     ) -> HRESULT,
     fn get_InputSentenceLength(
         Length: *mut c_long,
     ) -> HRESULT,
     fn get_LastBookmark(
         Bookmark: *mut BSTR,
     ) -> HRESULT,
     fn get_LastBookmarkId(
         BookmarkId: *mut c_long,
     ) -> HRESULT,
     fn get_PhonemeId(
         PhoneId: *mut c_short,
     ) -> HRESULT,
     fn get_VisemeId(
         VisemeId: *mut c_short,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xa372acd1, 0x3bef, 0x4bbd, 0x8f, 0xfb, 0xcb, 0x3e, 0x2b, 0x41, 0x6a, 0xf8)]
 interface _ISpeechVoiceEvents(_ISpeechVoiceEventsVtbl): IDispatch(IDispatchVtbl) {}}
 RIDL!{#[uuid(0x2d5f1c0c, 0xbd75, 0x4b08, 0x94, 0x78, 0x3b, 0x11, 0xfe, 0xa2, 0x58, 0x6c)]
 interface ISpeechRecognizer(ISpeechRecognizerVtbl): IDispatch(IDispatchVtbl) {
     fn putref_Recognizer(
         Recognizer: *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get_Recognizer(
         Recognizer: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn put_AllowAudioInputFormatChangesOnNextSet(
         Allow: VARIANT_BOOL,
     ) -> HRESULT,
     fn get_AllowAudioInputFormatChangesOnNextSet(
         Allow: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn putref_AudioInput(
         AudioInput: *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get_AudioInput(
         AudioInput: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn putref_AudioInputStream(
         AudioInputStream: *mut ISpeechBaseStream,
     ) -> HRESULT,
     fn get_AudioInputStream(
         AudioInputStream: *mut *mut ISpeechBaseStream,
     ) -> HRESULT,
     fn get_IsShared(
         Shared: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn put_State(
         State: SpeechRecognizerState,
     ) -> HRESULT,
     fn get_State(
         State: *mut SpeechRecognizerState,
     ) -> HRESULT,
     fn get_Status(
         Status: *mut *mut ISpeechRecognizerStatus,
     ) -> HRESULT,
     fn putref_Profile(
         Profile: *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn get_Profile(
         Profile: *mut *mut ISpeechObjectToken,
     ) -> HRESULT,
     fn EmulateRecognition(
         TextElements: VARIANT,
         ElementDisplayAttributes: *mut VARIANT,
         LanguageId: c_long,
     ) -> HRESULT,
     fn CreateRecoContext(
         NewContext: *mut *mut ISpeechRecoContext,
     ) -> HRESULT,
     fn GetFormat(
         Type: SpeechFormatType,
         Format: *mut *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn SetPropertyNumber(
         Name: BSTR,
         Value: c_long,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn GetPropertyNumber(
         Name: BSTR,
         Value: *mut c_long,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn SetPropertyString(
         Name: BSTR,
         Value: BSTR,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn GetPropertyString(
         Name: BSTR,
         Value: *mut BSTR,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn IsUISupported(
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
         Supported: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn DisplayUI(
         hWndParent: c_long,
         Title: BSTR,
         TypeOfUI: BSTR,
         ExtraData: *const VARIANT,
     ) -> HRESULT,
     fn GetRecognizers(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         ObjectTokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
     fn GetAudioInputs(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         ObjectTokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
     fn GetProfiles(
         RequiredAttributes: BSTR,
         OptionalAttributes: BSTR,
         ObjectTokens: *mut *mut ISpeechObjectTokens,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xbff9e781, 0x53ec, 0x484e, 0xbb, 0x8a, 0x0e, 0x1b, 0x55, 0x51, 0xe3, 0x5c)]
 interface ISpeechRecognizerStatus(ISpeechRecognizerStatusVtbl): IDispatch(IDispatchVtbl) {
     fn get_AudioStatus(
         AudioStatus: *mut *mut ISpeechAudioStatus,
     ) -> HRESULT,
     fn get_CurrentStreamPosition(
         pCurrentStreamPos: *mut VARIANT,
     ) -> HRESULT,
     fn get_CurrentStreamNumber(
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn get_NumberOfActiveRules(
         NumberOfActiveRules: *mut c_long,
     ) -> HRESULT,
     fn get_ClsidEngine(
         ClsidEngine: *mut BSTR,
     ) -> HRESULT,
     fn get_SupportedLanguages(
         SupportedLanguages: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x580aa49d, 0x7e1e, 0x4809, 0xb8, 0xe2, 0x57, 0xda, 0x80, 0x61, 0x04, 0xb8)]
 interface ISpeechRecoContext(ISpeechRecoContextVtbl): IDispatch(IDispatchVtbl) {
     fn get_Recognizer(
         Recognizer: *mut *mut ISpeechRecognizer,
     ) -> HRESULT,
     fn get_AudioInputInterferenceStatus(
         Interference: *mut SpeechInterference,
     ) -> HRESULT,
     fn get_RequestedUIType(
         UIType: *mut BSTR,
     ) -> HRESULT,
     fn putref_Voice(
         Voice: *mut ISpeechVoice,
     ) -> HRESULT,
     fn get_Voice(
         Voice: *mut *mut ISpeechVoice,
     ) -> HRESULT,
     fn put_AllowVoiceFormatMatchingOnNextSet(
         Allow: VARIANT_BOOL,
     ) -> HRESULT,
     fn get_AllowVoiceFormatMatchingOnNextSet(
         Allow: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn put_VoicePurgeEvent(
         EventInterest: SpeechRecoEvents,
     ) -> HRESULT,
     fn get_VoicePurgeEvent(
         EventInterest: *mut SpeechRecoEvents,
     ) -> HRESULT,
     fn put_EventInterests(
         EventInterest: SpeechRecoEvents,
     ) -> HRESULT,
     fn get_EventInterests(
         EventInterest: *mut SpeechRecoEvents,
     ) -> HRESULT,
     fn put_CmdMaxAlternates(
         MaxAlternates: c_long,
     ) -> HRESULT,
     fn get_CmdMaxAlternates(
         MaxAlternates: *mut c_long,
     ) -> HRESULT,
     fn put_State(
         State: SpeechRecoContextState,
     ) -> HRESULT,
     fn get_State(
         State: *mut SpeechRecoContextState,
     ) -> HRESULT,
     fn put_RetainedAudio(
         Option: SpeechRetainedAudioOptions,
     ) -> HRESULT,
     fn get_RetainedAudio(
         Option: *mut SpeechRetainedAudioOptions,
     ) -> HRESULT,
     fn putref_RetainedAudioFormat(
         Format: *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn get_RetainedAudioFormat(
         Format: *mut *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn Pause() -> HRESULT,
     fn Resume() -> HRESULT,
     fn CreateGrammar(
         GrammarId: VARIANT,
         Grammar: *mut *mut ISpeechRecoGrammar,
     ) -> HRESULT,
     fn CreateResultFromMemory(
         ResultBlock: *mut VARIANT,
         Result: *mut *mut ISpeechRecoResult,
     ) -> HRESULT,
     fn Bookmark(
         Options: SpeechBookmarkOptions,
         StreamPos: VARIANT,
         BookmarkId: VARIANT,
     ) -> HRESULT,
     fn SetAdaptationData(
         AdaptationString: BSTR,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xb6d6f79f, 0x2158, 0x4e50, 0xb5, 0xbc, 0x9a, 0x9c, 0xcd, 0x85, 0x2a, 0x09)]
 interface ISpeechRecoGrammar(ISpeechRecoGrammarVtbl): IDispatch(IDispatchVtbl) {
     fn get_Id(
         Id: *mut VARIANT,
     ) -> HRESULT,
     fn get_RecoContext(
         RecoContext: *mut *mut ISpeechRecoContext,
     ) -> HRESULT,
     fn put_State(
         State: SpeechGrammarState,
     ) -> HRESULT,
     fn get_State(
         State: *mut SpeechGrammarState,
     ) -> HRESULT,
     fn get_Rules(
         Rules: *mut *mut ISpeechGrammarRules,
     ) -> HRESULT,
     fn Reset(
         NewLanguage: SpeechLanguageId,
     ) -> HRESULT,
     fn CmdLoadFromFile(
         FileName: BSTR,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn CmdLoadFromObject(
         ClassId: BSTR,
         GrammarName: BSTR,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn CmdLoadFromResource(
         hModule: c_long,
         ResourceName: VARIANT,
         ResourceType: VARIANT,
         LanguageId: SpeechLanguageId,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn CmdLoadFromMemory(
         GrammarData: VARIANT,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn CmdLoadFromProprietaryGrammar(
         ProprietaryGuid: BSTR,
         PriorietaryString: BSTR,
         ProprietaryData: VARIANT,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn CmdSetRuleState(
         Name: BSTR,
         State: SpeechRuleState,
     ) -> HRESULT,
     fn CmdSetRuleIdState(
         RuleId: c_long,
         State: SpeechRuleState,
     ) -> HRESULT,
     fn DictationLoad(
         TopicName: BSTR,
         LoadOption: SpeechLoadOption,
     ) -> HRESULT,
     fn DictationUnload() -> HRESULT,
     fn DictationSetState(
         State: SpeechRuleState,
     ) -> HRESULT,
     fn SetWordSequenceData(
         Text: BSTR,
         TextLength: c_long,
         Info: *mut ISpeechTextSelectionInformation,
     ) -> HRESULT,
     fn SetTextSelection(
         Info: *mut ISpeechTextSelectionInformation,
     ) -> HRESULT,
     fn IsPronounceable(
         Word: BSTR,
         WordPronounceable: *mut SpeechWordPronounceable,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x7b8fcb42, 0x0e9d, 0x4f00, 0xa0, 0x48, 0x7b, 0x04, 0xd6, 0x17, 0x9d, 0x3d)]
 interface _ISpeechRecoContextEvents(_ISpeechRecoContextEventsVtbl): IDispatch(IDispatchVtbl) {}}
 RIDL!{#[uuid(0xafe719cf, 0x5dd1, 0x44f2, 0x99, 0x9c, 0x7a, 0x39, 0x9f, 0x1c, 0xfc, 0xcc)]
 interface ISpeechGrammarRule(ISpeechGrammarRuleVtbl): IDispatch(IDispatchVtbl) {
     fn get_Attributes(
         Attributes: *mut SpeechRuleAttributes,
     ) -> HRESULT,
     fn get_InitialState(
         State: *mut *mut ISpeechGrammarRuleState,
     ) -> HRESULT,
     fn get_Name(
         Name: *mut BSTR,
     ) -> HRESULT,
     fn get_Id(
         Id: *mut c_long,
     ) -> HRESULT,
     fn Clear() -> HRESULT,
     fn AddResource(
         ResourceName: BSTR,
         ResourceValue: BSTR,
     ) -> HRESULT,
     fn AddState(
         State: *mut *mut ISpeechGrammarRuleState,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x6ffa3b44, 0xfc2d, 0x40d1, 0x8a, 0xfc, 0x32, 0x91, 0x1c, 0x7f, 0x1a, 0xd1)]
 interface ISpeechGrammarRules(ISpeechGrammarRulesVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn FindRule(
         RuleNameOrId: VARIANT,
         Rule: *mut *mut ISpeechGrammarRule,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Rule: *mut *mut ISpeechGrammarRule,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
     fn get_Dynamic(
         Dynamic: *mut VARIANT_BOOL,
     ) -> HRESULT,
     fn Add(
         RuleName: BSTR,
         Attributes: SpeechRuleAttributes,
         RuleId: c_long,
         Rule: *mut *mut ISpeechGrammarRule,
     ) -> HRESULT,
     fn Commit() -> HRESULT,
     fn CommitAndSave(
         ErrorText: *mut BSTR,
         SaveStream: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xd4286f2c, 0xee67, 0x45ae, 0xb9, 0x28, 0x28, 0xd6, 0x95, 0x36, 0x2e, 0xda)]
 interface ISpeechGrammarRuleState(ISpeechGrammarRuleStateVtbl): IDispatch(IDispatchVtbl) {
     fn get_Rule(
         Rule: *mut *mut ISpeechGrammarRule,
     ) -> HRESULT,
     fn get_Transitions(
         Transitions: *mut *mut ISpeechGrammarRuleStateTransitions,
     ) -> HRESULT,
     fn AddWordTransition(
         DestState: *mut ISpeechGrammarRuleState,
         Words: BSTR,
         Separators: BSTR,
         Type: SpeechGrammarWordType,
         PropertyName: BSTR,
         PropertyId: c_long,
         PropertyValue: *mut VARIANT,
         Weight: c_float,
     ) -> HRESULT,
     fn AddRuleTransition(
         DestinationState: *mut ISpeechGrammarRuleState,
         Rule: *mut ISpeechGrammarRule,
         PropertyName: BSTR,
         PropertyId: c_long,
         PropertyValue: *mut VARIANT,
         Weight: c_float,
     ) -> HRESULT,
     fn AddSpecialTransition(
         DestinationState: *mut ISpeechGrammarRuleState,
         Type: SpeechSpecialTransitionType,
         PropertyName: BSTR,
         PropertyId: c_long,
         PropertyValue: *mut VARIANT,
         Weight: c_float,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xcafd1db1, 0x41d1, 0x4a06, 0x98, 0x63, 0xe2, 0xe8, 0x1d, 0xa1, 0x7a, 0x9a)]
 interface ISpeechGrammarRuleStateTransition(ISpeechGrammarRuleStateTransitionVtbl):
     IDispatch(IDispatchVtbl) {
     fn get_Type(
         Type: *mut SpeechGrammarRuleStateTransitionType,
     ) -> HRESULT,
     fn get_Text(
         Text: *mut BSTR,
     ) -> HRESULT,
     fn get_Rule(
         Rule: *mut *mut ISpeechGrammarRule,
     ) -> HRESULT,
     fn get_Weight(
         Weight: *mut VARIANT,
     ) -> HRESULT,
     fn get_PropertyName(
         PropertyName: *mut BSTR,
     ) -> HRESULT,
     fn get_PropertyId(
         PropertyId: *mut c_long,
     ) -> HRESULT,
     fn get_PropertyValue(
         PropertyValue: *mut VARIANT,
     ) -> HRESULT,
     fn get_NextState(
         NextState: *mut *mut ISpeechGrammarRuleState,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xeabce657, 0x75bc, 0x44a2, 0xaa, 0x7f, 0xc5, 0x64, 0x76, 0x74, 0x29, 0x63)]
 interface ISpeechGrammarRuleStateTransitions(ISpeechGrammarRuleStateTransitionsVtbl):
     IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Transition: *mut *mut ISpeechGrammarRuleStateTransition,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x3b9c7e7a, 0x6eee, 0x4ded, 0x90, 0x92, 0x11, 0x65, 0x72, 0x79, 0xad, 0xbe)]
 interface ISpeechTextSelectionInformation(ISpeechTextSelectionInformationVtbl):
     IDispatch(IDispatchVtbl) {
     fn put_ActiveOffset(
         ActiveOffset: c_long,
     ) -> HRESULT,
     fn get_ActiveOffset(
         ActiveOffset: *mut c_long,
     ) -> HRESULT,
     fn put_ActiveLength(
         ActiveLength: c_long,
     ) -> HRESULT,
     fn get_ActiveLength(
         ActiveLength: *mut c_long,
     ) -> HRESULT,
     fn put_SelectionOffset(
         SelectionOffset: c_long,
     ) -> HRESULT,
     fn get_SelectionOffset(
         SelectionOffset: *mut c_long,
     ) -> HRESULT,
     fn put_SelectionLength(
         SelectionLength: c_long,
     ) -> HRESULT,
     fn get_SelectionLength(
         SelectionLength: *mut c_long,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xed2879cf, 0xced9, 0x4ee6, 0xa5, 0x34, 0xde, 0x01, 0x91, 0xd5, 0x46, 0x8d)]
 interface ISpeechRecoResult(ISpeechRecoResultVtbl): IDispatch(IDispatchVtbl) {
     fn get_RecoContext(
         RecoContext: *mut *mut ISpeechRecoContext,
     ) -> HRESULT,
     fn get_Times(
         Times: *mut *mut ISpeechRecoResultTimes,
     ) -> HRESULT,
     fn putref_AudioFormat(
         Format: *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn get_AudioFormat(
         Format: *mut *mut ISpeechAudioFormat,
     ) -> HRESULT,
     fn get_PhraseInfo(
         PhraseInfo: *mut *mut ISpeechPhraseInfo,
     ) -> HRESULT,
     fn Alternates(
         RequestCount: c_long,
         StartElement: c_long,
         Elements: c_long,
         Alternates: *mut *mut ISpeechPhraseAlternates,
     ) -> HRESULT,
     fn Audio(
         StartElement: c_long,
         Elements: c_long,
         Stream: *mut *mut ISpeechMemoryStream,
     ) -> HRESULT,
     fn SpeakAudio(
         StartElement: c_long,
         Elements: c_long,
         Flags: SpeechVoiceSpeakFlags,
         StreamNumber: *mut c_long,
     ) -> HRESULT,
     fn SaveToMemory(
         ResultBlock: *mut VARIANT,
     ) -> HRESULT,
     fn DiscardResultInfo(
         ValueTypes: SpeechDiscardType,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x62b3b8fb, 0xf6e7, 0x41be, 0xbd, 0xcb, 0x05, 0x6b, 0x1c, 0x29, 0xef, 0xc0)]
 interface ISpeechRecoResultTimes(ISpeechRecoResultTimesVtbl): IDispatch(IDispatchVtbl) {
     fn get_StreamTime(
         Time: *mut VARIANT,
     ) -> HRESULT,
     fn get_Length(
         Length: *mut VARIANT,
     ) -> HRESULT,
     fn get_TickCount(
         TickCount: *mut c_long,
     ) -> HRESULT,
     fn get_OffsetFromStart(
         OffsetFromStart: *mut VARIANT,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x27864a2a, 0x2b9f, 0x4cb8, 0x92, 0xd3, 0x0d, 0x27, 0x22, 0xfd, 0x1e, 0x73)]
 interface ISpeechPhraseAlternate(ISpeechPhraseAlternateVtbl): IDispatch(IDispatchVtbl) {
     fn get_RecoResult(
         RecoResult: *mut *mut ISpeechRecoResult,
     ) -> HRESULT,
     fn get_StartElementInResult(
         StartElement: *mut c_long,
     ) -> HRESULT,
     fn get_NumberOfElementsInResult(
         NumberOfElements: *mut c_long,
     ) -> HRESULT,
     fn get_PhraseInfo(
         PhraseInfo: *mut *mut ISpeechPhraseInfo,
     ) -> HRESULT,
     fn Commit() -> HRESULT,
 }}
 RIDL!{#[uuid(0xb238b6d5, 0xf276, 0x4c3d, 0xa6, 0xc1, 0x29, 0x74, 0x80, 0x1c, 0x3c, 0xc2)]
 interface ISpeechPhraseAlternates(ISpeechPhraseAlternatesVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         PhraseAlternate: *mut *mut ISpeechPhraseAlternate,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x961559cf, 0x4e67, 0x4662, 0x8b, 0xf0, 0xd9, 0x3f, 0x1f, 0xcd, 0x61, 0xb3)]
 interface ISpeechPhraseInfo(ISpeechPhraseInfoVtbl): IDispatch(IDispatchVtbl) {
     fn get_LanguageId(
         LanguageId: *mut c_long,
     ) -> HRESULT,
     fn get_GrammarId(
         GrammarId: *mut VARIANT,
     ) -> HRESULT,
     fn get_StartTime(
         StartTime: *mut VARIANT,
     ) -> HRESULT,
     fn get_AudioStreamPosition(
         AudioStreamPosition: *mut VARIANT,
     ) -> HRESULT,
     fn get_AudioSizeBytes(
         pAudioSizeBytes: *mut c_long,
     ) -> HRESULT,
     fn get_RetainedSizeBytes(
         RetainedSizeBytes: *mut c_long,
     ) -> HRESULT,
     fn get_AudioSizeTime(
         AudioSizeTime: *mut c_long,
     ) -> HRESULT,
     fn get_Rule(
         Rule: *mut *mut ISpeechPhraseRule,
     ) -> HRESULT,
     fn get_Properties(
         Properties: *mut *mut ISpeechPhraseProperties,
     ) -> HRESULT,
     fn get_Elements(
         Elements: *mut *mut ISpeechPhraseElements,
     ) -> HRESULT,
     fn get_Replacements(
         Replacements: *mut *mut ISpeechPhraseReplacements,
     ) -> HRESULT,
     fn get_EngineId(
         EngineIdGuid: *mut BSTR,
     ) -> HRESULT,
     fn get_EnginePrivateData(
         PrivateData: *mut VARIANT,
     ) -> HRESULT,
     fn SaveToMemory(
         PhraseBlock: *mut VARIANT,
     ) -> HRESULT,
     fn GetText(
         StartElement: c_long,
         Elements: c_long,
         UseReplacements: VARIANT_BOOL,
         Text: *mut BSTR,
     ) -> HRESULT,
     fn GetDisplayAttributes(
         StartElement: c_long,
         Elements: c_long,
         UseReplacements: VARIANT_BOOL,
         DisplayAttributes: *mut SpeechDisplayAttributes,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xe6176f96, 0xe373, 0x4801, 0xb2, 0x23, 0x3b, 0x62, 0xc0, 0x68, 0xc0, 0xb4)]
 interface ISpeechPhraseElement(ISpeechPhraseElementVtbl): IDispatch(IDispatchVtbl) {
     fn get_AudioTimeOffset(
         AudioTimeOffset: *mut c_long,
     ) -> HRESULT,
     fn get_AudioSizeTime(
         AudioSizeTime: *mut c_long,
     ) -> HRESULT,
     fn get_AudioStreamOffset(
         AudioStreamOffset: *mut c_long,
     ) -> HRESULT,
     fn get_AudioSizeBytes(
         AudioSizeBytes: *mut c_long,
     ) -> HRESULT,
     fn get_RetainedStreamOffset(
         RetainedStreamOffset: *mut c_long,
     ) -> HRESULT,
     fn get_RetainedSizeBytes(
         RetainedSizeBytes: *mut c_long,
     ) -> HRESULT,
     fn get_DisplayText(
         DisplayText: *mut BSTR,
     ) -> HRESULT,
     fn get_LexicalForm(
         LexicalForm: *mut BSTR,
     ) -> HRESULT,
     fn get_Pronunciation(
         Pronunciation: *mut VARIANT,
     ) -> HRESULT,
     fn get_DisplayAttributes(
         DisplayAttributes: *mut SpeechDisplayAttributes,
     ) -> HRESULT,
     fn get_RequiredConfidence(
         RequiredConfidence: *mut SpeechEngineConfidence,
     ) -> HRESULT,
     fn get_ActualConfidence(
         ActualConfidence: *mut SpeechEngineConfidence,
     ) -> HRESULT,
     fn get_EngineConfidence(
         EngineConfident: *mut c_float,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x0626b328, 0x3478, 0x467d, 0xa0, 0xb3, 0xd0, 0x85, 0x3b, 0x93, 0xdd, 0xa3)]
 interface ISpeechPhraseElements(ISpeechPhraseElementsVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Element: *mut *mut ISpeechPhraseElement,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x2890a410, 0x53a7, 0x4fb5, 0x94, 0xec, 0x06, 0xd4, 0x99, 0x8e, 0x3d, 0x02)]
 interface ISpeechPhraseReplacement(ISpeechPhraseReplacementVtbl): IDispatch(IDispatchVtbl) {
     fn get_DisplayAttributes(
         DisplayAttributes: *mut SpeechDisplayAttributes,
     ) -> HRESULT,
     fn get_Text(
         Text: *mut BSTR,
     ) -> HRESULT,
     fn get_FirstElement(
         FirstElement: *mut c_long,
     ) -> HRESULT,
     fn get_NumberOfElements(
         NumberOfElements: *mut c_long,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x38bc662f, 0x2257, 0x4525, 0x95, 0x9e, 0x20, 0x69, 0xd2, 0x59, 0x6c, 0x05)]
 interface ISpeechPhraseReplacements(ISpeechPhraseReplacementsVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Reps: *mut *mut ISpeechPhraseReplacement,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xce563d48, 0x961e, 0x4732, 0xa2, 0xe1, 0x37, 0x8a, 0x42, 0xb4, 0x30, 0xbe)]
 interface ISpeechPhraseProperty(ISpeechPhrasePropertyVtbl): IDispatch(IDispatchVtbl) {
     fn get_Name(
         Name: *mut BSTR,
     ) -> HRESULT,
     fn get_Id(
         Id: *mut c_long,
     ) -> HRESULT,
     fn get_Value(
         Value: *mut VARIANT,
     ) -> HRESULT,
     fn get_FirstElement(
         FirstElement: *mut c_long,
     ) -> HRESULT,
     fn get_NumberOfElements(
         NumberOfElements: *mut c_long,
     ) -> HRESULT,
     fn get_EngineConfidence(
         Confidence: *mut c_float,
     ) -> HRESULT,
     fn get_Confidence(
         Confidence: *mut SpeechEngineConfidence,
     ) -> HRESULT,
     fn get_Parent(
         ParentProperty: *mut *mut ISpeechPhraseProperty,
     ) -> HRESULT,
     fn get_Children(
         Children: *mut *mut ISpeechPhraseProperties,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x08166b47, 0x102e, 0x4b23, 0xa5, 0x99, 0xbd, 0xb9, 0x8d, 0xbf, 0xd1, 0xf4)]
 interface ISpeechPhraseProperties(ISpeechPhrasePropertiesVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Property: *mut *mut ISpeechPhraseProperty,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xa7bfe112, 0xa4a0, 0x48d9, 0xb6, 0x02, 0xc3, 0x13, 0x84, 0x3f, 0x69, 0x64)]
 interface ISpeechPhraseRule(ISpeechPhraseRuleVtbl): IDispatch(IDispatchVtbl) {
     fn get_Name(
         Name: *mut BSTR,
     ) -> HRESULT,
     fn get_Id(
         Id: *mut c_long,
     ) -> HRESULT,
     fn get_FirstElement(
         FirstElement: *mut c_long,
     ) -> HRESULT,
     fn get_NumberOfElements(
         NumberOfElements: *mut c_long,
     ) -> HRESULT,
     fn get_Parent(
         Parent: *mut *mut ISpeechPhraseRule,
     ) -> HRESULT,
     fn get_Children(
         Children: *mut *mut ISpeechPhraseRules,
     ) -> HRESULT,
     fn get_Confidence(
         ActualConfidence: *mut SpeechEngineConfidence,
     ) -> HRESULT,
     fn get_EngineConfidence(
         Confidence: *mut c_float,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x9047d593, 0x01dd, 0x4b72, 0x81, 0xa3, 0xe4, 0xa0, 0xca, 0x69, 0xf4, 0x07)]
 interface ISpeechPhraseRules(ISpeechPhraseRulesVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Rule: *mut *mut ISpeechPhraseRule,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x3da7627a, 0xc7ae, 0x4b23, 0x87, 0x08, 0x63, 0x8c, 0x50, 0x36, 0x2c, 0x25)]
 interface ISpeechLexicon(ISpeechLexiconVtbl): IDispatch(IDispatchVtbl) {
     fn get_GenerationId(
         GenerationId: *mut c_long,
     ) -> HRESULT,
     fn GetWords(
         Flags: SpeechLexiconType,
         GenerationID: *mut c_long,
         Words: *mut *mut ISpeechLexiconWords,
     ) -> HRESULT,
     fn AddPronunciation(
         bstrWord: BSTR,
         LangId: SpeechLanguageId,
         PartOfSpeech: SpeechPartOfSpeech,
         bstrPronunciation: BSTR,
     ) -> HRESULT,
     fn AddPronunciationByPhoneIds(
         bstrWord: BSTR,
         LangId: SpeechLanguageId,
         PartOfSpeech: SpeechPartOfSpeech,
         PhoneIds: *mut VARIANT,
     ) -> HRESULT,
     fn RemovePronunciation(
         bstrWord: BSTR,
         LangId: SpeechLanguageId,
         PartOfSpeech: SpeechPartOfSpeech,
         bstrPronunciation: BSTR,
     ) -> HRESULT,
     fn RemovePronunciationByPhoneIds(
         bstrWord: BSTR,
         LangId: SpeechLanguageId,
         PartOfSpeech: SpeechPartOfSpeech,
         PhoneIds: *mut VARIANT,
     ) -> HRESULT,
     fn GetPronunciations(
         bstrWord: BSTR,
         LangId: SpeechLanguageId,
         TypeFlags: SpeechLexiconType,
         ppPronunciations: *mut *mut ISpeechLexiconPronunciations,
     ) -> HRESULT,
     fn GetGenerationChange(
         GenerationID: *mut c_long,
         ppWords: *mut *mut ISpeechLexiconWords,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x8d199862, 0x415e, 0x47d5, 0xac, 0x4f, 0xfa, 0xa6, 0x08, 0xb4, 0x24, 0xe6)]
 interface ISpeechLexiconWords(ISpeechLexiconWordsVtbl): IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Word: *mut *mut ISpeechLexiconWord,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x4e5b933c, 0xc9be, 0x48ed, 0x88, 0x42, 0x1e, 0xe5, 0x1b, 0xb1, 0xd4, 0xff)]
 interface ISpeechLexiconWord(ISpeechLexiconWordVtbl): IDispatch(IDispatchVtbl) {
     fn get_LangId(
         LangId: *mut SpeechLanguageId,
     ) -> HRESULT,
     fn get_Type(
         WordType: *mut SpeechWordType,
     ) -> HRESULT,
     fn get_Word(
         Word: *mut BSTR,
     ) -> HRESULT,
     fn get_Pronunciations(
         Pronunciations: *mut *mut ISpeechLexiconPronunciations,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x72829128, 0x5682, 0x4704, 0xa0, 0xd4, 0x3e, 0x2b, 0xb6, 0xf2, 0xea, 0xd3)]
 interface ISpeechLexiconPronunciations(ISpeechLexiconPronunciationsVtbl):
     IDispatch(IDispatchVtbl) {
     fn get_Count(
         Count: *mut c_long,
     ) -> HRESULT,
     fn Item(
         Index: c_long,
         Pronunciation: *mut *mut ISpeechLexiconPronunciation,
     ) -> HRESULT,
     fn get__NewEnum(
         EnumVARIANT: *mut *mut IUnknown,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0x95252c5d, 0x9e43, 0x4f4a, 0x98, 0x99, 0x48, 0xee, 0x73, 0x35, 0x2f, 0x9f)]
 interface ISpeechLexiconPronunciation(ISpeechLexiconPronunciationVtbl): IDispatch(IDispatchVtbl) {
     fn get_Type(
         LexiconType: *mut SpeechLexiconType,
     ) -> HRESULT,
     fn get_LangId(
         LangId: *mut SpeechLanguageId,
     ) -> HRESULT,
     fn get_PartOfSpeech(
         PartOfSpeech: *mut SpeechPartOfSpeech,
     ) -> HRESULT,
     fn get_PhoneIds(
         PhoneIds: *mut VARIANT,
     ) -> HRESULT,
     fn get_Symbolic(
         Symbolic: *mut BSTR,
     ) -> HRESULT,
 }}
 pub const Speech_Default_Weight: c_float = DEFAULT_WEIGHT;
 pub const Speech_Max_Word_Length: LONG = SP_MAX_WORD_LENGTH as i32;
 pub const Speech_Max_Pron_Length: LONG = SP_MAX_PRON_LENGTH as i32;
 pub const Speech_StreamPos_Asap: LONG = SP_STREAMPOS_ASAP as i32;
 pub const Speech_StreamPos_RealTime: LONG = SP_STREAMPOS_REALTIME as i32;
 pub const SpeechAllElements: LONG = SPPR_ALL_ELEMENTS as i32;
 RIDL!{#[uuid(0x3b151836, 0xdf3a, 0x4e0a, 0x84, 0x6c, 0xd2, 0xad, 0xc9, 0x33, 0x43, 0x33)]
 interface ISpeechPhraseInfoBuilder(ISpeechPhraseInfoBuilderVtbl): IDispatch(IDispatchVtbl) {
     fn RestorePhraseFromMemory(
         PhraseInMemory: *mut VARIANT,
         PhraseInfo: *mut *mut ISpeechPhraseInfo,
     ) -> HRESULT,
 }}
 RIDL!{#[uuid(0xc3e4f353, 0x433f, 0x43d6, 0x89, 0xa1, 0x6a, 0x62, 0xa7, 0x05, 0x4c, 0x3d)]
 interface ISpeechPhoneConverter(ISpeechPhoneConverterVtbl): IDispatch(IDispatchVtbl) {
     fn get_LanguageId(
         LanguageId: *mut SpeechLanguageId,
     ) -> HRESULT,
     fn put_LanguageId(
         LanguageId: SpeechLanguageId,
     ) -> HRESULT,
     fn PhoneToId(
         Phonemes: BSTR,
         IdArray: *mut VARIANT,
     ) -> HRESULT,
     fn IdToPhone(
         IdArray: VARIANT,
         Phonemes: *mut BSTR,
     ) -> HRESULT,
 }}
 extern {
     pub static CLSID_SpNotifyTranslator: CLSID;
     pub static CLSID_SpObjectTokenCategory: CLSID;
     pub static CLSID_SpObjectToken: CLSID;
     pub static CLSID_SpResourceManager: CLSID;
     pub static CLSID_SpStreamFormatConverter: CLSID;
     pub static CLSID_SpMMAudioEnum: CLSID;
     pub static CLSID_SpMMAudioIn: CLSID;
     pub static CLSID_SpMMAudioOut: CLSID;
     pub static CLSID_SpStream: CLSID;
     pub static CLSID_SpVoice: CLSID;
     pub static CLSID_SpSharedRecoContext: CLSID;
     pub static CLSID_SpInprocRecognizer: CLSID;
     pub static CLSID_SpSharedRecognizer: CLSID;
     pub static CLSID_SpLexicon: CLSID;
     pub static CLSID_SpUnCompressedLexicon: CLSID;
     pub static CLSID_SpCompressedLexicon: CLSID;
     pub static CLSID_SpPhoneConverter: CLSID;
     pub static CLSID_SpNullPhoneConverter: CLSID;
     pub static CLSID_SpTextSelectionInformation: CLSID;
     pub static CLSID_SpPhraseInfoBuilder: CLSID;
     pub static CLSID_SpAudioFormat: CLSID;
     pub static CLSID_SpWaveFormatEx: CLSID;
     pub static CLSID_SpInProcRecoContext: CLSID;
     pub static CLSID_SpCustomStream: CLSID;
     pub static CLSID_SpFileStream: CLSID;
     pub static CLSID_SpMemoryStream: CLSID;
 }