// Copyright © 2015, Connor Hilarides
// Licensed under the MIT License <LICENSE.md>
//! Mappings for the contents of sapi.h
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,
}}
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 SPTOKENKEY_RETAINEDAUDIO: &'static str = "SecondsPerRetainedAudioEvent";
pub const SPTOKENKEY_AUDIO_LATENCY_WARNING: &'static str = "LatencyWarningThreshold";
pub const SPTOKENKEY_AUDIO_LATENCY_TRUNCATE: &'static str = "LatencyTruncateThreshold";
pub const SPTOKENKEY_AUDIO_LATENCY_UPDATE_INTERVAL: &'static str = "LatencyUpdateInterval";
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 SPREG_SAFE_USER_TOKENS: &'static str = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\UserTokens";
pub const SP_LOW_CONFIDENCE: i32 = -1;
pub const SP_NORMAL_CONFIDENCE: i32 = 0;
pub const SP_HIGH_CONFIDENCE: i32 = 1;
pub const DEFAULT_WEIGHT: i32 = 1;
pub const SP_MAX_WORD_LENGTH: i32 = 128;
pub const SP_MAX_PRON_LENGTH: i32 = 384;
pub const SP_EMULATE_RESULT: i32 = 0x40000000;
RIDL!(
interface ISpNotifyCallback(ISpNotifyCallbackVtbl) {
    fn NotifyCallback(&mut self, wParam: ::WPARAM, lParam: ::LPARAM) -> ::HRESULT
}
);
pub type SPNOTIFYCALLBACK = unsafe extern "system" fn(wParam: ::WPARAM, lParam: ::LPARAM);
RIDL!(
interface ISpNotifySource(ISpNotifySourceVtbl): IUnknown(IUnknownVtbl) {
    fn SetNotifySink(&mut self, pNotifySink: *mut ISpNotifySink) -> ::HRESULT,
    fn SetNotifyWindowMessage(
        &mut self, hWnd: ::HWND, Msg: ::UINT, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn SetNotifyCallbackFunction(
        &mut self, pfnCallback: SPNOTIFYCALLBACK, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn SetNotifyCallbackInterface(
        &mut self, pSpCallback: *mut ISpNotifyCallback, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn SetNotifyWin32Event(&mut self) -> ::HRESULT,
    fn WaitForNotifyEvent(&mut self, dwMilliseconds: ::DWORD) -> ::HRESULT,
    fn GetNotifyEventHandle(&mut self) -> ::HANDLE
}
);
RIDL!(
interface ISpNotifySink(ISpNotifySinkVtbl): IUnknown(IUnknownVtbl) {
    fn Notify(&mut self) -> ::HRESULT
}
);
RIDL!(
interface ISpNotifyTranslator(ISpNotifyTranslatorVtbl): ISpNotifySink(ISpNotifySinkVtbl) {
    fn InitWindowMessage(
        &mut self, hWnd: ::HWND, Msg: ::UINT, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn InitCallback(
        &mut self, pfnCallback: SPNOTIFYCALLBACK, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn InitSpNotifyCallback(
        &mut self, pSpCallback: *mut ISpNotifyCallback, wParam: ::WPARAM, lParam: ::LPARAM
    ) -> ::HRESULT,
    fn InitWin32Event(&mut self, hEvent: ::HANDLE, fCloseHandleOnRelease: ::BOOL) -> ::HRESULT,
    fn Wait(&mut self, dwMilliseconds: ::DWORD) -> ::HRESULT,
    fn GetEventHandle(&mut self) -> ::HANDLE
}
);
RIDL!(
interface ISpDataKey(ISpDataKeyVtbl): IUnknown(IUnknownVtbl) {
    fn SetData(
        &mut self, pszValueName: ::LPCWSTR, cbData: ::ULONG, pData: *const ::BYTE
    ) -> ::HRESULT,
    fn GetData(
        &mut self, pszValueName: ::LPCWSTR, pcbData: *mut ::ULONG, pData: *mut ::BYTE
    ) -> ::HRESULT,
    fn SetStringValue(&mut self, pszValueName: ::LPCWSTR, pszValue: ::LPCWSTR) -> ::HRESULT,
    fn GetStringValue(&mut self, pszValueName: ::LPCWSTR, ppszValue: *mut ::LPWSTR) -> ::HRESULT,
    fn SetDWORD(&mut self, pszValueName: ::LPCWSTR, dwValue: ::DWORD) -> ::HRESULT,
    fn GetDWORD(&mut self, pszValueName: ::LPCWSTR, pdwValue: *mut ::DWORD) -> ::HRESULT,
    fn OpenKey(&mut self, pszSubKeyName: ::LPCWSTR, ppSubKey: *mut *mut ISpDataKey) -> ::HRESULT,
    fn CreateKey(&mut self, pszSubKey: ::LPCWSTR, ppSubKey: *mut *mut ISpDataKey) -> ::HRESULT,
    fn DeleteKey(&mut self, pszSubKey: ::LPCWSTR) -> ::HRESULT,
    fn DeleteValue(&mut self, pszValueName: ::LPCWSTR) -> ::HRESULT,
    fn EnumKeys(&mut self, Index: ::ULONG, ppszSubKeyName: *mut ::LPWSTR) -> ::HRESULT,
    fn EnumValues(&mut self, Index: ::ULONG, ppszValueName: *mut ::LPWSTR) -> ::HRESULT
}
);
RIDL!(
interface ISpRegDataKey(ISpRegDataKeyVtbl): ISpDataKey(ISpDataKeyVtbl) {
    fn SetKey(&mut self, hkey: ::HKEY, fReadOnly: ::BOOL) -> ::HRESULT
}
);
RIDL!(
interface ISpObjectTokenCategory(ISpObjectTokenCategoryVtbl): ISpDataKey(ISpDataKeyVtbl) {
    fn SetId(&mut self, pszCategoryId: ::LPCWSTR, fCreateIfNotExist: ::BOOL) -> ::HRESULT,
    fn GetId(&mut self, ppszCoMemCategoryId: *mut ::LPWSTR) -> ::HRESULT,
    fn GetDataKey(
        &mut self, spdkl: SPDATAKEYLOCATION, pppDataKey: *mut *mut ISpDataKey
    ) -> ::HRESULT,
    fn EnumTokens(
        &mut self, pzsReqAttribs: ::LPCWSTR, pszOptAttribs: ::LPCWSTR,
        ppEnum: *mut *mut IEnumSpObjectTokens
    ) -> ::HRESULT,
    fn SetDefaultTokenId(&mut self, pszTokenId: ::LPCWSTR) -> ::HRESULT,
    fn GetDefaultTokenId(&mut self, ppszCoMemTokenId: *mut ::LPWSTR) -> ::HRESULT
}
);
RIDL!(
interface ISpObjectToken(ISpObjectTokenVtbl): ISpDataKey(ISpDataKeyVtbl) {
    fn SetId(
        &mut self, pszCategoryId: ::LPCWSTR, pszTokenId: ::LPCWSTR, fCreateIfNotExist: ::BOOL
    ) -> ::HRESULT,
    fn GetId(&mut self, ppszCoMemTokenId: *mut ::LPWSTR) -> ::HRESULT,
    fn GetCategory(&mut self, ppTokenCategory: *mut *mut ISpObjectTokenCategory) -> ::HRESULT,
    fn CreateInstance(
        &mut self, pUnkOuter: *mut ::IUnknown, dwClsContext: ::DWORD, riid: ::REFIID,
        ppvObject: *mut *mut ::c_void
    ) -> ::HRESULT,
    fn GetStorageFileName(
        &mut self, clsidCaller: ::REFCLSID, pszValueName: ::LPCWSTR,
        pszFileNameSpecifier: ::LPCWSTR, nFolder: ::ULONG, ppszFilePath: *mut ::LPWSTR
    ) -> ::HRESULT,
    fn RemoveStorageFileName(&mut self, pszKeyName: ::LPCWSTR, fDeleteFile: ::BOOL) -> ::HRESULT,
    fn Remove(&mut self, pclsidCaller: *const ::CLSID) -> ::HRESULT,
    fn IsUISupported(
        &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG,
        punkObject: *mut ::IUnknown, pfSupported: *mut ::BOOL
    ) -> ::HRESULT,
    fn DisplayUI(
        &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR,
        pvExtraData: *mut ::c_void, cbExtraData: ::ULONG, punkObject: *mut ::IUnknown
    ) -> ::HRESULT,
    fn MatchesAttributes(&mut self, pszAttributes: ::LPCWSTR, pfMatches: *mut ::BOOL) -> ::HRESULT
}
);
RIDL!(
interface ISpObjectTokenInit(ISpObjectTokenInitVtbl): ISpObjectToken(ISpObjectTokenVtbl) {
    fn InitFromDataKey(
        &mut self, pszCategoryId: ::LPCWSTR, pszTokenId: ::LPCWSTR, pDataKey: *mut ISpDataKey
    ) -> ::HRESULT
}
);
RIDL!(
interface IEnumSpObjectTokens(IEnumSpObjectTokensVtbl): IUnknown(IUnknownVtbl) {
    fn Next(
        &mut self, celt: ::ULONG, pelt: *mut *mut ISpObjectToken, pceltFetched: *mut ::ULONG
    ) -> ::HRESULT,
    fn Skip(&mut self, celt: ::ULONG) -> ::HRESULT,
    fn Reset(&mut self) -> ::HRESULT,
    fn Clone(&mut self, ppEnum: *mut *mut IEnumSpObjectTokens) -> ::HRESULT,
    fn Item(&mut self, Index: ::ULONG, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn GetCount(&mut self, pCount: *mut ::ULONG) -> ::HRESULT
}
);
RIDL!(
interface ISpObjectWithToken(ISpObjectWithTokenVtbl): IUnknown(IUnknownVtbl) {
    fn SetObjectToken(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT,
    fn GetObjectToken(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT
}
);
RIDL!(
interface ISpResourceManager(ISpResourceManagerVtbl): IServiceProvider(IServiceProviderVtbl) {
    fn SetObject(&mut self, guidServiceId: ::REFGUID, pUnkObject: *mut ::IUnknown) -> ::HRESULT,
    fn GetObject(
        &mut self, 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_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_RETAINEDAUDIO = 51,
    SPEI_SR_PRIVATE = 52,
    SPEI_ACTIVE_CATEGORY_CHANGED = 53,
    SPEI_RESERVED5 = 54,
    SPEI_RESERVED6 = 55,
    SPEI_RESERVED1 = 30,
    SPEI_RESERVED2 = 33,
    SPEI_RESERVED3 = 63,
}}
pub const SPEI_MIN_TTS: SPEVENTENUM = SPEI_START_INPUT_STREAM;
pub const SPEI_MAX_TTS: SPEVENTENUM = SPEI_TTS_PRIVATE;
pub const SPEI_MIN_SR: SPEVENTENUM = SPEI_END_SR_STREAM;
pub const SPEI_MAX_SR: SPEVENTENUM = SPEI_RESERVED6;
pub const SPFEI_FLAGCHECK: u64 = (1 << SPEI_RESERVED1.0 as u64) | (1 << SPEI_RESERVED2.0 as u64);
pub const SPFEI_ALL_TTS_EVENTS: u64 = 0x000000000000FFFE | SPFEI_FLAGCHECK;
pub const SPFEI_ALL_SR_EVENTS: u64 = 0x003FFFFC00000000 | SPFEI_FLAGCHECK;
pub const SPFEI_ALL_EVENTS: u64 = 0xEFFFFFFFFFFFFFFF;
#[inline]
pub fn SPFEI(SPEI_ord: u64) -> u64 {
    (1 << SPEI_ord) | SPFEI_FLAGCHECK
}
STRUCT!{struct SPEVENT {
    eEventId: ::WORD,
    elParamType: ::WORD,
    ulStreamNum: ::ULONG,
    ullAudioStreamOffset: ::ULONGLONG,
    wParam: ::WPARAM,
    lParam: ::LPARAM,
}}
STRUCT!{struct SPSERIALIZEDEVENT {
    eEventId: ::WORD,
    elParamType: ::WORD,
    ulStreamNum: ::ULONG,
    ullAudioStreamOffset: ::ULONGLONG,
    SerializedwParam: ::ULONG,
    SerializedlParam: ::LONG,
}}
STRUCT!{struct SPSERIALIZEDEVENT64 {
    eEventId: ::WORD,
    elParamType: ::WORD,
    ulStreamNum: ::ULONG,
    ullAudioStreamOffset: ::ULONGLONG,
    SerializedwParam: ::ULONGLONG,
    SerializedlParam: ::LONGLONG,
}}
STRUCT!{struct SPEVENTEX {
    eEventId: ::WORD,
    elParamType: ::WORD,
    ulStreamNum: ::ULONG,
    ullAudioStreamOffset: ::ULONGLONG,
    wParam: ::WPARAM,
    lParam: ::LPARAM,
    ullAudioTimeOffset: ::ULONGLONG,
}}
ENUM!{enum SPINTERFERENCE {
    SPINTERFERENCE_NONE = 0,
    SPINTERFERENCE_NOISE = 1,
    SPINTERFERENCE_NOSIGNAL = 2,
    SPINTERFERENCE_TOOLOUD = 3,
    SPINTERFERENCE_TOOQUIET = 4,
    SPINTERFERENCE_TOOFAST = 5,
    SPINTERFERENCE_TOOSLOW = 6,
    SPINTERFERENCE_LATENCY_WARNING = 7,
    SPINTERFERENCE_LATENCY_TRUNCATE_BEGIN = 8,
    SPINTERFERENCE_LATENCY_TRUNCATE_END = 9,
}}
FLAGS!{enum SPENDSRSTREAMFLAGS {
    SPESF_NONE = 0,
    SPESF_STREAM_RELEASED = 1 << 0,
    SPESF_EMULATED = 1 << 1,
}}
FLAGS!{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!(
interface ISpEventSource(ISpEventSourceVtbl): ISpNotifySource(ISpNotifySourceVtbl) {
    fn SetInterest(
        &mut self, ullEventInterest: ::ULONGLONG, ullQueuedInterest: ::ULONGLONG
    ) -> ::HRESULT,
    fn GetEvents(
        &mut self, ulCount: ::ULONG, pEventArray: *mut SPEVENT, pulFetched: *mut ::ULONG
    ) -> ::HRESULT,
    fn GetInfo(&mut self, pInfo: *mut SPEVENTSOURCEINFO) -> ::HRESULT
}
);
RIDL!(
interface ISpEventSource2(ISpEventSource2Vtbl): ISpEventSource(ISpEventSourceVtbl) {
    fn GetEventsEx(
        &mut self, ulCount: ::ULONG, pEventArray: *mut SPEVENTEX, pulFetched: *mut ::ULONG
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpEventSink(ISpEventSinkVtbl): IUnknown(IUnknownVtbl) {
    fn AddEvents(&mut self, pEventArray: *const SPEVENT, ulCount: ::ULONG) -> ::HRESULT,
    fn GetEventInterest(&mut self, pullEventInterest: *mut ::ULONGLONG) -> ::HRESULT
}
);
RIDL!(
interface ISpStreamFormat(ISpStreamFormatVtbl): IStream(IStreamVtbl) {
    fn GetFormat(
        &mut self, pguidFormatId: *mut ::GUID, ppCoMemWaveFormatEx: *mut *mut ::WAVEFORMATEX
    ) -> ::HRESULT
}
);
ENUM!{enum SPFILEMODE {
    SPFM_OPEN_READONLY = 0,
    SPFM_OPEN_READWRITE = 1,
    SPFM_CREATE = 2,
    SPFM_CREATE_ALWAYS = 3,
    SPFM_NUM_MODES = 4,
}}
RIDL!(
interface ISpStream(ISpStreamVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
    fn SetBaseStream(
        &mut self, pStream: *mut ::IStream, rguidFormat: ::REFGUID,
        pWaveFormatEx: *const ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn GetBaseStream(&mut self, ppStream: *mut *mut ::IStream) -> ::HRESULT,
    fn BindToFile(
        &mut self, pszFileName: ::LPCWSTR, eMode: SPFILEMODE, pFormatId: *const ::GUID,
        pWaveFormatEx: *const ::WAVEFORMATEX, ullEventInterest: ::ULONGLONG
    ) -> ::HRESULT,
    fn Close(&mut self) -> ::HRESULT
}
);
RIDL!(
interface ISpStreamFormatConverter(ISpStreamFormatConverterVtbl)
    : ISpStreamFormat(ISpStreamFormatVtbl) {
    fn SetBaseStream(
        &mut self, pStream: *mut ISpStreamFormat, fSetFormatToBaseStreamFormat: ::BOOL,
        fWriteToBaseStream: ::BOOL
    ) -> ::HRESULT,
    fn GetBaseStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT,
    fn SetFormat(
        &mut self, rguidFormatIdOfConvertedStream: ::REFGUID,
        pWaveFormatExOfConvertedStream: *const ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn ResetSeekPosition(&mut self) -> ::HRESULT,
    fn ScaleConvertedToBaseOffset(
        &mut self, ullOffsetConvertedStream: ::ULONGLONG, pullOffsetBaseStream: *mut ::ULONGLONG
    ) -> ::HRESULT,
    fn ScaleBaseToConvertedOffset(
        &mut self, ullOffsetBaseStream: ::ULONGLONG, pullOffsetConvertedStream: *mut ::ULONGLONG
    ) -> ::HRESULT
}
);
ENUM!{enum SPAUDIOSTATE {
    SPAS_CLOSED = 0,
    SPAS_STOP = 1,
    SPAS_PAUSE = 2,
    SPAS_RUN = 3,
}}
STRUCT!{struct SPAUDIOSTATUS {
    cbFreeBuffSpace: ::LONG,
    cbNonBlockingIO: ::ULONG,
    State: SPAUDIOSTATE,
    CurSeekPos: ::ULONGLONG,
    CurDevicePos: ::ULONGLONG,
    dwAudioLevel: ::DWORD,
    dwReserved2: ::DWORD,
}}
STRUCT!{struct SPAUDIOBUFFERINFO {
    ulMsMinNotification: ::ULONG,
    ulMsBufferSize: ::ULONG,
    ulMsEventBias: ::ULONG,
}}
RIDL!(
interface ISpAudio(ISpAudioVtbl): ISpStreamFormat(ISpStreamFormatVtbl) {
    fn SetState(&mut self, NewState: SPAUDIOSTATE, ullReserved: ::ULONGLONG) -> ::HRESULT,
    fn SetFormat(
        &mut self, rguidFmtId: ::REFGUID, pWaveFormatEx: *const ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn GetStatus(&mut self, pStatus: *mut SPAUDIOSTATUS) -> ::HRESULT,
    fn SetBufferInfo(&mut self, pBuffInfo: *const SPAUDIOBUFFERINFO) -> ::HRESULT,
    fn GetBufferInfo(&mut self, pBuffInfo: *mut SPAUDIOBUFFERINFO) -> ::HRESULT,
    fn GetDefaultFormat(
        &mut self, pFormatId: *mut ::GUID, ppCoMemWaveFormatEx: *mut *mut ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn EventHandle(&mut self) -> ::HANDLE,
    fn GetVolumeLevel(&mut self, pLevel: *mut ::ULONG) -> ::HRESULT,
    fn SetVolumeLevel(&mut self, Level: ::ULONG) -> ::HRESULT,
    fn GetBufferNotifySize(&mut self, pcbSize: *mut ::ULONG) -> ::HRESULT,
    fn SetBufferNotifySize(&mut self, cbSize: ::ULONG) -> ::HRESULT
}
);
RIDL!(
interface ISpMMSysAudio(ISpMMSysAudioVtbl): ISpAudio(ISpAudioVtbl) {
    fn GetDeviceId(&mut self, puDeviceId: *mut ::UINT) -> ::HRESULT,
    fn SetDeviceId(&mut self, uDeviceId: ::UINT) -> ::HRESULT,
    fn GetMMHandle(&mut self, pHandle: *mut *mut ::c_void) -> ::HRESULT,
    fn GetLineId(&mut self, puLineId: *mut ::UINT) -> ::HRESULT,
    fn SetLineId(&mut self, uLineId: ::UINT) -> ::HRESULT
}
);
RIDL!(
interface ISpTranscript(ISpTranscriptVtbl): IUnknown(IUnknownVtbl) {
    fn GetTranscript(&mut self, ppszTranscript: *mut ::LPWSTR) -> ::HRESULT,
    fn AppendTranscript(&mut self, pszTranscript: ::LPCWSTR) -> ::HRESULT
}
);
FLAGS!{enum SPDISPLYATTRIBUTES {
    SPAF_ONE_TRAILING_SPACE = 0x2,
    SPAF_TWO_TRAILING_SPACES = 0x4,
    SPAF_CONSUME_LEADING_SPACES = 0x8,
    SPAF_BUFFER_POSITION = 0x10,
    SPAF_ALL = 0x1f,
    SPAF_USER_SPECIFIED = 0x80,
}}
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 {
    pszName: ::LPCWSTR,
    bType: ::BYTE,
    bReserved: ::BYTE,
    usArrayIndex: u16,
    pszValue: ::LPCWSTR,
    vValue: ::VARIANT,
    ulFirstElement: ::ULONG,
    ulCountOfElements: ::ULONG,
    pNextSibling: *const SPPHRASEPROPERTY,
    pFirstChild: *const SPPHRASEPROPERTY,
    SREngineConfidence: ::c_float,
    Confidence: ::c_char,
}}
UNION!(SPPHRASEPROPERTY, bType, ulId, ulId_mut, ::ULONG);
STRUCT!{struct SPPHRASEREPLACEMENT {
    bDisplayAttributes: ::BYTE,
    pszReplacementText: ::LPCWSTR,
    ulFirstElement: ::ULONG,
    ulCountOfElements: ::ULONG,
}}
STRUCT!{struct SPSEMANTICERRORINFO {
    ulLineNumber: ::ULONG,
    pszScriptLine: ::LPWSTR,
    pszSource: ::LPWSTR,
    pszDescription: ::LPWSTR,
    hrResultCode: ::HRESULT,
}}
ENUM!{enum SPSEMANTICFORMAT {
    SPSMF_SAPI_PROPERTIES = 0,
    SPSMF_SRGS_SEMANTICINTERPRETATION_MS = 1,
    SPSMF_SRGS_SAPIPROPERTIES = 2,
    SPSMF_UPS = 4,
    SPSMF_SRGS_SEMANTICINTERPRETATION_W3C = 8,
}}
STRUCT!{struct SPPHRASE_50 {
    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 SPPHRASE_53 {
    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,
    pSML: ::LPWSTR,
    pSemanticErrorInfo: *mut SPSEMANTICERRORINFO,
}}
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,
    pSML: ::LPWSTR,
    pSemanticErrorInfo: *mut SPSEMANTICERRORINFO,
    SemanticTagFormat: SPSEMANTICFORMAT,
}}
STRUCT!{struct SPSERIALIZEDPHRASE {
    ulSerializedSize: ::ULONG,
}}
STRUCT!{struct SPRULE {
    pszRuleName: ::LPCWSTR,
    ulRuleId: ::ULONG,
    dwAttributes: ::DWORD,
}}
FLAGS!{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__);
FLAGS!{enum SPRECOEVENTFLAGS {
    SPREF_AutoPause = 1 << 0,
    SPREF_Emulated = 1 << 1,
    SPREF_SMLTimeout = 1 << 2,
    SPREF_ExtendableParse = 1 << 3,
    SPREF_ReSent = 1 << 4,
    SPREF_Hypothesis = 1 << 5,
    SPREF_FalseRecognition = 1 << 6,
}}
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,
    SPPS_Noncontent = 0x6000,
    SPPS_LMA = 0x7000,
    SPPS_SuppressWord = 0xf000,
}}
FLAGS!{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,
}}
FLAGS!{enum SPWORDTYPE {
    eWORDTYPE_ADDED = 1 << 0,
    eWORDTYPE_DELETED = 1 << 1,
}}
FLAGS!{enum SPPRONUNCIATIONFLAGS {
    ePRONFLAG_USED = 1 << 0,
}}
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!(
interface ISpLexicon(ISpLexiconVtbl): IUnknown(IUnknownVtbl) {
    fn GetPronunciations(
        &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, dwFlags: ::DWORD,
        pWordPronunciationList: *mut SPWORDPRONUNCIATIONLIST
    ) -> ::HRESULT,
    fn AddPronunciation(
        &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, ePartOfSpeech: SPPARTOFSPEECH,
        pszPronunciation: PCSPPHONEID
    ) -> ::HRESULT,
    fn RemovePronunciation(
        &mut self, pszWord: ::LPCWSTR, LangID: ::WORD, ePartOfSpeech: SPPARTOFSPEECH,
        pszPronunciation: PCSPPHONEID
    ) -> ::HRESULT,
    fn GetGeneration(&mut self, pdwGeneration: *mut ::DWORD) -> ::HRESULT,
    fn GetGenerationChange(
        &mut self, dwFlags: ::DWORD, pdwGeneration: *mut ::DWORD, pWordList: *mut SPWORDLIST
    ) -> ::HRESULT,
    fn GetWords(
        &mut self, dwFlags: ::DWORD, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD,
        pWordList: *mut SPWORDLIST
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpContainerLexicon(ISpContainerLexiconVtbl): ISpLexicon(ISpLexiconVtbl) {
    fn AddLexicon(&mut self, pAddLexicon: *mut ISpLexicon, dwFlags: ::DWORD) -> ::HRESULT
}
);
ENUM!{enum SPSHORTCUTTYPE {
    SPSHT_NotOverriden = -1i32 as u32,
    SPSHT_Unknown = 0,
    SPSHT_EMAIL = 0x1000,
    SPSHT_OTHER = 0x2000,
    SPPS_RESERVED1 = 0x3000,
    SPPS_RESERVED2 = 0x4000,
    SPPS_RESERVED3 = 0x5000,
    SPPS_RESERVED4 = 0xf000,
}}
STRUCT!{struct SPSHORTCUTPAIR {
    pNextSHORTCUTPAIR: *mut SPSHORTCUTPAIR,
    LangID: ::WORD,
    shType: SPSHORTCUTTYPE,
    pszDisplay: ::LPWSTR,
    pszSpoken: ::LPWSTR,
}}
STRUCT!{struct SPSHORTCUTPAIRLIST {
    ulSize: ::ULONG,
    pvBuffer: *mut ::BYTE,
    pFirstShortcutPair: *mut SPSHORTCUTPAIR,
}}
RIDL!(
interface ISpShortcut(ISpShortcutVtbl): IUnknown(IUnknownVtbl) {
    fn AddShortcut(
        &mut self, pszDisplay: ::LPCWSTR, LangID: ::WORD, pszSpoken: ::LPCWSTR,
        shType: SPSHORTCUTTYPE
    ) -> ::HRESULT,
    fn RemoveShortcut(
        &mut self, pszDisplay: ::LPCWSTR, LangID: ::WORD, pszSpoken: ::LPCWSTR,
        shType: SPSHORTCUTTYPE
    ) -> ::HRESULT,
    fn GetShortcuts(
        &mut self, LangId: ::WORD, pShortcutpairList: *mut SPSHORTCUTPAIRLIST
    ) -> ::HRESULT,
    fn GetGeneration(&mut self, pdwGeneration: *mut ::DWORD) -> ::HRESULT,
    fn GetWordsFromGenerationChange(
        &mut self, pdwGeneration: *mut ::DWORD, pWordList: *mut SPWORDLIST
    ) -> ::HRESULT,
    fn GetWords(
        &mut self, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD, pWordList: *mut SPWORDLIST
    ) -> ::HRESULT,
    fn GetShortcutsForGeneration(
        &mut self, pdwGeneration: *mut ::DWORD, pdwCookie: *mut ::DWORD,
        pShortcutpairList: *mut SPSHORTCUTPAIRLIST
    ) -> ::HRESULT,
    fn GetGenerationChange(
        &mut self, pdwGeneration: *mut ::DWORD, pShortcutpairList: *mut SPSHORTCUTPAIRLIST
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpPhoneConverter(ISpPhoneConverterVtbl): ISpObjectWithToken(ISpObjectWithTokenVtbl) {
    fn PhoneToId(&mut self, pszPhone: ::LPCWSTR, pId: *mut SPPHONEID) -> ::HRESULT,
    fn IdToPhone(&mut self, pId: PCSPPHONEID, pszPhone: *mut ::WCHAR) -> ::HRESULT
}
);
RIDL!(
interface ISpPhoneticAlphabetConverter(ISpPhoneticAlphabetConverterVtbl): IUnknown(IUnknownVtbl) {
    fn GetLangId(&mut self, pLangID: *mut ::WORD) -> ::HRESULT,
    fn SetLangId(&mut self, LangID: *mut ::WORD) -> ::HRESULT,
    fn SAPI2UPS(
        &mut self, pszSAPIId: *const SPPHONEID, pszUPSId: *mut SPPHONEID, cMaxLength: ::DWORD
    ) -> ::HRESULT,
    fn UPS2SAPI(
        &mut self, pszUPSId: *const SPPHONEID, pszSAPIId: *mut SPPHONEID, cMaxLength: ::DWORD
    ) -> ::HRESULT,
    fn GetMaxConvertLength(
        &mut self, cSrcLength: ::DWORD, bSAPI2UPS: ::BOOL, pcMaxDestLength: *mut ::DWORD
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpPhoneticAlphabetSelection(ISpPhoneticAlphabetSelectionVtbl): IUnknown(IUnknownVtbl) {
    fn IsAlphabetUPS(&mut self, pfIsUPS: *mut ::BOOL) -> ::HRESULT,
    fn SetAlphabetToUPS(&mut self, fForceUPS: ::BOOL) -> ::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,
}}
FLAGS!{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_PARSE_SAPI = 1 << 7,
    SPF_PARSE_SSML = 1 << 8,
}}
pub const SPF_PARSE_AUTODETECT: SPEAKFLAGS = SPF_DEFAULT;
pub const SPF_NLP_MASK: SPEAKFLAGS = SPF_NLP_SPEAK_PUNC;
pub const SPF_PARSE_MASK: i32 = SPF_PARSE_SAPI.0 as i32 | SPF_PARSE_SSML.0 as i32;
pub const SPF_VOICE_MASK: i32 =
    SPF_ASYNC.0 as i32 | SPF_PURGEBEFORESPEAK.0 as i32 | SPF_IS_FILENAME.0 as i32 | SPF_IS_XML.0 as i32 |
    SPF_IS_NOT_XML.0 as i32 | SPF_NLP_MASK.0 as i32 | SPF_PERSIST_XML.0 as i32 | SPF_PARSE_MASK;
pub const SPF_UNUSED_FLAGS: i32 = !SPF_VOICE_MASK;
RIDL!(
interface ISpVoice(ISpVoiceVtbl): ISpEventSource(ISpEventSourceVtbl) {
    fn SetOutput(&mut self, pUnkOutput: *mut ::IUnknown, fAllowFormatChanges: ::BOOL) -> ::HRESULT,
    fn GetOutputObjectToken(&mut self, ppObjectToken: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn GetOutputStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT,
    fn Pause(&mut self) -> ::HRESULT,
    fn Resume(&mut self) -> ::HRESULT,
    fn SetVoice(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT,
    fn GetVoice(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn Speak(
        &mut self, pwcs: ::LPCWSTR, dwFlags: ::DWORD, pulStreamNumber: *mut ::ULONG
    ) -> ::HRESULT,
    fn SpeakStream(
        &mut self, pStream: *mut ::IStream, dwFlags: ::DWORD, pulStreamNumber: *mut ::ULONG
    ) -> ::HRESULT,
    fn GetStatus(
        &mut self, pStatus: *mut SPVOICESTATUS, ppszLastBookmark: *mut ::LPWSTR
    ) -> ::HRESULT,
    fn Skip(
        &mut self, pItemType: ::LPCWSTR, lNumItems: ::c_long, pulNumSkipped: *mut ::ULONG
    ) -> ::HRESULT,
    fn SetPriority(&mut self, ePriority: SPVPRIORITY) -> ::HRESULT,
    fn GetPriority(&mut self, pePriority: *mut SPVPRIORITY) -> ::HRESULT,
    fn SetAlertBoundary(&mut self, eBoundary: SPEVENTENUM) -> ::HRESULT,
    fn GetAlertBoundary(&mut self, peBoundary: *mut SPEVENTENUM) -> ::HRESULT,
    fn SetRate(&mut self, RateAdjust: ::c_long) -> ::HRESULT,
    fn GetRate(&mut self, pRateAdjust: *mut ::c_long) -> ::HRESULT,
    fn SetVolume(&mut self, usVolume: ::USHORT) -> ::HRESULT,
    fn GetVolume(&mut self, pusVolume: *mut ::USHORT) -> ::HRESULT,
    fn WaitUntilDone(&mut self, msTimeout: ::ULONG) -> ::HRESULT,
    fn SetSyncSpeakTimeout(&mut self, msTimeout: ::ULONG) -> ::HRESULT,
    fn GetSyncSpeakTimeout(&mut self, pmsTimeout: *mut ::ULONG) -> ::HRESULT,
    fn SpeakCompleteEvent(&mut self) -> ::HANDLE,
    fn IsUISupported(
        &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG,
        pfSupported: *mut ::BOOL
    ) -> ::HRESULT,
    fn DisplayUI(
        &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR,
        pvExtraData: *mut ::c_void, cbExtraData: ::ULONG
    ) -> ::HRESULT
}
);
DEFINE_GUID!(
    UuidOfISpVoice,
    0x6C44DF74, 0x72B9, 0x4992, 0xA1, 0xEC, 0xEF, 0x99, 0x6E, 0x04, 0x22, 0xD4
);
RIDL!(
interface ISpPhrase(ISpPhraseVtbl): IUnknown(IUnknownVtbl) {
    fn GetPhrase(&mut self, ppCoMemPhrase: *mut *mut SPPHRASE) -> ::HRESULT,
    fn GetSerializedPhrase(&mut self, ppCoMemPhrase: *mut *mut SPSERIALIZEDPHRASE) -> ::HRESULT,
    fn GetText(
        &mut self, ulStart: ::ULONG, ulCount: ::ULONG, fUseTextReplacements: ::BOOL,
        ppszCoMemText: *mut ::LPWSTR, pbDisplayAttributes: *mut ::BYTE
    ) -> ::HRESULT,
    fn Discard(&mut self, dwValueTypes: ::DWORD) -> ::HRESULT
}
);
RIDL!(
interface ISpPhraseAlt(ISpPhraseAltVtbl): ISpPhrase(ISpPhraseVtbl) {
    fn GetAltInfo(
        &mut self, pParent: *mut *mut ISpPhrase, pulStartElementInParent: *mut ::ULONG,
        pcElementsInParent: *mut ::ULONG, pcElementsInAlt: *mut ::ULONG
    ) -> ::HRESULT,
    fn Commit(&mut self) -> ::HRESULT
}
);
ENUM!{enum SPXMLRESULTOPTIONS {
    SPXRO_SML = 0,
    SPXRO_Alternates_SML = 1,
}}
RIDL!(
interface ISpPhrase2(ISpPhrase2Vtbl): ISpPhrase(ISpPhraseVtbl) {
    fn GetXMLResult(
        &mut self, ppszCoMemXMLResult: *mut ::LPWSTR, Options: SPXMLRESULTOPTIONS
    ) -> ::HRESULT,
    fn GetXMLErrorInfo(&mut self, pSemanticErrorInfo: *mut SPSEMANTICERRORINFO) -> ::HRESULT,
    fn GetAudio(
        &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ppStream: *mut *mut ISpStreamFormat
    ) -> ::HRESULT
}
);
STRUCT!{struct SPRECORESULTTIMES {
    ftStreamTime: ::FILETIME,
    ullLength: ::ULONGLONG,
    dwTickCount: ::DWORD,
    ullStart: ::ULONGLONG,
}}
STRUCT!{struct SPSERIALIZEDRESULT {
    ulSerializedSize: ::ULONG,
}}
RIDL!(
interface ISpRecoResult(ISpRecoResultVtbl): ISpPhrase(ISpPhraseVtbl) {
    fn GetResultTimes(&mut self, pTimes: *mut SPRECORESULTTIMES) -> ::HRESULT,
    fn GetAlternates(
        &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ulRequestCount: ::ULONG,
        ppPhrases: *mut *mut ISpPhraseAlt, pcPhrasesReturned: *mut ::ULONG
    ) -> ::HRESULT,
    fn GetAudio(
        &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, ppStream: *mut *mut ISpStreamFormat
    ) -> ::HRESULT,
    fn SpeakAudio(
        &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, dwFlags: ::DWORD,
        pulStreamNumber: *mut ::ULONG
    ) -> ::HRESULT,
    fn Serialize(&mut self, ppCoMemSerializedResult: *mut *mut SPSERIALIZEDRESULT) -> ::HRESULT,
    fn ScaleAudio(
        &mut self, pAudioFormatId: *const ::GUID, pWaveFormatEx: *const ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn GetRecoContext(&mut self, ppRecoContext: *mut *mut ISpRecoContext) -> ::HRESULT
}
);
FLAGS!{enum SPCOMMITFLAGS {
    SPCF_NONE = 0,
    SPCF_ADD_TO_USER_LEXICON = 1 << 0,
    SPCF_DEFINITE_CORRECTION = 1 << 1,
}}
RIDL!(
interface ISpRecoResult2(ISpRecoResult2Vtbl): ISpRecoResult(ISpRecoResultVtbl) {
    fn CommitAlternate(
        &mut self, pPhraseAlt: *mut ISpPhraseAlt, ppNewResult: *mut *mut ISpRecoResult
    ) -> ::HRESULT,
    fn CommitText(
        &mut self, ulStartElement: ::ULONG, cElements: ::ULONG, pszCorrectedData: ::LPCWSTR,
        eCommitFlags: ::DWORD
    ) -> ::HRESULT,
    fn SetTextFeedback(&mut self, pszFeedback: ::LPCWSTR, fSuccessful: ::BOOL) -> ::HRESULT
}
);
RIDL!(
interface ISpXMLRecoResult(ISpXMLRecoResultVtbl): ISpRecoResult(ISpRecoResultVtbl) {
    fn GetXMLResult(
        &mut self, ppszCoMemXMLResult: *mut ::LPWSTR, Options: SPXMLRESULTOPTIONS
    ) -> ::HRESULT,
    fn GetXMLErrorInfo(&mut self, pSemanticErrorInfo: *mut SPSEMANTICERRORINFO) -> ::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,
    SPRS_ACTIVE_USER_DELIMITED = 4,
}}
pub const SP_STREAMPOS_ASAP: ::INT = 0;
pub const SP_STREAMPOS_REALTIME: ::INT = -1;
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 = 0,
    SPWT_LEXICAL = 1,
    SPWT_PRONUNCIATION = 2,
    SPWT_LEXICAL_NO_SPECIAL_CHARS = 3,
}}
STRUCT!{struct SPPROPERTYINFO {
    pszName: ::LPCWSTR,
    ulId: ::ULONG,
    pszValue: ::LPCWSTR,
    vValue: ::VARIANT,
}}
FLAGS!{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_Root = 1 << 6,
    SPRAF_AutoPause = 1 << 16,
    SPRAF_UserDelimited = 1 << 17,
}}
RIDL!(
interface ISpGrammarBuilder(ISpGrammarBuilderVtbl): IUnknown(IUnknownVtbl) {
    fn ResetGrammar(&mut self, NewLanguage: ::WORD) -> ::HRESULT,
    fn GetRule(
        &mut self, pszRuleName: ::LPCWSTR, dwRuleId: ::DWORD, dwAttributes: ::DWORD,
        fCreateIfNotExist: ::BOOL, phInitialState: *mut SPSTATEHANDLE
    ) -> ::HRESULT,
    fn ClearRule(&mut self, hState: SPSTATEHANDLE) -> ::HRESULT,
    fn CreateNewState(&mut self, hState: SPSTATEHANDLE, phState: *mut SPSTATEHANDLE) -> ::HRESULT,
    fn AddWordTransition(
        &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, psz: ::LPCWSTR,
        pszSeparators: ::LPCWSTR, eWordType: SPGRAMMARWORDTYPE, Weight: ::c_float,
        pPropInfo: *const SPPROPERTYINFO
    ) -> ::HRESULT,
    fn AddRuleTransition(
        &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, hRule: SPSTATEHANDLE,
        Weight: ::c_float, pPropInfo: *const SPPROPERTYINFO
    ) -> ::HRESULT,
    fn AddResource(
        &mut self, hRuleState: SPSTATEHANDLE, pszResourceName: ::LPCWSTR,
        pszResourceValue: ::LPCWSTR
    ) -> ::HRESULT,
    fn Commit(&mut self, dwReserved: ::DWORD) -> ::HRESULT
}
);
ENUM!{enum SPLOADOPTIONS {
    SPLO_STATIC = 0,
    SPLO_DYNAMIC = 1,
}}
RIDL!(
interface ISpRecoGrammar(ISpRecoGrammarVtbl): ISpGrammarBuilder(ISpGrammarBuilderVtbl) {
    fn GetGrammarId(&mut self, pullGrammarId: *mut ::ULONGLONG) -> ::HRESULT,
    fn GetRecoContext(&mut self, ppRecoCtxt: *mut *mut ISpRecoContext) -> ::HRESULT,
    fn LoadCmdFromFile(&mut self, pszFileName: ::LPCWSTR, Options: SPLOADOPTIONS) -> ::HRESULT,
    fn LoadCmdFromObject(
        &mut self, rcid: ::REFCLSID, pszGrammarName: ::LPCWSTR, Options: SPLOADOPTIONS
    ) -> ::HRESULT,
    fn LoadCmdFromResource(
        &mut self, hModule: ::HMODULE, pszResourceName: ::LPCWSTR, pszResourceType: ::LPCWSTR,
        wLanguage: ::WORD, Options: SPLOADOPTIONS
    ) -> ::HRESULT,
    fn LoadCmdFromMemory(
        &mut self, pGrammar: *const SPBINARYGRAMMAR, Options: SPLOADOPTIONS
    ) -> ::HRESULT,
    fn LoadCmdFromProprietaryGrammar(
        &mut self, rguidParam: ::REFGUID, pszStringParam: ::LPCWSTR, pvDataPrarm: *const ::c_void,
        cbDataSize: ::ULONG, Options: SPLOADOPTIONS
    ) -> ::HRESULT,
    fn SetRuleState(
        &mut self, pszName: ::LPCWSTR, pReserved: *mut ::c_void, NewState: SPRULESTATE
    ) -> ::HRESULT,
    fn SetRuleIdState(&mut self, ulRuleId: ::ULONG, NewState: SPRULESTATE) -> ::HRESULT,
    fn LoadDictation(&mut self, pszTopicName: ::LPCWSTR, Options: SPLOADOPTIONS) -> ::HRESULT,
    fn UnloadDictation(&mut self) -> ::HRESULT,
    fn SetDictationState(&mut self, NewState: SPRULESTATE) -> ::HRESULT,
    fn SetWordSequenceData(
        &mut self, pText: *const ::WCHAR, cchText: ::ULONG, pInfo: *const SPTEXTSELECTIONINFO
    ) -> ::HRESULT,
    fn SetTextSelection(&mut self, pInfo: *const SPTEXTSELECTIONINFO) -> ::HRESULT,
    fn IsPronounceable(
        &mut self, pszWord: ::LPCWSTR, pWordPronounceable: *mut SPWORDPRONOUNCEABLE
    ) -> ::HRESULT,
    fn SetGrammarState(&mut self, eGrammarState: SPGRAMMARSTATE) -> ::HRESULT,
    fn SaveCmd(&mut self, pStream: *mut ::IStream, ppszCoMemErrorText: *mut ::LPWSTR) -> ::HRESULT,
    fn GetGrammarState(&mut self, peGrammarState: *mut SPGRAMMARSTATE) -> ::HRESULT
}
);
ENUM!{enum SPMATCHINGMODE {
    AllWords = 0,
    Subsequence = 1,
    OrderedSubset = 3,
    SubsequenceContentRequired = 5,
    OrderedSubsetContentRequired = 7,
}}
ENUM!{enum PHONETICALPHABET {
    PA_Ipa = 0,
    PA_Ups = 1,
    PA_Sapi = 2,
}}
RIDL!(
interface ISpGrammarBuilder2(ISpGrammarBuilder2Vtbl): IUnknown(IUnknownVtbl) {
    fn AddTextSubset(
        &mut self, hFromState: SPSTATEHANDLE, hToState: SPSTATEHANDLE, psz: ::LPCWSTR,
        eMatchMode: SPMATCHINGMODE
    ) -> ::HRESULT,
    fn SetPhoneticAlphabet(&mut self, phoneticALphabet: PHONETICALPHABET) -> ::HRESULT
}
);
RIDL!(
interface ISpRecoGrammar2(ISpRecoGrammar2Vtbl): IUnknown(IUnknownVtbl) {
    fn GetRules(&mut self, ppCoMemRules: *mut *mut SPRULE, puNumRules: *mut ::UINT) -> ::HRESULT,
    fn LoadCmdFromFile2(
        &mut self, pszFileName: ::LPCWSTR, Options: SPLOADOPTIONS, pszSharingUri: ::LPCWSTR,
        pszBaseUri: ::LPCWSTR
    ) -> ::HRESULT,
    fn LoadCmdFromMemory2(
        &mut self, pGrammar: *const SPBINARYGRAMMAR, Options: SPLOADOPTIONS,
        pszSharingUri: ::LPCWSTR, pszBaseUri: ::LPCWSTR
    ) -> ::HRESULT,
    fn SetRulePriority(
        &mut self, pszRuleName: ::LPCWSTR, ulRuleId: ::ULONG, nRulePriority: ::c_int
    ) -> ::HRESULT,
    fn SetRuleWeight(
        &mut self, pszRuleName: ::LPCWSTR, ulRuleId: ::ULONG, flWeight: ::c_float
    ) -> ::HRESULT,
    fn SetDictationWeight(&mut self, flWeight: ::c_float) -> ::HRESULT,
    fn SetGrammarLoader(&mut self, pLoader: *mut ISpeechResourceLoader) -> ::HRESULT,
    fn SetSMLSecurityManager(
        &mut self, pSMLSecurityManager: *mut ::IInternetSecurityManager
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpeechResourceLoader(ISpeechResourceLoaderVtbl): IDispatch(IDispatchVtbl) {
    fn LoadResource(
        &mut self, bstrResourceUri: ::BSTR, fAlwaysReload: ::VARIANT_BOOL,
        pStream: *mut *mut ::IUnknown, pbstrMIMEType: *mut ::BSTR, pfModified: *mut ::VARIANT_BOOL,
        pbstrRedirectUrl: *mut ::BSTR
    ) -> ::HRESULT,
    fn GetLocalCopy(
        &mut self, bstrResourceUri: ::BSTR, pbstrLocalPath: *mut ::BSTR,
        pbstrMIMEType: *mut ::BSTR, pbstrRedirectUrl: *mut ::BSTR
    ) -> ::HRESULT,
    fn ReleaseLocalCopy(&mut self, pbstrLocalPath: ::BSTR) -> ::HRESULT
}
);
STRUCT!{nodebug struct SPRECOCONTEXTSTATUS {
    eInterference: SPINTERFERENCE,
    szRequestTypeOfUI: [::WCHAR; 255],
    dwReserved1: ::DWORD,
    dwReserved2: ::DWORD,
}}
FLAGS!{enum SPBOOKMARKOPTIONS {
    SPBO_NONE = 0,
    SPBO_PAUSE = 1 << 0,
    SPBO_AHEAD = 1 << 1,
    SPBO_TIME_UNITS = 1 << 2,
}}
FLAGS!{enum SPAUDIOOPTIONS {
    SPAO_NONE = 0,
    SPAO_RETAIN_AUDIO = 1 << 0,
}}
RIDL!(
interface ISpRecoContext(ISpRecoContextVtbl): ISpEventSource(ISpEventSourceVtbl) {
    fn GetRecognizer(&mut self, ppRecognizer: *mut *mut ISpRecognizer) -> ::HRESULT,
    fn CreateGrammer(
        &mut self, ullGrammarId: ::ULONGLONG, ppGrammar: *mut *mut ISpRecoGrammar
    ) -> ::HRESULT,
    fn GetStatus(&mut self, pState: *mut SPRECOCONTEXTSTATUS) -> ::HRESULT,
    fn GetMaxAlternates(&mut self, pcAlternates: *mut ::ULONG) -> ::HRESULT,
    fn SetMaxAlternates(&mut self, cAlternates: ::ULONG) -> ::HRESULT,
    fn SetAudioOptions(
        &mut self, Options: SPAUDIOOPTIONS, pAudioFormatId: *const ::GUID,
        pWaveFormatEx: *const ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn GetAudioOptions(
        &mut self, pOptions: *mut SPAUDIOOPTIONS, pAudioFormatId: *mut ::GUID,
        ppCoMemWFEX: *mut *mut ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn DeserializeResult(
        &mut self, pSerializedResult: *const SPSERIALIZEDRESULT, ppResult: *mut *mut ISpRecoResult
    ) -> ::HRESULT,
    fn Bookmark(
        &mut self, Options: SPBOOKMARKOPTIONS, ullStreamPosition: ::ULONGLONG,
        lparamEvent: ::LPARAM
    ) -> ::HRESULT,
    fn SetAdaptionData(&mut self, pAdaptionData: ::LPCWSTR, cch: ::ULONG) -> ::HRESULT,
    fn Pause(&mut self, dwReserved: ::DWORD) -> ::HRESULT,
    fn Resume(&mut self, dwReserved: ::DWORD) -> ::HRESULT,
    fn SetVoice(&mut self, pVoice: *mut ISpVoice, fAllowFormatChanges: ::BOOL) -> ::HRESULT,
    fn GetVoice(&mut self, ppVoice: *mut *mut ISpVoice) -> ::HRESULT,
    fn SetVoicePurgeEvent(&mut self, ullEventIntereset: ::ULONGLONG) -> ::HRESULT,
    fn GetVoicePurgeEvent(&mut self, pullEventIntereset: *mut ::ULONGLONG) -> ::HRESULT,
    fn SetContextState(&mut self, eContextState: SPCONTEXTSTATE) -> ::HRESULT,
    fn GetContextState(&mut self, peContextState: *mut SPCONTEXTSTATE) -> ::HRESULT
}
);
FLAGS!{enum SPGRAMMAROPTIONS {
    SPGO_SAPI = 0x1,
    SPGO_SRGS = 0x2,
    SPGO_UPS = 0x4,
    SPGO_SRGS_MS_SCRIPT = 0x8,
    SPGO_SRGS_W3C_SCRIPT = 0x100,
    SPGO_SRGS_STG_SCRIPT = 0x200,
    SPGO_SRGS_SCRIPT =
        SPGO_SRGS.0 | SPGO_SRGS_MS_SCRIPT.0 | SPGO_SRGS_W3C_SCRIPT.0 |
             SPGO_SRGS_STG_SCRIPT.0,
    SPGO_FILE = 0x10,
    SPGO_HTTP = 0x20,
    SPGO_RES = 0x40,
    SPGO_OBJECT = 0x80,
    SPGO_DEFAULT = 0x3fb,
    SPGO_ALL = 0x3ff,
}}
FLAGS!{enum SPADAPTATIONSETTINGS {
    SPADS_Default = 0,
    SPADS_CurrentRecognizer = 0x1,
    SPADS_RecoProfile = 0x2,
    SPADS_Immediate = 0x4,
    SPADS_Reset = 0x8,
    SPADS_HighVolumeDataSource = 0x10,
}}
ENUM!{enum SPADAPTATIONRELEVANCE {
    SPAR_Unknown = 0,
    SPAR_Low = 1,
    SPAR_Medium = 2,
    SPAR_High = 3,
}}
RIDL!(
interface ISpRecoContext2(ISpRecoContext2Vtbl): IUnknown(IUnknownVtbl) {
    fn SetGrammarOptions(&mut self, eGrammarOptions: ::DWORD) -> ::HRESULT,
    fn GetGrammarOptions(&mut self, peGrammarOptions: *mut ::DWORD) -> ::HRESULT,
    fn SetAdaptationData2(
        &mut self, pAdaptationData: ::LPCWSTR, cch: ::ULONG, pTopicName: ::LPCWSTR,
        eAdaptationSettings: ::DWORD, eRelevance: SPADAPTATIONRELEVANCE
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpProperties(ISpPropertiesVtbl): IUnknown(IUnknownVtbl) {
    fn SetPropertyNum(&mut self, pName: ::LPCWSTR, lValue: ::LONG) -> ::HRESULT,
    fn GetPropertyNum(&mut self, pName: ::LPCWSTR, plValue: *mut ::LONG) -> ::HRESULT,
    fn SetPropertyString(&mut self, pName: ::LPCWSTR, pValue: ::LPCWSTR) -> ::HRESULT,
    fn GetPropertyString(&mut self, pName: ::LPCWSTR, ppCoMemValue: *mut ::LPWSTR) -> ::HRESULT
}
);
STRUCT!{struct SPRECOGNIZERSTATUS {
    AudioStatus: SPAUDIOSTATUS,
    ullRecognitionStreamPos: ::ULONGLONG,
    ulStreamNumber: ::ULONG,
    ulNumActive: ::ULONG,
    clsidEngine: ::CLSID,
    cLangIDs: ::ULONG,
    aLangID: [::WORD; 20],
    ullRecognitionStreamTime: ::ULONGLONG,
}}
ENUM!{enum SPWAVEFORMATTYPE {
    SPWF_INPUT = 0,
    SPWF_SRENGINE = 1,
}}
pub type SPSTREAMFORMATTYPE = SPWAVEFORMATTYPE;
ENUM!{enum SPRECOSTATE {
    SPRST_INACTIVE = 0,
    SPRST_ACTIVE = 1,
    SPRST_ACTIVE_ALWAYS = 2,
    SPRST_INACTIVE_WITH_PURGE = 3,
    SPRST_NUM_STATES = 4,
}}
RIDL!(
interface ISpRecognizer(ISpRecognizerVtbl): ISpProperties(ISpPropertiesVtbl) {
    fn SetRecognizer(&mut self, pRecognizer: *mut ISpObjectToken) -> ::HRESULT,
    fn GetRecognizer(&mut self, ppRecognizer: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn SetInput(&mut self, pUnkInput: *mut ::IUnknown, fAllowFormatChanges: ::BOOL) -> ::HRESULT,
    fn GetInputObjectToken(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn GetInputStream(&mut self, ppStream: *mut *mut ISpStreamFormat) -> ::HRESULT,
    fn CreateRecoContext(&mut self, ppNewCtxt: *mut *mut ISpRecoContext) -> ::HRESULT,
    fn GetRecoProfile(&mut self, ppToken: *mut *mut ISpObjectToken) -> ::HRESULT,
    fn SetRecoProfile(&mut self, pToken: *mut ISpObjectToken) -> ::HRESULT,
    fn IsSharedInstance(&mut self) -> ::HRESULT,
    fn GetRecoState(&mut self, pState: *mut SPRECOSTATE) -> ::HRESULT,
    fn SetRecoState(&mut self, NewState: SPRECOSTATE) -> ::HRESULT,
    fn GetStatus(&mut self, pStatus: *mut SPRECOGNIZERSTATUS) -> ::HRESULT,
    fn GetFormat(
        &mut self, WaveFormatType: SPSTREAMFORMATTYPE, pFormatId: *mut ::GUID,
        ppCoMemWFEX: *mut ::WAVEFORMATEX
    ) -> ::HRESULT,
    fn IsUISupported(
        &mut self, pszTypeOfUI: ::LPCWSTR, pvExtraData: *mut ::c_void, cbExtraData: ::ULONG,
        pfSupported: *mut ::BOOL
    ) -> ::HRESULT,
    fn DisplayUI(
        &mut self, hwndParent: ::HWND, pszTitle: ::LPCWSTR, pszTypeOfUI: ::LPCWSTR,
        pvExtraData: *mut ::c_void, cbExtraData: ::ULONG
    ) -> ::HRESULT,
    fn EmulateRecognition(&mut self, pPhrase: *mut ISpPhrase) -> ::HRESULT
}
);
RIDL!(
interface ISpSerializeState(ISpSerializeStateVtbl): IUnknown(IUnknownVtbl) {
    fn GetSerializedState(
        &mut self, ppbData: *mut *mut ::BYTE, pulSize: *mut ::ULONG, dwReserved: ::DWORD
    ) -> ::HRESULT,
    fn SetSerializedState(
        &mut self, pbData: *mut ::BYTE, ulSize: ::ULONG, dwReserved: ::DWORD
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpRecognizer2(ISpRecognizer2Vtbl): IUnknown(IUnknownVtbl) {
    fn EmulateRecognitionEx(
        &mut self, pPhrase: *mut ISpPhrase, dwCompareFlags: ::DWORD
    ) -> ::HRESULT,
    fn SetTrainingState(
        &mut self, fDoingTraining: ::BOOL, fAdaptFromTrainingData: ::BOOL
    ) -> ::HRESULT,
    fn ResetAcousticModelAdaptation(&mut self) -> ::HRESULT
}
);
ENUM!{enum SPCATEGORYTYPE {
    SPCT_COMMAND = 0,
    SPCT_DICTATION,
    SPCT_SLEEP,
    SPCT_SUB_COMMAND,
    SPCT_SUB_DICTATION,
}}
RIDL!(
interface ISpRecoCategory(ISpRecoCategoryVtbl): IUnknown(IUnknownVtbl) {
    fn GetType(&mut self, peCategoryType: *mut SPCATEGORYTYPE) -> ::HRESULT
}
);
RIDL!(
interface ISpRecognizer3(ISpRecognizer3Vtbl): IUnknown(IUnknownVtbl) {
    fn GetCategory(
        &mut self, categoryType: SPCATEGORYTYPE, ppCategory: *mut *mut ISpRecoCategory
    ) -> ::HRESULT,
    fn SetActiveCategory(&mut self, pCategory: *mut ISpRecoCategory) -> ::HRESULT,
    fn GetActiveCategory(&mut self, ppCategory: *mut *mut ISpRecoCategory) -> ::HRESULT
}
);
STRUCT!{struct SPNORMALIZATIONLIST {
    ulSize: ::ULONG,
    ppszzNormalizedList: *mut *mut ::WCHAR,
}}
RIDL!(
interface ISpEnginePronunciation(ISpEnginePronunciationVtbl): IUnknown(IUnknownVtbl) {
    fn Normalize(
        &mut self, pszWord: ::LPCWSTR, pszLeftContext: ::LPCWSTR, pszRightContext: ::LPCWSTR,
        LangID: ::WORD, pNormalizationList: *mut SPNORMALIZATIONLIST
    ) -> ::HRESULT,
    fn GetPronunciations(
        &mut self, pszWord: ::LPCWSTR, pszLeftContext: ::LPCWSTR, pszRightContext: ::LPCWSTR,
        LangID: ::WORD, pEnginePronunciationList: *mut SPWORDPRONUNCIATIONLIST
    ) -> ::HRESULT
}
);
STRUCT!{struct SPDISPLAYTOKEN {
    pszLexical: *const ::WCHAR,
    pszDisplay: *const ::WCHAR,
    bDisplayAttributes: ::BYTE,
}}
STRUCT!{struct SPDISPLAYPHRASE {
    ulNumTokens: ::ULONG,
    pTokens: *mut SPDISPLAYTOKEN,
}}
RIDL!(
interface ISpDisplayAlternates(ISpDisplayAlternatesVtbl): IUnknown(IUnknownVtbl) {
    fn GetDisplayAlternates(
        &mut self, pPhrase: *const SPDISPLAYPHRASE, cRequestCount: ::ULONG,
        ppCoMemPhrases: *mut *mut SPDISPLAYPHRASE, pcPhrasesReturned: *mut ::ULONG
    ) -> ::HRESULT,
    fn SetFullStopTrailSpace(&mut self, ulTrailSpace: ::ULONG) -> ::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.0,
    SDKLCurrentUser = SPDKL_CurrentUser.0,
    SDKLLocalMachine = SPDKL_LocalMachine.0,
    SDKLCurrentConfig = SPDKL_CurrentConfig.0,
}}
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.0,
    SSSPTRelativeToCurrentPosition = ::STREAM_SEEK_CUR.0,
    SSSPTRelativeToEnd = ::STREAM_SEEK_END.0,
}}
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.0,
    SASStop = SPAS_STOP.0,
    SASPause = SPAS_PAUSE.0,
    SASRun = SPAS_RUN.0,
}}
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.0,
    SSFMOpenReadWrite = SPFM_OPEN_READWRITE.0,
    SSFMCreate = SPFM_CREATE.0,
    SSFMCreateForWrite = SPFM_CREATE_ALWAYS.0,
}}
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.0,
    SVPAlert = SPVPRI_ALERT.0,
    SVPOver = SPVPRI_OVER.0,
}}
FLAGS!{enum SpeechVoiceSpeakFlags {
    SVSFDefault = SPF_DEFAULT.0,
    SVSFlagsAsync = SPF_ASYNC.0,
    SVSFPurgeBeforeSpeak = SPF_PURGEBEFORESPEAK.0,
    SVSFIsFilename = SPF_IS_FILENAME.0,
    SVSFIsXML = SPF_IS_XML.0,
    SVSFIsNotXML = SPF_IS_NOT_XML.0,
    SVSFPersistXML = SPF_PERSIST_XML.0,
    SVSFNLPSpeakPunc = SPF_NLP_SPEAK_PUNC.0,
    SVSFParseSapi = SPF_PARSE_SAPI.0,
    SVSFParseSsml = SPF_PARSE_SSML.0,
    SVSFParseMask = SPF_PARSE_MASK as u32,
    SVSFVoiceMask = SPF_VOICE_MASK as u32,
    SVSFUnusedFlags = SPF_UNUSED_FLAGS as u32,
}}
pub const SVSFParseAutodetect: SpeechVoiceSpeakFlags = SVSFDefault;
pub const SVSFNLPMask: SpeechVoiceSpeakFlags = SVSFNLPSpeakPunc;
FLAGS!{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.0,
    SRSEIsSpeaking = SPRS_IS_SPEAKING.0,
}}
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.0,
    SVF_Emphasis = SPVFEATURE_EMPHASIS.0,
}}
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.0,
    SRSActive = SPRST_ACTIVE.0,
    SRSActiveAlways = SPRST_ACTIVE_ALWAYS.0,
    SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE.0,
}}
ENUM!{enum SpeechDisplayAttributes {
    SDA_No_Trailing_Space = 0,
    SDA_One_Trailing_Space = SPAF_ONE_TRAILING_SPACE.0,
    SDA_Two_Trailing_Spaces = SPAF_TWO_TRAILING_SPACES.0,
    SDA_Consume_Leading_Spaces = SPAF_CONSUME_LEADING_SPACES.0,
}}
ENUM!{enum SpeechFormatType {
    SFTInput = SPWF_INPUT.0,
    SFTSREngine = SPWF_SRENGINE.0,
}}
FLAGS!{enum SpeechEmulationCompareFlags {
    SECFIgnoreCase = 0x1,
    SECFIgnoreKanaType = 0x10000,
    SECFIgnoreWidth = 0x20000,
    SECFNoSpecialChars = 0x20000000,
    SECFEmulateResult = 0x40000000,
    SECFDefault = SECFIgnoreCase.0 | SECFIgnoreKanaType.0 | SECFIgnoreWidth.0,
}}
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.0,
    SRAORetainAudio = SPAO_RETAIN_AUDIO.0,
}}
ENUM!{enum SpeechBookmarkOptions {
    SBONone = SPBO_NONE.0,
    SBOPause = SPBO_PAUSE.0,
}}
ENUM!{enum SpeechInterference {
    SINone = SPINTERFERENCE_NONE.0,
    SINoise = SPINTERFERENCE_NOISE.0,
    SINoSignal = SPINTERFERENCE_NOSIGNAL.0,
    SITooLoud = SPINTERFERENCE_TOOLOUD.0,
    SITooQuiet = SPINTERFERENCE_TOOQUIET.0,
    SITooFast = SPINTERFERENCE_TOOFAST.0,
    SITooSlow = SPINTERFERENCE_TOOSLOW.0,
}}
FLAGS!{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.0,
    SRCS_Enabled = SPCS_ENABLED.0,
}}
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.0,
    SLODynamic = SPLO_DYNAMIC.0,
}}
ENUM!{enum SpeechWordPronounceable {
    SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE.0,
    SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE.0,
    SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE.0,
}}
ENUM!{enum SpeechGrammarState {
    SGSEnabled = SPGS_ENABLED.0,
    SGSDisabled = SPGS_DISABLED.0,
    SGSExclusive = SPGS_EXCLUSIVE.0,
}}
ENUM!{enum SpeechRuleState {
    SGDSInactive = SPRS_INACTIVE.0,
    SGDSActive = SPRS_ACTIVE.0,
    SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE.0,
    SGDSActiveUserDelimited = SPRS_ACTIVE_USER_DELIMITED.0,
}}
ENUM!{enum SpeechRuleAttributes {
    SRATopLevel = SPRAF_TopLevel.0,
    SRADefaultToActive = SPRAF_Active.0,
    SRAExport = SPRAF_Export.0,
    SRAImport = SPRAF_Import.0,
    SRAInterpreter = SPRAF_Interpreter.0,
    SRADynamic = SPRAF_Dynamic.0,
    SRARoot = SPRAF_Root.0,
}}
ENUM!{enum SpeechGrammarWordType {
    SGDisplay = SPWT_DISPLAY.0,
    SGLexical = SPWT_LEXICAL.0,
    SGPronounciation = SPWT_PRONUNCIATION.0,
    SGLexicalNoSpecialChars = SPWT_LEXICAL_NO_SPECIAL_CHARS.0,
}}
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.0,
    SRTEmulated = SPREF_Emulated.0,
    SRTSMLTimeout = SPREF_SMLTimeout.0,
    SRTExtendableParse = SPREF_ExtendableParse.0,
    SRTReSent = SPREF_ReSent.0,
}}
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.0,
    SDTReplacement = SPDF_REPLACEMENT.0,
    SDTRule = SPDF_RULE.0,
    SDTDisplayText = SPDF_DISPLAYTEXT.0,
    SDTLexicalForm = SPDF_LEXICALFORM.0,
    SDTPronunciation = SPDF_PRONUNCIATION.0,
    SDTAudio = SPDF_AUDIO.0,
    SDTAlternates = SPDF_ALTERNATES.0,
    SDTAll = SPDF_ALL.0,
}}
ENUM!{enum DISPID_SpeechXMLRecoResult {
    DISPID_SRRGetXMLResult,
    DISPID_SRRGetXMLErrorInfo,
}}
ENUM!{enum DISPID_SpeechRecoResult2 {
    DISPID_SRRSetTextFeedback,
}}
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.0,
    SLTApp = eLEXTYPE_APP.0,
}}
ENUM!{enum SpeechPartOfSpeech {
    SPSNotOverriden = SPPS_NotOverriden.0,
    SPSUnknown = SPPS_Unknown.0,
    SPSNoun = SPPS_Noun.0,
    SPSVerb = SPPS_Verb.0,
    SPSModifier = SPPS_Modifier.0,
    SPSFunction = SPPS_Function.0,
    SPSInterjection = SPPS_Interjection.0,
    SPSLMA = SPPS_LMA.0,
    SPSSuppressWord = SPPS_SuppressWord.0,
}}
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.0,
    SWTDeleted = eWORDTYPE_DELETED.0,
}}
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,
}}
RIDL!(
interface ISpeechDataKey(ISpeechDataKeyVtbl): IDispatch(IDispatchVtbl) {
    fn SetBinaryValue(&mut self, ValueName: ::BSTR, Value: ::VARIANT) -> ::HRESULT,
    fn GetBinaryValue(&mut self, ValueName: ::BSTR, Value: *mut ::VARIANT) -> ::HRESULT,
    fn SetStringValue(&mut self, ValueName: ::BSTR, Value: ::BSTR) -> ::HRESULT,
    fn GetStringValue(&mut self, ValueName: ::BSTR, Value: *mut ::BSTR) -> ::HRESULT,
    fn SetLongValue(&mut self, ValueName: ::BSTR, Value: ::c_long) -> ::HRESULT,
    fn GetLongValue(&mut self, ValueName: ::BSTR, Value: *mut ::c_long) -> ::HRESULT,
    fn OpenKey(&mut self, SubKeyName: ::BSTR, SubKey: *mut *mut ISpeechDataKey) -> ::HRESULT,
    fn CreateKey(&mut self, SubKeyName: ::BSTR, SubKey: *mut *mut ISpeechDataKey) -> ::HRESULT,
    fn DeleteKey(&mut self, SubKeyName: ::BSTR) -> ::HRESULT,
    fn DeleteValue(&mut self, ValueName: ::BSTR) -> ::HRESULT,
    fn EnumKeys(&mut self, Index: ::c_long, SubKeyName: *mut ::BSTR) -> ::HRESULT,
    fn EnumValues(&mut self, Index: ::c_long, ValueName: *mut ::BSTR) -> ::HRESULT
}
);
RIDL!(
interface ISpeechObjectToken(ISpeechObjectTokenVtbl): IDispatch(IDispatchVtbl) {
    fn get_Id(&mut self, ObjectId: *mut ::BSTR) -> ::HRESULT,
    fn get_DataKey(&mut self, DataKey: *mut *mut ISpeechDataKey) -> ::HRESULT,
    fn get_Category(&mut self, Category: *mut *mut ISpeechObjectTokenCategory) -> ::HRESULT,
    fn GetDescription(&mut self, Locale: ::c_long, Description: *mut ::BSTR) -> ::HRESULT,
    fn SetId(
        &mut self, Id: ::BSTR, CategoryId: ::BSTR, CreateIfNotExist: ::VARIANT_BOOL
    ) -> ::HRESULT,
    fn GetAttribute(&mut self, AttributeName: ::BSTR, AttributeValue: *mut ::BSTR) -> ::HRESULT,
    fn CreateInstance(
        &mut self, pUnkOuter: *mut ::IUnknown, ClsContext: SpeechTokenContext,
        Object: *mut *mut ::IUnknown
    ) -> ::HRESULT,
    fn Remove(&mut self, ObjectStorageCLSID: ::BSTR) -> ::HRESULT,
    fn GetStorageFileName(
        &mut self, ObjectStorageCLSID: ::BSTR, KeyName: ::BSTR, FileName: ::BSTR, Folder: ::BSTR,
        FilePath: *mut ::BSTR
    ) -> ::HRESULT,
    fn RemoveStorageFileName(
        &mut self, ObjectStorageCLSID: ::BSTR, KeyName: ::BSTR, DeleteFile: ::VARIANT_BOOL
    ) -> ::HRESULT,
    fn IsUISupported(
        &mut self, TypeOfUI: ::BSTR, ExtraData: *const ::VARIANT, Object: *mut ::IUnknown,
        Supported: *mut ::VARIANT_BOOL
    ) -> ::HRESULT,
    fn DisplayUI(
        &mut self, hWnd: ::c_long, Title: ::BSTR, TypeOfUI: ::BSTR, ExtraData: *const ::VARIANT,
        Object: *mut ::IUnknown
    ) -> ::HRESULT,
    fn MatchesAttributes(&mut self, Attributes: ::BSTR, Matches: *mut ::VARIANT_BOOL) -> ::HRESULT
}
);
RIDL!(
interface ISpeechObjectTokens(ISpeechObjectTokensVtbl): IDispatch(IDispatchVtbl) {
    fn get_Count(&mut self, Count: *mut ::c_long) -> ::HRESULT,
    fn Item(&mut self, Index: ::c_long, Token: *mut *mut ISpeechObjectToken) -> ::HRESULT,
    fn get__NewEnum(&mut self, ppEnumVARIANT: *mut *mut ::IUnknown) -> ::HRESULT
}
);
RIDL!(
interface ISpeechObjectTokenCategory(ISpeechObjectTokenCategoryVtbl): IDispatch(IDispatchVtbl) {
    fn get_Id(&mut self, Id: *mut ::BSTR) -> ::HRESULT,
    fn put_Default(&mut self, TokenId: ::BSTR) -> ::HRESULT,
    fn get_Default(&mut self, TokenId: *mut ::BSTR) -> ::HRESULT,
    fn SetId(&mut self, Id: ::BSTR, CreateIfNotExist: ::VARIANT_BOOL) -> ::HRESULT,
    fn GetDataKey(
        &mut self, Location: SpeechDataKeyLocation, DataKey: *mut *mut ISpeechDataKey
    ) -> ::HRESULT,
    fn EnumerateTokens(
        &mut self, RequiredAttributes: ::BSTR, OptionalAttributes: ::BSTR,
        Tokens: *mut *mut ISpeechObjectTokens
    ) -> ::HRESULT
}
);
RIDL!(
interface ISpeechAudioBufferInfo(ISpeechAudioBufferInfoVtbl): IDispatch(IDispatchVtbl) {
    fn get_MinNotification(&mut self, MinNotification: *mut ::c_long) -> ::HRESULT,
    fn put_MinNotification(&mut self, MinNotification: ::c_long) -> ::HRESULT,
    fn get_BufferSize(&mut self, BufferSize: *mut ::c_long) -> ::HRESULT,
    fn put_BufferSize(&mut self, BufferSize: ::c_long) -> ::HRESULT,
    fn get_EventBias(&mut self, EventBias: *mut ::c_long) -> ::HRESULT,
    fn put_EventBias(&mut self, EventBias: ::c_long) -> ::HRESULT
}
);
RIDL!(
interface ISpeechAudioStatus(ISpeechAudioStatusVtbl): IDispatch(IDispatchVtbl) {
    fn get_FreeBufferSpace(&mut self, FreeBufferSpace: *mut ::c_long) -> ::HRESULT,
    fn get_NonBlockingIO(&mut self, NonBlockingIO: *mut ::c_long) -> ::HRESULT,
    fn get_State(&mut self, State: *mut SpeechAudioState) -> ::HRESULT,
    fn get_CurrentSeekPosition(&mut self, CurrentSeekPosition: *mut ::VARIANT) -> ::HRESULT,
    fn get_CurrentDevicePosition(&mut self, CurrentDevicePosition: *mut ::VARIANT) -> ::HRESULT
}
);
RIDL!(
interface ISpeechAudioFormat(ISpeechAudioFormatVtbl): IDispatch(IDispatchVtbl) {
    fn get_Type(&mut self, AudioFormat: *mut SpeechAudioFormatType) -> ::HRESULT,
    fn put_Type(&mut self, AudioFormat: SpeechAudioFormatType) -> ::HRESULT,
    fn get_Guid(&mut self, Guid: *mut ::BSTR) -> ::HRESULT,
    fn put_Guid(&mut self, Guid: ::BSTR) -> ::HRESULT,
    fn GetWaveFormatEx(&mut self, SpeechWaveFormatEx: *mut *mut ISpeechWaveFormatEx) -> ::HRESULT,
    fn SetWaveFormatEx(&mut self, SpeechWaveFormatEx: *mut ISpeechWaveFormatEx) -> ::HRESULT
}
);
RIDL!(
interface ISpeechWaveFormatEx(ISpeechWaveFormatExVtbl): IDispatch(IDispatchVtbl) {
    fn get_FormatTag(&mut self, FormatTag: *mut ::c_short) -> ::HRESULT,
    fn put_FormatTag(&mut self, FormatTag: ::c_short) -> ::HRESULT,
    fn get_Channels(&mut self, Channels: *mut ::c_short) -> ::HRESULT,
    fn put_Channels(&mut self, Channels: ::c_short) -> ::HRESULT,
    fn get_SamplesPerSec(&mut self, SamplesPerSec: *mut ::c_long) -> ::HRESULT,
    fn put_SamplesPerSec(&mut self, SamplesPerSec: ::c_long) -> ::HRESULT,
    fn get_AvgBytesPerSec(&mut self, AvgBytesPerSec: *mut ::c_long) -> ::HRESULT,
    fn put_AvgBytesPerSec(&mut self, AvgBytesPerSec: ::c_long) -> ::HRESULT,
    fn get_BlockAlign(&mut self, BlockAlign: *mut ::c_short) -> ::HRESULT,
    fn put_BlockAlign(&mut self, BlockAlign: ::c_short) -> ::HRESULT,
    fn get_BitsPerSample(&mut self, BitsPerSample: *mut ::c_short) -> ::HRESULT,
    fn put_BitsPerSample(&mut self, BitsPerSample: ::c_short) -> ::HRESULT,
    fn get_ExtraData(&mut self, ExtraData: *mut ::VARIANT) -> ::HRESULT,
    fn put_ExtraData(&mut self, ExtraData: ::VARIANT) -> ::HRESULT
}
);