// Copyright © 2017 winapi-rs developers
// 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;
}
