/**
 * This file is part of the mingw-w64 runtime package.
 * No warranty is given; refer to the file DISCLAIMER within this package.
 */

#ifndef _SAPI_BLD_
#define _SAPI_BLD_ 0x54
#endif

import "oaidl.idl";
import "ocidl.idl";

cpp_quote("#ifndef _SAPI_VER")
cpp_quote("#error \"you have to include <sapi.h> header before this.\"")
cpp_quote("#endif")

#ifndef LANGID
#define LANGID WORD
#endif

cpp_quote("#if 0")
typedef [restricted, hidden] struct WAVEFORMATEX {
  WORD wFormatTag;
  WORD nChannels;
  DWORD nSamplesPerSec;
  DWORD nAvgBytesPerSec;
  WORD nBlockAlign;
  WORD wBitsPerSample;
  WORD cbSize;
} WAVEFORMATEX;
cpp_quote("#endif")

interface ISpNotifySource;
interface ISpNotifySink;
interface ISpNotifyTranslator;
interface ISpDataKey;
interface ISpObjectTokenCategory;
interface ISpObjectToken;
interface IEnumSpObjectTokens;
interface ISpObjectWithToken;
interface ISpResourceManager;
interface ISpEventSource;
interface ISpEventSink;
interface ISpStreamFormat;
interface ISpStream;
interface ISpStreamFormatConverter;
interface ISpAudio;
interface ISpMMSysAudio;
interface ISpTranscript;
interface ISpVoice;
interface ISpRecoResult;
interface ISpRecoContext;
interface ISpRecognizer;
interface ISpProperties;
interface ISpLexicon;
interface ISpPhoneConverter;
interface ISpPhrase;
#if _SAPI_BLD_ >= 0x53
interface ISpRecoContext2;
interface ISpRecognizer2;
interface ISpShortcut;
interface ISpPhoneticAlphabetConverter;
interface ISpPhoneticAlphabetSelection;
interface ISpRecoGrammar2;
interface ISpeechResourceLoader;
#endif
#if _SAPI_BLD_ >= 0x54
interface ISpRecognizer3;
#endif

typedef [hidden] enum SPDATAKEYLOCATION {
  SPDKL_DefaultLocation = 0,
  SPDKL_CurrentUser = 1,
  SPDKL_LocalMachine = 2,
  SPDKL_CurrentConfig = 5
} SPDATAKEYLOCATION;

typedef [hidden] enum SPSTREAMFORMAT {
  SPSF_Default = -1,
  SPSF_NoAssignedFormat = 0,
  SPSF_Text,
  SPSF_NonStandardFormat,
  SPSF_ExtendedAudioFormat,
  SPSF_8kHz8BitMono,
  SPSF_8kHz8BitStereo,
  SPSF_8kHz16BitMono,
  SPSF_8kHz16BitStereo,
  SPSF_11kHz8BitMono,
  SPSF_11kHz8BitStereo,
  SPSF_11kHz16BitMono,
  SPSF_11kHz16BitStereo,
  SPSF_12kHz8BitMono,
  SPSF_12kHz8BitStereo,
  SPSF_12kHz16BitMono,
  SPSF_12kHz16BitStereo,
  SPSF_16kHz8BitMono,
  SPSF_16kHz8BitStereo,
  SPSF_16kHz16BitMono,
  SPSF_16kHz16BitStereo,
  SPSF_22kHz8BitMono,
  SPSF_22kHz8BitStereo,
  SPSF_22kHz16BitMono,
  SPSF_22kHz16BitStereo,
  SPSF_24kHz8BitMono,
  SPSF_24kHz8BitStereo,
  SPSF_24kHz16BitMono,
  SPSF_24kHz16BitStereo,
  SPSF_32kHz8BitMono,
  SPSF_32kHz8BitStereo,
  SPSF_32kHz16BitMono,
  SPSF_32kHz16BitStereo,
  SPSF_44kHz8BitMono,
  SPSF_44kHz8BitStereo,
  SPSF_44kHz16BitMono,
  SPSF_44kHz16BitStereo,
  SPSF_48kHz8BitMono,
  SPSF_48kHz8BitStereo,
  SPSF_48kHz16BitMono,
  SPSF_48kHz16BitStereo,
  SPSF_TrueSpeech_8kHz1BitMono,
  SPSF_CCITT_ALaw_8kHzMono,
  SPSF_CCITT_ALaw_8kHzStereo,
  SPSF_CCITT_ALaw_11kHzMono,
  SPSF_CCITT_ALaw_11kHzStereo,
  SPSF_CCITT_ALaw_22kHzMono,
  SPSF_CCITT_ALaw_22kHzStereo,
  SPSF_CCITT_ALaw_44kHzMono,
  SPSF_CCITT_ALaw_44kHzStereo,
  SPSF_CCITT_uLaw_8kHzMono,
  SPSF_CCITT_uLaw_8kHzStereo,
  SPSF_CCITT_uLaw_11kHzMono,
  SPSF_CCITT_uLaw_11kHzStereo,
  SPSF_CCITT_uLaw_22kHzMono,
  SPSF_CCITT_uLaw_22kHzStereo,
  SPSF_CCITT_uLaw_44kHzMono,
  SPSF_CCITT_uLaw_44kHzStereo,
  SPSF_ADPCM_8kHzMono,
  SPSF_ADPCM_8kHzStereo,
  SPSF_ADPCM_11kHzMono,
  SPSF_ADPCM_11kHzStereo,
  SPSF_ADPCM_22kHzMono,
  SPSF_ADPCM_22kHzStereo,
  SPSF_ADPCM_44kHzMono,
  SPSF_ADPCM_44kHzStereo,
  SPSF_GSM610_8kHzMono,
  SPSF_GSM610_11kHzMono,
  SPSF_GSM610_22kHzMono,
  SPSF_GSM610_44kHzMono,
  SPSF_NUM_FORMATS
} SPSTREAMFORMAT;

typedef [hidden] enum SPEVENTLPARAMTYPE {
  SPET_LPARAM_IS_UNDEFINED = 0,
  SPET_LPARAM_IS_TOKEN,
  SPET_LPARAM_IS_OBJECT,
  SPET_LPARAM_IS_POINTER,
  SPET_LPARAM_IS_STRING
} SPEVENTLPARAMTYPE;

typedef [hidden] 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,
#if _SAPI_BLD_ >= 0x53
  SPEI_SR_RETAINEDAUDIO = 51,
#endif
  SPEI_SR_PRIVATE = 52,
#if _SAPI_BLD_ >= 0x53
#if _SAPI_BLD_ >= 0x54
  SPEI_ACTIVE_CATEGORY_CHANGED = 53,
#else
  SPEI_RESERVED4 = 53,
#endif
  SPEI_RESERVED5 = 54,
  SPEI_RESERVED6 = 55,
#endif
  SPEI_MIN_SR = 34,
#if _SAPI_BLD_ >= 0x53
  SPEI_MAX_SR = 55,
#else
  SPEI_MAX_SR = 52,
#endif
  SPEI_RESERVED1 = 30,
  SPEI_RESERVED2 = 33,
  SPEI_RESERVED3 = 63
} SPEVENTENUM;

typedef [hidden] 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
} SPINTERFERENCE;

typedef [hidden] enum SPENDSRSTREAMFLAGS {
  SPESF_NONE = 0,
  SPESF_STREAM_RELEASED = 1
#if _SAPI_BLD_ >= 0x53
  , SPESF_EMULATED = 2
#endif
} SPENDSRSTREAMFLAGS;

typedef [hidden] enum SPVFEATURE {
  SPVFEATURE_STRESSED = 1,
  SPVFEATURE_EMPHASIS = 2
} SPVFEATURE;

typedef [hidden] 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,
} SPVISEMES;

typedef [hidden] enum SPFILEMODE {
  SPFM_OPEN_READONLY,
  SPFM_OPEN_READWRITE,
  SPFM_CREATE,
  SPFM_CREATE_ALWAYS,
  SPFM_NUM_MODES
} SPFILEMODE;

typedef [hidden] enum _SPAUDIOSTATE {
  SPAS_CLOSED,
  SPAS_STOP,
  SPAS_PAUSE,
  SPAS_RUN
} SPAUDIOSTATE;

typedef [hidden] enum SPDISPLYATTRIBUTES {
  SPAF_ONE_TRAILING_SPACE = 0x2,
  SPAF_TWO_TRAILING_SPACES = 0x4,
  SPAF_CONSUME_LEADING_SPACES = 0x8,
#if _SAPI_BLD_ >= 0x53
  SPAF_BUFFER_POSITION = 0x10,
  SPAF_ALL = 0x1f,
  SPAF_USER_SPECIFIED = 0x80
#else
  SPAF_ALL = 0x0f
#endif
} SPDISPLAYATTRIBUTES;

typedef [hidden] enum SPPHRASEPROPERTYUNIONTYPE {
  SPPPUT_UNUSED = 0,
  SPPPUT_ARRAY_INDEX
} SPPHRASEPROPERTYUNIONTYPE;

#if _SAPI_BLD_ >= 0x53
typedef enum SPSEMANTICFORMAT {
  SPSMF_SAPI_PROPERTIES = 0,
  SPSMF_SRGS_SEMANTICINTERPRETATION_MS = 1,
  SPSMF_SRGS_SAPIPROPERTIES = 2,
  SPSMF_UPS = 4,
  SPSMF_SRGS_SEMANTICINTERPRETATION_W3C = 8
} SPSEMANTICFORMAT;
#endif

typedef [hidden] enum SPRECOEVENTFLAGS {
  SPREF_AutoPause = 0x1,
  SPREF_Emulated = 0x2
#if _SAPI_BLD_ >= 0x53
  , SPREF_SMLTimeout = 0x4,
  SPREF_ExtendableParse = 0x8,
  SPREF_ReSent = 0x10,
  SPREF_Hypothesis = 0x20,
  SPREF_FalseRecognition = 0x40
#endif
} SPRECOEVENTFLAGS;

typedef [hidden] enum SPPARTOFSPEECH {
  SPPS_NotOverriden = -1,
  SPPS_Unknown = 0,
  SPPS_Noun = 0x1000,
  SPPS_Verb = 0x2000,
  SPPS_Modifier = 0x3000,
  SPPS_Function = 0x4000,
  SPPS_Interjection = 0x5000
#if _SAPI_BLD_ >= 0x53
  , SPPS_Noncontent = 0x6000,
  SPPS_LMA = 0x7000,
  SPPS_SuppressWord = 0xf000
#endif
} SPPARTOFSPEECH;

typedef [hidden] enum SPLEXICONTYPE {
  eLEXTYPE_USER = 0x1,
  eLEXTYPE_APP = 0x2,
  eLEXTYPE_VENDORLEXICON = 0x4,
  eLEXTYPE_LETTERTOSOUND = 0x8,
  eLEXTYPE_MORPHOLOGY = 0x10,
  eLEXTYPE_RESERVED4 = 0x20,
  eLEXTYPE_USER_SHORTCUT = 0x40,
  eLEXTYPE_RESERVED6 = 0x80,
  eLEXTYPE_RESERVED7 = 0x100,
  eLEXTYPE_RESERVED8 = 0x200,
  eLEXTYPE_RESERVED9 = 0x400,
  eLEXTYPE_RESERVED10 = 0x800,
  eLEXTYPE_PRIVATE1 = 0x1000,
  eLEXTYPE_PRIVATE2 = 0x2000,
  eLEXTYPE_PRIVATE3 = 0x4000,
  eLEXTYPE_PRIVATE4 = 0x8000,
  eLEXTYPE_PRIVATE5 = 0x10000,
  eLEXTYPE_PRIVATE6 = 0x20000,
  eLEXTYPE_PRIVATE7 = 0x40000,
  eLEXTYPE_PRIVATE8 = 0x80000,
  eLEXTYPE_PRIVATE9 = 0x100000,
  eLEXTYPE_PRIVATE10 = 0x200000,
  eLEXTYPE_PRIVATE11 = 0x400000,
  eLEXTYPE_PRIVATE12 = 0x800000,
  eLEXTYPE_PRIVATE13 = 0x1000000,
  eLEXTYPE_PRIVATE14 = 0x2000000,
  eLEXTYPE_PRIVATE15 = 0x4000000,
  eLEXTYPE_PRIVATE16 = 0x8000000,
  eLEXTYPE_PRIVATE17 = 0x10000000,
  eLEXTYPE_PRIVATE18 = 0x20000000,
  eLEXTYPE_PRIVATE19 = 0x40000000,
  eLEXTYPE_PRIVATE20 = 0x80000000u
} SPLEXICONTYPE;

typedef [hidden] enum SPWORDTYPE {
  eWORDTYPE_ADDED = 1,
  eWORDTYPE_DELETED = 2
} SPWORDTYPE;

#if _SAPI_BLD_ >= 0x53
typedef [hidden] enum SPPRONUNCIATIONFLAGS {
  ePRONFLAG_USED = 1
} SPPRONUNCIATIONFLAGS;

typedef [hidden] enum SPSHORTCUTTYPE {
  SPSHT_NotOverriden = -1,
  SPSHT_Unknown = 0,
  SPSHT_EMAIL = 0x1000,
  SPSHT_OTHER = 0x2000,
  SPPS_RESERVED1 = 0x3000,
  SPPS_RESERVED2 = 0x4000,
  SPPS_RESERVED3 = 0x5000,
  SPPS_RESERVED4 = 0xf000
} SPSHORTCUTTYPE;
#endif

typedef [hidden] 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
} SPVALUETYPE;

typedef [hidden] enum SPPHRASERNG {
  SPPR_ALL_ELEMENTS = -1
} SPPHRASERNG;

typedef [hidden] enum SPVACTIONS {
  SPVA_Speak = 0,
  SPVA_Silence,
  SPVA_Pronounce,
  SPVA_Bookmark,
  SPVA_SpellOut,
  SPVA_Section,
  SPVA_ParseUnknownTag
} SPVACTIONS;

typedef [hidden] enum SPRUNSTATE {
  SPRS_DONE = 1,
  SPRS_IS_SPEAKING = 2
} SPRUNSTATE;

typedef [hidden] enum SPVLIMITS {
  SPMIN_VOLUME = 0,
  SPMAX_VOLUME = 100,
  SPMIN_RATE = -10,
  SPMAX_RATE = 10
} SPVLIMITS;

typedef [hidden] enum SPVPRIORITY {
  SPVPRI_NORMAL = 0,
  SPVPRI_ALERT = 1,
  SPVPRI_OVER = 2
} SPVPRIORITY;

cpp_quote("EXTERN_C const GUID SPDFID_Text;")
cpp_quote("EXTERN_C const GUID SPDFID_WaveFormatEx;")

cpp_quote("")
const signed char SP_LOW_CONFIDENCE = -1;
const signed char SP_NORMAL_CONFIDENCE = 0;
const signed char SP_HIGH_CONFIDENCE = +1;
const float DEFAULT_WEIGHT = 1;
const ULONG SP_MAX_WORD_LENGTH = 128;
const ULONG SP_MAX_PRON_LENGTH = 384;
#if _SAPI_BLD_ >= 0x53
const ULONG SP_EMULATE_RESULT = 0x40000000;
#endif

cpp_quote("")
cpp_quote("#ifdef __cplusplus")
cpp_quote("interface ISpNotifyCallback {")
cpp_quote("  virtual HRESULT STDMETHODCALLTYPE NotifyCallback(WPARAM wParam, LPARAM lParam) = 0;")
cpp_quote("};")
cpp_quote("#else")
typedef void *ISpNotifyCallback;
cpp_quote("#endif")

cpp_quote("#if 0")
typedef void *SPNOTIFYCALLBACK;
cpp_quote("#else")
cpp_quote("typedef void __stdcall SPNOTIFYCALLBACK(WPARAM wParam, LPARAM lParam);")
cpp_quote("#endif")

[object, uuid (5eff4aef-8487-11d2-961c-00c04f8ee628), pointer_default (unique), restricted]
interface ISpNotifySource : IUnknown {
  HRESULT SetNotifySink ([in] ISpNotifySink *pNotifySink);
  [local] HRESULT SetNotifyWindowMessage ([in] HWND hWnd,[in] UINT Msg,[in] WPARAM wParam,[in] LPARAM lParam);
  [local] HRESULT SetNotifyCallbackFunction ([in] SPNOTIFYCALLBACK *pfnCallback,[in] WPARAM wParam,[in] LPARAM lParam);
  [local] HRESULT SetNotifyCallbackInterface ([in] ISpNotifyCallback *pSpCallback,[in] WPARAM wParam,[in] LPARAM lParam);
  [local] HRESULT SetNotifyWin32Event (void);
  [local] HRESULT WaitForNotifyEvent ([in] DWORD dwMilliseconds);
  [local] HANDLE GetNotifyEventHandle ();
}

[object, uuid (259684dc-37c3-11d2-9603-00c04f8ee628), pointer_default (unique), restricted]
interface ISpNotifySink : IUnknown {
  HRESULT Notify (void);
}

[object, local, uuid (ACA16614-5d3d-11d2-960e-00c04f8ee628), pointer_default (unique), restricted]
interface ISpNotifyTranslator : ISpNotifySink {
  HRESULT InitWindowMessage ([in] HWND hWnd,[in] UINT Msg,[in] WPARAM wParam,[in] LPARAM lParam);
  HRESULT InitCallback ([in] SPNOTIFYCALLBACK *pfnCallback,[in] WPARAM wParam,[in] LPARAM lParam);
  HRESULT InitSpNotifyCallback ([in] ISpNotifyCallback *pSpCallback,[in] WPARAM wParam,[in] LPARAM lParam);
  HRESULT InitWin32Event ([in] HANDLE hEvent,[in] WINBOOL fCloseHandleOnRelease);
  HRESULT Wait ([in] DWORD dwMilliseconds);
  HANDLE GetEventHandle ();
}

[object, local, uuid (14056581-E16C-11d2-BB90-00c04f8ee6c0), pointer_default (unique), restricted]
interface ISpDataKey : IUnknown {
  HRESULT SetData ([in] LPCWSTR pszValueName,[in] ULONG cbData,[in] const BYTE *pData);
  HRESULT GetData ([in] LPCWSTR pszValueName,[in] ULONG *pcbData,[out] BYTE *pData);
  HRESULT SetStringValue ([in] LPCWSTR pszValueName,[in] LPCWSTR pszValue);
  HRESULT GetStringValue ([in] LPCWSTR pszValueName,[out] LPWSTR *ppszValue);
  HRESULT SetDWORD ([in] LPCWSTR pszValueName,[in] DWORD dwValue);
  HRESULT GetDWORD ([in] LPCWSTR pszValueName,[out] DWORD *pdwValue);
  HRESULT OpenKey ([in] LPCWSTR pszSubKeyName,[out] ISpDataKey **ppSubKey);
  HRESULT CreateKey ([in] LPCWSTR pszSubKey,[out] ISpDataKey **ppSubKey);
  HRESULT DeleteKey ([in] LPCWSTR pszSubKey);
  HRESULT DeleteValue ([in] LPCWSTR pszValueName);
  HRESULT EnumKeys ([in] ULONG Index,[out] LPWSTR *ppszSubKeyName);
  HRESULT EnumValues ([in] ULONG Index,[out] LPWSTR *ppszValueName);
};

[object, uuid (5b559f40-E952-11d2-BB91-00c04f8ee6c0), pointer_default (unique), restricted]
interface ISpObjectWithToken : IUnknown {
  HRESULT SetObjectToken ([in] ISpObjectToken *pToken);
  HRESULT GetObjectToken ([out] ISpObjectToken **ppToken);
};

[object, local, uuid (06b64f9e-7fda-11d2-B4F2-00c04f797396), pointer_default (unique), restricted]
interface IEnumSpObjectTokens : IUnknown {
  HRESULT Next ([in] ULONG celt,[out, size_is (celt), length_is (*pceltFetched)] ISpObjectToken **pelt,[out] ULONG *pceltFetched);
  HRESULT Skip ([in] ULONG celt);
  HRESULT Reset (void);
  HRESULT Clone ([out] IEnumSpObjectTokens **ppEnum);
  HRESULT Item ([in] ULONG Index,[out] ISpObjectToken **ppToken);
  HRESULT GetCount ([out] ULONG *pCount);
};

[object, uuid (92a66e2b-C830-4149-83df-6fc2ba1e7a5b), pointer_default (unique), restricted]
interface ISpRegDataKey : ISpDataKey {
  [local] HRESULT SetKey ([in] HKEY hkey,[in] WINBOOL fReadOnly);
}

[object, local, uuid (2d3d3845-39af-4850-BBF9-40b49780011d), pointer_default (unique), restricted]
interface ISpObjectTokenCategory : ISpDataKey {
  HRESULT SetId ([in] LPCWSTR pszCategoryId,[in] WINBOOL fCreateIfNotExist);
  HRESULT GetId ([out] LPWSTR *ppszCoMemCategoryId);
  HRESULT GetDataKey ([in] SPDATAKEYLOCATION spdkl,[out] ISpDataKey **ppDataKey);
  HRESULT EnumTokens ([in, string] LPCWSTR pzsReqAttribs,[in, string] LPCWSTR pszOptAttribs,[out] IEnumSpObjectTokens **ppEnum);
  HRESULT SetDefaultTokenId ([in] LPCWSTR pszTokenId);
  HRESULT GetDefaultTokenId ([out] LPWSTR *ppszCoMemTokenId);
};

[object, local, uuid (14056589-E16C-11d2-BB90-00c04f8ee6c0), pointer_default (unique), restricted]
interface ISpObjectToken : ISpDataKey {
  HRESULT SetId (LPCWSTR pszCategoryId,[in] LPCWSTR pszTokenId,[in] WINBOOL fCreateIfNotExist);
  HRESULT GetId ([out] LPWSTR *ppszCoMemTokenId);
  HRESULT GetCategory ([out] ISpObjectTokenCategory **ppTokenCategory);
  HRESULT CreateInstance ([in] IUnknown *pUnkOuter,[in] DWORD dwClsContext,[in] REFIID riid,[out, iid_is (riid)] void **ppvObject);
  HRESULT GetStorageFileName ([in] REFCLSID clsidCaller,[in] LPCWSTR pszValueName,[in, string] LPCWSTR pszFileNameSpecifier,[in] ULONG nFolder,[out] LPWSTR *ppszFilePath);
  HRESULT RemoveStorageFileName ([in] REFCLSID clsidCaller,[in] LPCWSTR pszKeyName,[in] WINBOOL fDeleteFile);
  HRESULT Remove (const CLSID *pclsidCaller);
  [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[in] IUnknown *punkObject,[out] WINBOOL *pfSupported);
  [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[in] IUnknown *punkObject);
  HRESULT MatchesAttributes ([in] LPCWSTR pszAttributes,[out] WINBOOL *pfMatches);
};

[object, uuid (B8AAB0CF-346f-49d8-9499-C8B03F161D51), pointer_default (unique), restricted]
interface ISpObjectTokenInit : ISpObjectToken {
  HRESULT InitFromDataKey ([in] LPCWSTR pszCategoryId,[in] LPCWSTR pszTokenId,[in] ISpDataKey *pDataKey);
};

[object, uuid (93384e18-5014-43d5-ADBB-A78E055926BD), pointer_default (unique), restricted]
interface ISpResourceManager : IServiceProvider
{
  HRESULT SetObject ([in] REFGUID guidServiceId,[in] IUnknown *pUnkObject);
  HRESULT GetObject ([in] REFGUID guidServiceId,[in] REFCLSID ObjectCLSID,[in] REFIID ObjectIID,[in] WINBOOL fReleaseWhenLastExternalRefReleased,[out, iid_is (ObjectIID)] void **ppObject);
};

cpp_quote("#if 0")
typedef [restricted, hidden] struct SPEVENT {
  WORD eEventId;
  WORD elParamType;
  ULONG ulStreamNum;
  ULONGLONG ullAudioStreamOffset;
  WPARAM wParam;
  LPARAM lParam;
} SPEVENT;

typedef [restricted, hidden] struct SPSERIALIZEDEVENT {
  WORD eEventId;
  WORD elParamType;
  ULONG ulStreamNum;
  ULONGLONG ullAudioStreamOffset;
  ULONG SerializedwParam;
  LONG SerializedlParam;
} SPSERIALIZEDEVENT;

typedef [restricted, hidden] struct SPSERIALIZEDEVENT64 {
  WORD eEventId;
  WORD elParamType;
  ULONG ulStreamNum;
  ULONGLONG ullAudioStreamOffset;
  ULONGLONG SerializedwParam;
  LONGLONG SerializedlParam;
} SPSERIALIZEDEVENT64;
cpp_quote("#else")
cpp_quote("typedef struct SPEVENT {")
cpp_quote("  SPEVENTENUM eEventId : 16;")
cpp_quote("  SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote("  ULONG ulStreamNum;")
cpp_quote("  ULONGLONG ullAudioStreamOffset;")
cpp_quote("  WPARAM      wParam;")
cpp_quote("  LPARAM      lParam;")
cpp_quote("} SPEVENT;")
cpp_quote("")
cpp_quote("typedef struct SPSERIALIZEDEVENT {")
cpp_quote("  SPEVENTENUM eEventId : 16;")
cpp_quote("  SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote("  ULONG ulStreamNum;")
cpp_quote("  ULONGLONG ullAudioStreamOffset;")
cpp_quote("  ULONG SerializedwParam;")
cpp_quote("  LONG SerializedlParam;")
cpp_quote("} SPSERIALIZEDEVENT;")
cpp_quote("")
cpp_quote("typedef struct SPSERIALIZEDEVENT64 {")
cpp_quote("  SPEVENTENUM eEventId : 16;")
cpp_quote("  SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote("  ULONG ulStreamNum;")
cpp_quote("  ULONGLONG ullAudioStreamOffset;")
cpp_quote("  ULONGLONG SerializedwParam;")
cpp_quote("  LONGLONG SerializedlParam;")
cpp_quote("} SPSERIALIZEDEVENT64;")
cpp_quote("#endif")

#if _SAPI_BLD_ >= 0x53
cpp_quote("#if 0")
typedef [restricted, hidden] struct SPEVENTEX {
  WORD eEventId;
  WORD elParamType;
  ULONG ulStreamNum;
  ULONGLONG ullAudioStreamOffset;
  WPARAM wParam;
  LPARAM lParam;
  ULONGLONG ullAudioTimeOffset;
} SPEVENTEX;
cpp_quote("#else")
cpp_quote("typedef struct SPEVENTEX {")
cpp_quote("  SPEVENTENUM eEventId : 16;")
cpp_quote("  SPEVENTLPARAMTYPE elParamType : 16;")
cpp_quote("  ULONG ulStreamNum;")
cpp_quote("  ULONGLONG ullAudioStreamOffset;")
cpp_quote("  WPARAM wParam;")
cpp_quote("  LPARAM lParam;")
cpp_quote("  ULONGLONG ullAudioTimeOffset;")
cpp_quote("} SPEVENTEX;")
cpp_quote("#endif")
#endif

typedef [restricted, hidden] struct SPEVENTSOURCEINFO {
  ULONGLONG ullEventInterest;
  ULONGLONG ullQueuedInterest;
  ULONG ulCount;
} SPEVENTSOURCEINFO;

[object, local, uuid (BE7A9CCE-5f9e-11d2-960f-00c04f8ee628), pointer_default (unique), restricted]
interface ISpEventSource : ISpNotifySource {
  HRESULT SetInterest ([in] ULONGLONG ullEventInterest,[in] ULONGLONG ullQueuedInterest);
  HRESULT GetEvents ([in] ULONG ulCount,[out, size_is (ulCount)] SPEVENT *pEventArray,[out] ULONG *pulFetched);
  HRESULT GetInfo ([out] SPEVENTSOURCEINFO *pInfo);
};

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (2373a435-6a4b-429e-A6AC-D4231A61975B), pointer_default (unique), restricted]
interface ISpEventSource2 : ISpEventSource {
  HRESULT GetEventsEx ([in] ULONG ulCount,[out, size_is (ulCount)] SPEVENTEX *pEventArray,[out] ULONG *pulFetched);
};
#endif

[object, local, uuid (BE7A9CC9-5f9e-11d2-960f-00c04f8ee628), pointer_default (unique), restricted]
interface ISpEventSink : IUnknown {
  HRESULT AddEvents ([in] const SPEVENT *pEventArray,[in] ULONG ulCount);
  HRESULT GetEventInterest ([out] ULONGLONG *pullEventInterest);
};

[object, uuid (BED530BE-2606-4f4d-A1C0-54c5cda5566f), pointer_default (unique), restricted]
interface ISpStreamFormat : IStream {
  HRESULT GetFormat ([in] GUID *pguidFormatId,[out] WAVEFORMATEX **ppCoMemWaveFormatEx);
}

[object, local, uuid (12e3cca9-7518-44c5-A5E7-BA5A79CB929E), pointer_default (unique), restricted]
interface ISpStream : ISpStreamFormat {
  HRESULT SetBaseStream ([in] IStream *pStream,[in] REFGUID rguidFormat,[in] const WAVEFORMATEX *pWaveFormatEx);
  HRESULT GetBaseStream ([out] IStream **ppStream);
  HRESULT BindToFile ([in] LPCWSTR pszFileName,[in] SPFILEMODE eMode,[in] const GUID *pFormatId, const WAVEFORMATEX *pWaveFormatEx,[in] ULONGLONG ullEventInterest);
  HRESULT Close ();
}

[object, uuid (678a932c-EA71-4446-9b41-78fda6280a29), pointer_default (unique), restricted]
interface ISpStreamFormatConverter : ISpStreamFormat {
  HRESULT SetBaseStream ([in] ISpStreamFormat *pStream,[in] WINBOOL fSetFormatToBaseStreamFormat,[in] WINBOOL fWriteToBaseStream);
  HRESULT GetBaseStream ([out] ISpStreamFormat **ppStream);
  HRESULT SetFormat ([in] REFGUID rguidFormatIdOfConvertedStream,[in] const WAVEFORMATEX *pWaveFormatExOfConvertedStream);
  HRESULT ResetSeekPosition ();
  HRESULT ScaleConvertedToBaseOffset ([in] ULONGLONG ullOffsetConvertedStream,[out] ULONGLONG *pullOffsetBaseStream);
  HRESULT ScaleBaseToConvertedOffset ([in] ULONGLONG ullOffsetBaseStream,[out] ULONGLONG *pullOffsetConvertedStream);
};

typedef [restricted, hidden] struct SPAUDIOSTATUS {
  long cbFreeBuffSpace;
  ULONG cbNonBlockingIO;
  SPAUDIOSTATE State;
  ULONGLONG CurSeekPos;
  ULONGLONG CurDevicePos;
  DWORD dwAudioLevel;
  DWORD dwReserved2;
} SPAUDIOSTATUS;

typedef [restricted, hidden] struct SPAUDIOBUFFERINFO {
  ULONG ulMsMinNotification;
  ULONG ulMsBufferSize;
  ULONG ulMsEventBias;
} SPAUDIOBUFFERINFO;

[object, local, uuid (C05C768F-FAE8-4ec2-8e07-338321c12452), pointer_default (unique), restricted]
interface ISpAudio : ISpStreamFormat {
  HRESULT SetState ([in] SPAUDIOSTATE NewState,[in] ULONGLONG ullReserved);
  HRESULT SetFormat ([in] REFGUID rguidFmtId,[in] const WAVEFORMATEX *pWaveFormatEx);
  HRESULT GetStatus ([out] SPAUDIOSTATUS *pStatus);
  HRESULT SetBufferInfo ([in] const SPAUDIOBUFFERINFO *pBuffInfo);
  HRESULT GetBufferInfo ([out] SPAUDIOBUFFERINFO *pBuffInfo);
  HRESULT GetDefaultFormat ([out] GUID *pFormatId,[out] WAVEFORMATEX **ppCoMemWaveFormatEx);
  HANDLE EventHandle ();
  HRESULT GetVolumeLevel ([out] ULONG *pLevel);
  HRESULT SetVolumeLevel ([in] ULONG Level);
  HRESULT GetBufferNotifySize ([out] ULONG *pcbSize);
  HRESULT SetBufferNotifySize ([in] ULONG cbSize);
};

[object, local, uuid (15806f6e-1d70-4b48-98e6-3b1a007509ab), pointer_default (unique), restricted]
interface ISpMMSysAudio : ISpAudio {
  HRESULT GetDeviceId ([out] UINT *puDeviceId);
  HRESULT SetDeviceId ([in] UINT uDeviceId);
  HRESULT GetMMHandle ([out] void **pHandle);
  HRESULT GetLineId ([out] UINT *puLineId);
  HRESULT SetLineId ([in] UINT uLineId);
};

[object, uuid (10f63bce-201a-11d3-AC70-00c04f8ee6c0), pointer_default (unique), restricted]
interface ISpTranscript : IUnknown {
  HRESULT GetTranscript ([out, string] LPWSTR *ppszTranscript);
  HRESULT AppendTranscript ([in, string] LPCWSTR pszTranscript);
};

typedef WCHAR SPPHONEID;
typedef LPWSTR PSPPHONEID;
typedef LPCWSTR PCSPPHONEID;

typedef [restricted, hidden] struct SPPHRASEELEMENT {
  ULONG ulAudioTimeOffset;
  ULONG ulAudioSizeTime;
  ULONG ulAudioStreamOffset;
  ULONG ulAudioSizeBytes;
  ULONG ulRetainedStreamOffset;
  ULONG ulRetainedSizeBytes;
  LPCWSTR pszDisplayText;
  LPCWSTR pszLexicalForm;
  const SPPHONEID *pszPronunciation;
  BYTE bDisplayAttributes;
  signed char RequiredConfidence;
  signed char ActualConfidence;
  BYTE Reserved;
  float SREngineConfidence;
} SPPHRASEELEMENT;

typedef [restricted, hidden] struct SPPHRASERULE SPPHRASERULE;
typedef [restricted, hidden] struct SPPHRASEPROPERTY SPPHRASEPROPERTY;

struct SPPHRASERULE {
  LPCWSTR pszName;
  ULONG ulId;
  ULONG ulFirstElement;
  ULONG ulCountOfElements;
  const SPPHRASERULE *pNextSibling;
  const SPPHRASERULE *pFirstChild;
  float SREngineConfidence;
  signed char Confidence;
};

struct SPPHRASEPROPERTY {
  LPCWSTR pszName;
  union {
    ULONG ulId;
    struct {
      byte bType;
      byte bReserved;
      unsigned short usArrayIndex;
    };
  };
  LPCWSTR pszValue;
  VARIANT vValue;
  ULONG ulFirstElement;
  ULONG ulCountOfElements;
  const SPPHRASEPROPERTY *pNextSibling;
  const SPPHRASEPROPERTY *pFirstChild;
  float SREngineConfidence;
  signed char Confidence;
};

typedef [restricted, hidden] struct SPPHRASEREPLACEMENT {
  BYTE bDisplayAttributes;
  LPCWSTR pszReplacementText;
  ULONG ulFirstElement;
  ULONG ulCountOfElements;
} SPPHRASEREPLACEMENT;

#if _SAPI_BLD_ >= 0x53
typedef [restricted, hidden] struct SPSEMANTICERRORINFO {
  ULONG ulLineNumber;
  LPWSTR pszScriptLine;
  LPWSTR pszSource;
  LPWSTR pszDescription;
  HRESULT hrResultCode;
} SPSEMANTICERRORINFO;
#endif

#if _SAPI_BLD_ >= 0x53
typedef [restricted, hidden] struct SPPHRASE_50
#else
typedef [restricted, hidden] struct SPPHRASE
#endif
{
  ULONG cbSize;
  LANGID LangID;
  WORD wHomophoneGroupId;
  ULONGLONG ullGrammarID;
  ULONGLONG ftStartTime;
  ULONGLONG ullAudioStreamPosition;
  ULONG ulAudioSizeBytes;
  ULONG ulRetainedSizeBytes;
  ULONG ulAudioSizeTime;
  SPPHRASERULE Rule;
  const SPPHRASEPROPERTY *pProperties;
  const SPPHRASEELEMENT *pElements;
  ULONG cReplacements;
  const SPPHRASEREPLACEMENT *pReplacements;
  GUID SREngineID;
  ULONG ulSREnginePrivateDataSize;
  const BYTE *pSREnginePrivateData;
}
#if _SAPI_BLD_ >= 0x53
SPPHRASE_50;
#else
SPPHRASE;
#endif

#if _SAPI_BLD_ >= 0x53
cpp_quote("#define SP_SPPHRASESIZE_500 sizeof (SPPHRASE_50)")

cpp_quote("#ifdef __cplusplus")
#if _SAPI_BLD_ > 0x53
cpp_quote("typedef struct SPPHRASE_53 : public SPPHRASE_50 {")
#else
cpp_quote("typedef struct SPPHRASE : public SPPHRASE_50 {")
#endif
cpp_quote("  LPWSTR pSML;")
cpp_quote("  SPSEMANTICERRORINFO* pSemanticErrorInfo;")
#if _SAPI_BLD_ > 0x53
cpp_quote("} SPPHRASE_53;")
#else
cpp_quote("} SPPHRASE;")
#endif
cpp_quote("#else")
#if _SAPI_BLD_ > 0x53
typedef [restricted, hidden] struct SPPHRASE_53
#else
typedef [restricted, hidden] struct SPPHRASE
#endif
{
  ULONG cbSize;
  LANGID LangID;
  WORD wHomophoneGroupId;
  ULONGLONG ullGrammarID;
  ULONGLONG ftStartTime;
  ULONGLONG ullAudioStreamPosition;
  ULONG ulAudioSizeBytes;
  ULONG ulRetainedSizeBytes;
  ULONG ulAudioSizeTime;
  SPPHRASERULE Rule;
  const SPPHRASEPROPERTY *pProperties;
  const SPPHRASEELEMENT *pElements;
  ULONG cReplacements;
  const SPPHRASEREPLACEMENT *pReplacements;
  GUID SREngineID;
  ULONG ulSREnginePrivateDataSize;
  const BYTE *pSREnginePrivateData;
  LPWSTR pSML;
  SPSEMANTICERRORINFO *pSemanticErrorInfo;
}
#if _SAPI_BLD_ > 0x53
SPPHRASE_53;
#else
SPPHRASE;
#endif
cpp_quote("#endif")
#endif

#if _SAPI_BLD_ >= 0x54
cpp_quote("#define SP_SPPHRASESIZE_530 sizeof (SPPHRASE_53)")

cpp_quote("#ifdef __cplusplus")
cpp_quote("typedef struct SPPHRASE : public SPPHRASE_53 {")
cpp_quote("  SPSEMANTICFORMAT SemanticTagFormat;")
cpp_quote("} SPPHRASE;")
cpp_quote("#else")
typedef [restricted, hidden] struct SPPHRASE {
  ULONG cbSize;
  LANGID LangID;
  WORD wHomophoneGroupId;
  ULONGLONG ullGrammarID;
  ULONGLONG ftStartTime;
  ULONGLONG ullAudioStreamPosition;
  ULONG ulAudioSizeBytes;
  ULONG ulRetainedSizeBytes;
  ULONG ulAudioSizeTime;
  SPPHRASERULE Rule;
  const SPPHRASEPROPERTY *pProperties;
  const SPPHRASEELEMENT *pElements;
  ULONG cReplacements;
  const SPPHRASEREPLACEMENT *pReplacements;
  GUID SREngineID;
  ULONG ulSREnginePrivateDataSize;
  const BYTE *pSREnginePrivateData;
  LPWSTR pSML;
  SPSEMANTICERRORINFO *pSemanticErrorInfo;
  SPSEMANTICFORMAT SemanticTagFormat;
} SPPHRASE;
cpp_quote("#endif")
#endif

typedef [restricted, hidden] struct SPSERIALIZEDPHRASE {
  ULONG ulSerializedSize;
} SPSERIALIZEDPHRASE;

#if _SAPI_BLD_ >= 0x53
typedef [restricted, hidden] struct SPRULE {
  LPCWSTR pszRuleName;
  ULONG ulRuleId;
  DWORD dwAttributes;
} SPRULE;
#endif

typedef [hidden] struct SPBINARYGRAMMAR {
  ULONG ulTotalSerializedSize;
} SPBINARYGRAMMAR;

cpp_quote("#if 0")
typedef void *SPSTATEHANDLE;
cpp_quote("#else")
cpp_quote("DECLARE_HANDLE(SPSTATEHANDLE);")
cpp_quote("#endif")

typedef [restricted, hidden] struct SPWORDPRONUNCIATION {
  struct SPWORDPRONUNCIATION *pNextWordPronunciation;
  SPLEXICONTYPE eLexiconType;
  LANGID LangID;
  WORD wPronunciationFlags;
  SPPARTOFSPEECH ePartOfSpeech;
  SPPHONEID szPronunciation[1];
} SPWORDPRONUNCIATION;

typedef [restricted, hidden] struct SPWORDPRONUNCIATIONLIST {
  ULONG ulSize;
  BYTE *pvBuffer;
  SPWORDPRONUNCIATION *pFirstWordPronunciation;
} SPWORDPRONUNCIATIONLIST;

typedef [restricted, hidden] struct SPWORD {
  struct SPWORD *pNextWord;
  LANGID LangID;
  WORD wReserved;
  SPWORDTYPE eWordType;
  LPWSTR pszWord;
  SPWORDPRONUNCIATION *pFirstWordPronunciation;
} SPWORD;

typedef [restricted, hidden] struct SPWORDLIST {
  ULONG ulSize;
  BYTE *pvBuffer;
  SPWORD *pFirstWord;
} SPWORDLIST;

[object, local, uuid (DA41A7C2-5383-4db2-916b-6c1719e3db58), pointer_default (unique), restricted]
interface ISpLexicon : IUnknown {
  HRESULT GetPronunciations ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] DWORD dwFlags,[in, out] SPWORDPRONUNCIATIONLIST *pWordPronunciationList);
  HRESULT AddPronunciation ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] SPPARTOFSPEECH ePartOfSpeech,[in] PCSPPHONEID pszPronunciation);
  HRESULT RemovePronunciation ([in] LPCWSTR pszWord,[in] LANGID LangID,[in] SPPARTOFSPEECH ePartOfSpeech,[in] PCSPPHONEID pszPronunciation);
  HRESULT GetGeneration ([out] DWORD *pdwGeneration);
  HRESULT GetGenerationChange ([in] DWORD dwFlags,[in, out] DWORD *pdwGeneration,[in, out] SPWORDLIST *pWordList);
  HRESULT GetWords ([in] DWORD dwFlags,[in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPWORDLIST *pWordList);
};

[object, uuid (8565572f-C094-41cc-B56E-10bd9c3ff044), pointer_default (unique), restricted]
interface ISpContainerLexicon : ISpLexicon {
  HRESULT AddLexicon ([in] ISpLexicon *pAddLexicon,[in] DWORD dwFlags);
};

#if _SAPI_BLD_ >= 0x53
typedef [restricted, hidden] struct SPSHORTCUTPAIR {
  struct SPSHORTCUTPAIR *pNextSHORTCUTPAIR;
  LANGID LangID;
  SPSHORTCUTTYPE shType;
  LPWSTR pszDisplay;
  LPWSTR pszSpoken;
} SPSHORTCUTPAIR;

typedef [restricted, hidden] struct SPSHORTCUTPAIRLIST {
  ULONG ulSize;
  BYTE *pvBuffer;
  SPSHORTCUTPAIR *pFirstShortcutPair;
} SPSHORTCUTPAIRLIST;
#endif

#if _SAPI_BLD_ >= 0x53
[object, uuid (3df681e2-EA56-11d9-8bde-F66BAD1E3F3A), pointer_default (unique), restricted]
interface ISpShortcut : IUnknown {
  HRESULT AddShortcut ([in] LPCWSTR pszDisplay,[in] LANGID LangID,[in] LPCWSTR pszSpoken,[in] SPSHORTCUTTYPE shType);
  HRESULT RemoveShortcut ([in] LPCWSTR pszDisplay,[in] LANGID LangID,[in] LPCWSTR pszSpoken,[in] SPSHORTCUTTYPE shType);
  HRESULT GetShortcuts ([in] LANGID LangID,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList);
  HRESULT GetGeneration ([out] DWORD *pdwGeneration);
  HRESULT GetWordsFromGenerationChange ([in, out] DWORD *pdwGeneration,[in, out] SPWORDLIST *pWordList);
  HRESULT GetWords ([in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPWORDLIST *pWordList);
  HRESULT GetShortcutsForGeneration ([in, out] DWORD *pdwGeneration,[in, out] DWORD *pdwCookie,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList);
  HRESULT GetGenerationChange ([in, out] DWORD *pdwGeneration,[in, out] SPSHORTCUTPAIRLIST *pShortcutpairList);
};
#endif

[object, uuid (8445c581-0cac-4a38-ABFE-9b2ce2826455), pointer_default (unique), restricted]
interface ISpPhoneConverter : ISpObjectWithToken {
  HRESULT PhoneToId ([in] LPCWSTR pszPhone,[out] SPPHONEID *pId);
  HRESULT IdToPhone ([in] PCSPPHONEID pId,[out] WCHAR *pszPhone);
};

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (133adcd4-19b4-4020-9fdc-842e78253b17), pointer_default (unique), restricted]
interface ISpPhoneticAlphabetConverter : IUnknown {
  HRESULT GetLangId ([out] LANGID *pLangID);
  HRESULT SetLangId ([in] LANGID LangID);
  HRESULT SAPI2UPS ([in] const SPPHONEID *pszSAPIId,[out] SPPHONEID *pszUPSId,[in] DWORD cMaxLength);
  HRESULT UPS2SAPI ([in] const SPPHONEID *pszUPSId,[out] SPPHONEID *pszSAPIId,[in] DWORD cMaxLength);
  HRESULT GetMaxConvertLength ([in] DWORD cSrcLength,[in] WINBOOL bSAPI2UPS,[out] DWORD *pcMaxDestLength);
};

[object, uuid (B2745EFD-42ce-48ca-81f1-A96E02538A90), pointer_default (unique), restricted]
interface ISpPhoneticAlphabetSelection : IUnknown {
  HRESULT IsAlphabetUPS ([out] WINBOOL *pfIsUPS);
  HRESULT SetAlphabetToUPS ([in] WINBOOL fForceUPS);
};
#endif

typedef [restricted, hidden] struct SPVPITCH {
  long MiddleAdj;
  long RangeAdj;
} SPVPITCH;

typedef [restricted, hidden] struct SPVCONTEXT {
  LPCWSTR pCategory;
  LPCWSTR pBefore;
  LPCWSTR pAfter;
} SPVCONTEXT;

typedef [restricted, hidden] struct SPVSTATE {
  SPVACTIONS eAction;
  LANGID LangID;
  WORD wReserved;
  long EmphAdj;
  long RateAdj;
  ULONG Volume;
  SPVPITCH PitchAdj;
  ULONG SilenceMSecs;
  SPPHONEID *pPhoneIds;
  SPPARTOFSPEECH ePartOfSpeech;
  SPVCONTEXT Context;
} SPVSTATE;

typedef [restricted, hidden] struct SPVOICESTATUS {
  ULONG ulCurrentStream;
  ULONG ulLastStreamQueued;
  HRESULT hrLastResult;
  DWORD dwRunningState;
  ULONG ulInputWordPos;
  ULONG ulInputWordLen;
  ULONG ulInputSentPos;
  ULONG ulInputSentLen;
  LONG lBookmarkId;
  SPPHONEID PhonemeId;
  SPVISEMES VisemeId;
  DWORD dwReserved1;
  DWORD dwReserved2;
} SPVOICESTATUS;

typedef [hidden] enum SPEAKFLAGS {
  SPF_DEFAULT = 0,
  SPF_ASYNC = 1,
  SPF_PURGEBEFORESPEAK = 2,
  SPF_IS_FILENAME = 4,
  SPF_IS_XML = 8,
  SPF_IS_NOT_XML = 0x10,
  SPF_PERSIST_XML = 0x20,
  SPF_NLP_SPEAK_PUNC = 0x40,
#if _SAPI_BLD_ >= 0x53
  SPF_PARSE_SAPI = 0x80,
  SPF_PARSE_SSML = 0x100,
  SPF_PARSE_AUTODETECT = 0,
#endif
  SPF_NLP_MASK = (SPF_NLP_SPEAK_PUNC),
#if _SAPI_BLD_ >= 0x53
  SPF_PARSE_MASK = (SPF_PARSE_SAPI | SPF_PARSE_SSML),
  SPF_VOICE_MASK = (SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML | SPF_NLP_MASK | SPF_PERSIST_XML | SPF_PARSE_MASK),
#else
  SPF_VOICE_MASK = (SPF_ASYNC | SPF_PURGEBEFORESPEAK | SPF_IS_FILENAME | SPF_IS_XML | SPF_IS_NOT_XML | SPF_NLP_MASK | SPF_PERSIST_XML),
#endif
  SPF_UNUSED_FLAGS = ~ (SPF_VOICE_MASK)
} SPEAKFLAGS;

[object, local, uuid (6c44df74-72b9-4992-A1EC-EF996E0422D4), pointer_default (unique), restricted]
interface ISpVoice : ISpEventSource {
  HRESULT SetOutput ([in] IUnknown *pUnkOutput,[in] WINBOOL fAllowFormatChanges);
  HRESULT GetOutputObjectToken ([out] ISpObjectToken **ppObjectToken);
  HRESULT GetOutputStream ([out] ISpStreamFormat **ppStream);
  HRESULT Pause (void);
  HRESULT Resume (void);
  HRESULT SetVoice ([in] ISpObjectToken *pToken);
  HRESULT GetVoice ([out] ISpObjectToken **ppToken);
  HRESULT Speak ([in, string] LPCWSTR pwcs,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber);
  HRESULT SpeakStream ([in] IStream *pStream,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber);
  HRESULT GetStatus ([out] SPVOICESTATUS *pStatus,[out] LPWSTR *ppszLastBookmark);
  HRESULT Skip ([in, string] LPCWSTR pItemType,[in] long lNumItems,[out] ULONG *pulNumSkipped);
  HRESULT SetPriority ([in] SPVPRIORITY ePriority);
  HRESULT GetPriority ([out] SPVPRIORITY *pePriority);
  HRESULT SetAlertBoundary ([in] SPEVENTENUM eBoundary);
  HRESULT GetAlertBoundary ([out] SPEVENTENUM *peBoundary);
  HRESULT SetRate ([in] long RateAdjust);
  HRESULT GetRate ([out] long *pRateAdjust);
  HRESULT SetVolume ([in] USHORT usVolume);
  HRESULT GetVolume ([out] USHORT *pusVolume);
  HRESULT WaitUntilDone ([in] ULONG msTimeout);
  HRESULT SetSyncSpeakTimeout ([in] ULONG msTimeout);
  HRESULT GetSyncSpeakTimeout ([out] ULONG *pmsTimeout);
  [local] HANDLE SpeakCompleteEvent ();
  [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[out] WINBOOL *pfSupported);
  [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData);
};

[object, local, uuid (1a5c0354-B621-4b5a-8791-D306ED379E53), pointer_default (unique), restricted]
interface ISpPhrase : IUnknown {
  HRESULT GetPhrase ([out] SPPHRASE **ppCoMemPhrase);
  HRESULT GetSerializedPhrase ([out] SPSERIALIZEDPHRASE **ppCoMemPhrase);
  HRESULT GetText ([in] ULONG ulStart,[in] ULONG ulCount,[in] WINBOOL fUseTextReplacements,[out] LPWSTR *ppszCoMemText,[out, optional] BYTE *pbDisplayAttributes);
  HRESULT Discard ([in] DWORD dwValueTypes);
};

[object, local, uuid (8fcebc98-4e49-4067-9c6c-D86A0E092E3D), pointer_default (unique), restricted]
interface ISpPhraseAlt : ISpPhrase {
  HRESULT GetAltInfo ([out] ISpPhrase **ppParent,[out] ULONG *pulStartElementInParent,[out] ULONG *pcElementsInParent,[out] ULONG *pcElementsInAlt);
  HRESULT Commit ();
};

#if _SAPI_BLD_ >= 0x53
typedef enum SPXMLRESULTOPTIONS {
  SPXRO_SML = 0,
  SPXRO_Alternates_SML = 1
} SPXMLRESULTOPTIONS;
#endif

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (F264DA52-E457-4696-B856-A737B717AF79), pointer_default (unique), restricted]
interface ISpPhrase2 : ISpPhrase {
  HRESULT GetXMLResult ([out] LPWSTR *ppszCoMemXMLResult,[in] SPXMLRESULTOPTIONS Options);
  HRESULT GetXMLErrorInfo ([out] SPSEMANTICERRORINFO *pSemanticErrorInfo);
  HRESULT GetAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[out] ISpStreamFormat **ppStream);
};
#endif

typedef [restricted, hidden] struct SPRECORESULTTIMES {
  FILETIME ftStreamTime;
  ULONGLONG ullLength;
  DWORD dwTickCount;
  ULONGLONG ullStart;
} SPRECORESULTTIMES;

typedef [hidden] struct SPSERIALIZEDRESULT {
  ULONG ulSerializedSize;
} SPSERIALIZEDRESULT;

[object, local, uuid (20b053be-E235-43cd-9a2a-8d17a48b7842), pointer_default (unique), restricted]
interface ISpRecoResult : ISpPhrase {
  HRESULT GetResultTimes ([out] SPRECORESULTTIMES *pTimes);
  HRESULT GetAlternates ([in] ULONG ulStartElement,[in] ULONG cElements,[in] ULONG ulRequestCount,[out] ISpPhraseAlt **ppPhrases,[out] ULONG *pcPhrasesReturned);
  HRESULT GetAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[out] ISpStreamFormat **ppStream);
  HRESULT SpeakAudio ([in] ULONG ulStartElement,[in] ULONG cElements,[in] DWORD dwFlags,[out] ULONG *pulStreamNumber);
  HRESULT Serialize ([out] SPSERIALIZEDRESULT **ppCoMemSerializedResult);
  HRESULT ScaleAudio ([in] const GUID *pAudioFormatId,[in] const WAVEFORMATEX *pWaveFormatEx);
  HRESULT GetRecoContext ([out] ISpRecoContext **ppRecoContext);
};

#if _SAPI_BLD_ >= 0x53
typedef [hidden] enum SPCOMMITFLAGS {
  SPCF_NONE = 0,
  SPCF_ADD_TO_USER_LEXICON = (1 << 0),
  SPCF_DEFINITE_CORRECTION = (1 << 1)
} SPCOMMITFLAGS;
#endif

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (27cac6c4-88f2-41f2-8817-0c95e59f1e6e), pointer_default (unique), restricted]
interface ISpRecoResult2 : ISpRecoResult {
  HRESULT CommitAlternate ([in] ISpPhraseAlt *pPhraseAlt,[out] ISpRecoResult **ppNewResult);
  HRESULT CommitText ([in] ULONG ulStartElement,[in] ULONG cElements,[in] LPCWSTR pszCorrectedData,[in] DWORD eCommitFlags);
  HRESULT SetTextFeedback ([in, string] LPCWSTR pszFeedback,[in] WINBOOL fSuccessful);
}

[object, local, uuid (AE39362B-45a8-4074-9b9e-CCF49AA2D0B6), pointer_default (unique), restricted]
interface ISpXMLRecoResult : ISpRecoResult {
  HRESULT GetXMLResult ([out] LPWSTR *ppszCoMemXMLResult,[in] SPXMLRESULTOPTIONS Options);
  HRESULT GetXMLErrorInfo ([out] SPSEMANTICERRORINFO *pSemanticErrorInfo);
};
#endif

typedef [hidden] struct tagSPTEXTSELECTIONINFO {
  ULONG ulStartActiveOffset;
  ULONG cchActiveChars;
  ULONG ulStartSelection;
  ULONG cchSelection;
} SPTEXTSELECTIONINFO;

typedef [hidden] enum SPWORDPRONOUNCEABLE {
  SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE = 0,
  SPWP_UNKNOWN_WORD_PRONOUNCEABLE = 1,
  SPWP_KNOWN_WORD_PRONOUNCEABLE = 2
} SPWORDPRONOUNCEABLE;

typedef [hidden] enum SPGRAMMARSTATE {
  SPGS_DISABLED = 0,
  SPGS_ENABLED = 1,
  SPGS_EXCLUSIVE = 3
} SPGRAMMARSTATE;

typedef [hidden] enum SPCONTEXTSTATE {
  SPCS_DISABLED = 0,
  SPCS_ENABLED = 1,
} SPCONTEXTSTATE;

typedef [hidden] enum SPRULESTATE {
  SPRS_INACTIVE = 0,
  SPRS_ACTIVE = 1,
  SPRS_ACTIVE_WITH_AUTO_PAUSE = 3
#if _SAPI_BLD_ >= 0x53
  , SPRS_ACTIVE_USER_DELIMITED = 4
#endif
} SPRULESTATE;

const ULONGLONG SP_STREAMPOS_ASAP = 0;
const ULONGLONG SP_STREAMPOS_REALTIME = -1;

cpp_quote("#define SPRULETRANS_TEXTBUFFER (SPSTATEHANDLE) (-1)")
cpp_quote("#define SPRULETRANS_WILDCARD (SPSTATEHANDLE) (-2)")
cpp_quote("#define SPRULETRANS_DICTATION (SPSTATEHANDLE) (-3)")

typedef [hidden] enum SPGRAMMARWORDTYPE {
  SPWT_DISPLAY,
  SPWT_LEXICAL,
  SPWT_PRONUNCIATION
#if _SAPI_BLD_ >= 0x53
  , SPWT_LEXICAL_NO_SPECIAL_CHARS
#endif
} SPGRAMMARWORDTYPE;

typedef [hidden] struct tagSPPROPERTYINFO {
  LPCWSTR pszName;
  ULONG ulId;
  LPCWSTR pszValue;
  VARIANT vValue;
} SPPROPERTYINFO;

typedef [hidden] enum SPCFGRULEATTRIBUTES {
  SPRAF_TopLevel = 0x1,
  SPRAF_Active = 0x2,
  SPRAF_Export = 0x4,
  SPRAF_Import = 0x8,
  SPRAF_Interpreter = 0x10,
  SPRAF_Dynamic = 0x20,
#if _SAPI_BLD_ >= 0x53
  SPRAF_Root = 0x40,
#endif
  SPRAF_AutoPause = 0x10000
#if _SAPI_BLD_ >= 0x53
  , SPRAF_UserDelimited = 0x20000
#endif
} SPCFGRULEATTRIBUTES;

[object, local, uuid (8137828f-591a-4a42-BE58-49ea7ebaac68), pointer_default (unique), restricted]
interface ISpGrammarBuilder : IUnknown {
  HRESULT ResetGrammar ([in] LANGID NewLanguage);
  HRESULT GetRule ([in] LPCWSTR pszRuleName,[in] DWORD dwRuleId,[in] DWORD dwAttributes,[in] WINBOOL fCreateIfNotExist,[out] SPSTATEHANDLE *phInitialState);
  HRESULT ClearRule ([in] SPSTATEHANDLE hState);
  HRESULT CreateNewState ([in] SPSTATEHANDLE hState,[out] SPSTATEHANDLE *phState);
  HRESULT AddWordTransition ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] LPCWSTR psz,[in] LPCWSTR pszSeparators,[in] SPGRAMMARWORDTYPE eWordType,[in] float Weight,[in] const SPPROPERTYINFO *pPropInfo);
  HRESULT AddRuleTransition ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] SPSTATEHANDLE hRule,[in] float Weight,[in] const SPPROPERTYINFO *pPropInfo);
  HRESULT AddResource ([in] SPSTATEHANDLE hRuleState,[in] LPCWSTR pszResourceName,[in] LPCWSTR pszResourceValue);
  HRESULT Commit ([in] DWORD dwReserved);
};

typedef [hidden] enum SPLOADOPTIONS {
  SPLO_STATIC = 0,
  SPLO_DYNAMIC = 1
} SPLOADOPTIONS;

[object, local, uuid (2177db29-7f45-47d0-8554-067e91c80502), pointer_default (unique), restricted]
interface ISpRecoGrammar : ISpGrammarBuilder {
  HRESULT GetGrammarId ([out] ULONGLONG *pullGrammarId);
  HRESULT GetRecoContext ([out] ISpRecoContext **ppRecoCtxt);
  HRESULT LoadCmdFromFile ([in, string] LPCWSTR pszFileName,[in] SPLOADOPTIONS Options);
  HRESULT LoadCmdFromObject ([in] REFCLSID rcid,[in, string] LPCWSTR pszGrammarName,[in] SPLOADOPTIONS Options);
  HRESULT LoadCmdFromResource ([in] HMODULE hModule,[in, string] LPCWSTR pszResourceName,[in, string] LPCWSTR pszResourceType,[in] WORD wLanguage,[in] SPLOADOPTIONS Options);
  HRESULT LoadCmdFromMemory ([in] const SPBINARYGRAMMAR *pGrammar,[in] SPLOADOPTIONS Options);
  HRESULT LoadCmdFromProprietaryGrammar ([in] REFGUID rguidParam,[in, string] LPCWSTR pszStringParam,[in] const void *pvDataPrarm,[in] ULONG cbDataSize,[in] SPLOADOPTIONS Options);
  HRESULT SetRuleState ([in, string] LPCWSTR pszName,[in] void *pReserved,[in] SPRULESTATE NewState);
  HRESULT SetRuleIdState ([in] ULONG ulRuleId,[in] SPRULESTATE NewState);
  HRESULT LoadDictation ([in, string] LPCWSTR pszTopicName,[in] SPLOADOPTIONS Options);
  HRESULT UnloadDictation ();
  HRESULT SetDictationState ([in] SPRULESTATE NewState);
  HRESULT SetWordSequenceData ([in] const WCHAR *pText,[in] ULONG cchText,[in] const SPTEXTSELECTIONINFO *pInfo);
  HRESULT SetTextSelection ([in] const SPTEXTSELECTIONINFO *pInfo);
  HRESULT IsPronounceable ([in, string] LPCWSTR pszWord,[out] SPWORDPRONOUNCEABLE *pWordPronounceable);
  HRESULT SetGrammarState ([in] SPGRAMMARSTATE eGrammarState);
  HRESULT SaveCmd ([in] IStream *pStream,[out, optional] LPWSTR *ppszCoMemErrorText);
  HRESULT GetGrammarState ([out] SPGRAMMARSTATE *peGrammarState);
};

#if _SAPI_BLD_ >= 0x53
typedef enum SPMATCHINGMODE {
  AllWords = 0,
  Subsequence = 1,
  OrderedSubset = 3,
  SubsequenceContentRequired = 5,
  OrderedSubsetContentRequired = 7
} SPMATCHINGMODE;

typedef enum PHONETICALPHABET {
  PA_Ipa = 0,
  PA_Ups = 1,
  PA_Sapi = 2,
} PHONETICALPHABET;
#endif

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (8ab10026-20cc-4b20-8c22-A49C9BA78F60), pointer_default (unique), restricted]
interface ISpGrammarBuilder2 : IUnknown {
  HRESULT AddTextSubset ([in] SPSTATEHANDLE hFromState,[in] SPSTATEHANDLE hToState,[in] LPCWSTR psz,[in] SPMATCHINGMODE eMatchMode);
  HRESULT SetPhoneticAlphabet ([in] PHONETICALPHABET phoneticALphabet);
}

cpp_quote("#define SPRP_NORMAL 0")

[object, local, uuid (4b37bc9e-9ed6-44a3-93d3-18f022b79ec3), pointer_default (unique), restricted]
interface ISpRecoGrammar2 : IUnknown {
  HRESULT GetRules ([out] SPRULE **ppCoMemRules,[out] UINT *puNumRules);
  HRESULT LoadCmdFromFile2 ([in, string] LPCWSTR pszFileName,[in] SPLOADOPTIONS Options,[in, string] LPCWSTR pszSharingUri,[in, string] LPCWSTR pszBaseUri);
  HRESULT LoadCmdFromMemory2 ([in] const SPBINARYGRAMMAR *pGrammar,[in] SPLOADOPTIONS Options,[in, string] LPCWSTR pszSharingUri,[in, string] LPCWSTR pszBaseUri);
  HRESULT SetRulePriority ([in, string] LPCWSTR pszRuleName,[in] ULONG ulRuleId,[in] int nRulePriority);
  HRESULT SetRuleWeight ([in, string] LPCWSTR pszRuleName,[in] ULONG ulRuleId,[in] float flWeight);
  HRESULT SetDictationWeight ([in] float flWeight);
  HRESULT SetGrammarLoader ([in] ISpeechResourceLoader *pLoader);
  HRESULT SetSMLSecurityManager ([in] IInternetSecurityManager *pSMLSecurityManager);
}

[object, local, uuid (B9AC5783-FCD0-4b21-B119-B4F8DA8FD2C3), pointer_default (unique), dual]
interface ISpeechResourceLoader : IDispatch {
  [id (1)] HRESULT LoadResource ([in] BSTR bstrResourceUri,[in] VARIANT_BOOL fAlwaysReload,[out] IUnknown **pStream,[out] BSTR *pbstrMIMEType,[out] VARIANT_BOOL *pfModified,[out] BSTR *pbstrRedirectUrl);
  [id (2)] HRESULT GetLocalCopy ([in] BSTR bstrResourceUri,[out] BSTR *pbstrLocalPath,[out] BSTR *pbstrMIMEType,[out] BSTR *pbstrRedirectUrl);
  [id (3)] HRESULT ReleaseLocalCopy ([in] BSTR pbstrLocalPath);
}
#endif

typedef [restricted, hidden] struct SPRECOCONTEXTSTATUS {
  SPINTERFERENCE eInterference;
  WCHAR szRequestTypeOfUI[255];
  DWORD dwReserved1;
  DWORD dwReserved2;
} SPRECOCONTEXTSTATUS;

typedef [hidden] enum SPBOOKMARKOPTIONS {
  SPBO_NONE = 0,
  SPBO_PAUSE = 0x1
#if _SAPI_BLD_ >= 0x53
  , SPBO_AHEAD = 0x2,
  SPBO_TIME_UNITS = 0x4
#endif
} SPBOOKMARKOPTIONS;

typedef [hidden] enum SPAUDIOOPTIONS {
  SPAO_NONE = 0,
  SPAO_RETAIN_AUDIO = 0x1
} SPAUDIOOPTIONS;

[object, local, uuid (F740A62F-7c15-489e-8234-940a33d9272d), pointer_default (unique), restricted]
interface ISpRecoContext : ISpEventSource {
  HRESULT GetRecognizer ([out] ISpRecognizer **ppRecognizer);
  HRESULT CreateGrammar ([in] ULONGLONG ullGrammarId,[out] ISpRecoGrammar **ppGrammar);
  HRESULT GetStatus ([out] SPRECOCONTEXTSTATUS *pStatus);
  HRESULT GetMaxAlternates ([in] ULONG *pcAlternates);
  HRESULT SetMaxAlternates ([in] ULONG cAlternates);
  HRESULT SetAudioOptions ([in] SPAUDIOOPTIONS Options,[in] const GUID *pAudioFormatId,[in] const WAVEFORMATEX *pWaveFormatEx);
  HRESULT GetAudioOptions ([in] SPAUDIOOPTIONS *pOptions,[out] GUID *pAudioFormatId,[out] WAVEFORMATEX **ppCoMemWFEX);
  HRESULT DeserializeResult ([in] const SPSERIALIZEDRESULT *pSerializedResult,[out] ISpRecoResult **ppResult);
  HRESULT Bookmark ([in] SPBOOKMARKOPTIONS Options,[in] ULONGLONG ullStreamPosition,[in] LPARAM lparamEvent);
  HRESULT SetAdaptationData ([in, string] LPCWSTR pAdaptationData,[in] const ULONG cch);
  HRESULT Pause ([in] DWORD dwReserved);
  HRESULT Resume ([in] DWORD dwReserved);
  HRESULT SetVoice ([in] ISpVoice *pVoice,[in] WINBOOL fAllowFormatChanges);
  HRESULT GetVoice ([out] ISpVoice **ppVoice);
  HRESULT SetVoicePurgeEvent ([in] ULONGLONG ullEventInterest);
  HRESULT GetVoicePurgeEvent ([out] ULONGLONG *pullEventInterest);
  HRESULT SetContextState ([in] SPCONTEXTSTATE eContextState);
  HRESULT GetContextState ([out] SPCONTEXTSTATE *peContextState);
};

#if _SAPI_BLD_ >= 0x53
typedef [hidden] enum SPGRAMMAROPTIONS {
  SPGO_SAPI = 0x1,
  SPGO_SRGS = 0x2,
  SPGO_UPS = 0x4,
  SPGO_SRGS_MS_SCRIPT = 0x8,
  SPGO_FILE = 0x10,
  SPGO_HTTP = 0x20,
  SPGO_RES = 0x40,
  SPGO_OBJECT = 0x80,
  SPGO_SRGS_W3C_SCRIPT = 0x100,
  SPGO_SRGS_STG_SCRIPT = 0x200,

  SPGO_SRGS_SCRIPT = SPGO_SRGS | SPGO_SRGS_MS_SCRIPT | SPGO_SRGS_W3C_SCRIPT | SPGO_SRGS_STG_SCRIPT,
  SPGO_DEFAULT = 0x03fb,
  SPGO_ALL = 0x03ff
} SPGRAMMAROPTIONS;

typedef [hidden] enum SPADAPTATIONSETTINGS {
  SPADS_Default = 0x0,
  SPADS_CurrentRecognizer = 0x1,
  SPADS_RecoProfile = 0x2,
  SPADS_Immediate = 0x4,
  SPADS_Reset = 0x8,
  SPADS_HighVolumeDataSource = 0x10
} SPADAPTATIONSETTINGS;

typedef [hidden] enum SPADAPTATIONRELEVANCE {
  SPAR_Unknown = 0,
  SPAR_Low = 1,
  SPAR_Medium = 2,
  SPAR_High = 3
} SPADAPTATIONRELEVANCE;
#endif

#if _SAPI_BLD_ >= 0x53
[object, local, uuid (BEAD311C-52ff-437f-9464-6b21054ca73d), pointer_default (unique), restricted]
interface ISpRecoContext2 : IUnknown {
  HRESULT SetGrammarOptions ([in] DWORD eGrammarOptions);
  HRESULT GetGrammarOptions ([out] DWORD *peGrammarOptions);
  HRESULT SetAdaptationData2 ([in] LPCWSTR pAdaptationData,[in] const ULONG cch,[in] LPCWSTR pTopicName,[in] DWORD eAdaptationSettings,[in] SPADAPTATIONRELEVANCE eRelevance);
}
#endif

[object, local, uuid (5b4fb971-B115-4de1-AD97-E482E3BF6EE4), pointer_default (unique), restricted]
interface ISpProperties : IUnknown {
  HRESULT SetPropertyNum ([in] LPCWSTR pName,[in] LONG lValue);
  HRESULT GetPropertyNum ([in] LPCWSTR pName,[out] LONG *plValue);
  HRESULT SetPropertyString ([in] LPCWSTR pName,[in] LPCWSTR pValue);
  HRESULT GetPropertyString ([in] LPCWSTR pName,[out, string] LPWSTR *ppCoMemValue);
};

const ULONG SP_MAX_LANGIDS = 20;

typedef [restricted, hidden] struct SPRECOGNIZERSTATUS {
  SPAUDIOSTATUS AudioStatus;
  ULONGLONG ullRecognitionStreamPos;
  ULONG ulStreamNumber;
  ULONG ulNumActive;
  CLSID clsidEngine;
  ULONG cLangIDs;
  LANGID aLangID[SP_MAX_LANGIDS];
  ULONGLONG ullRecognitionStreamTime;
} SPRECOGNIZERSTATUS;

typedef [hidden] enum SPWAVEFORMATTYPE {
  SPWF_INPUT,
  SPWF_SRENGINE
} SPSTREAMFORMATTYPE;

typedef [hidden] enum SPRECOSTATE {
  SPRST_INACTIVE,
  SPRST_ACTIVE,
  SPRST_ACTIVE_ALWAYS,
  SPRST_INACTIVE_WITH_PURGE,
  SPRST_NUM_STATES
} SPRECOSTATE;

#if _SAPI_BLD_ >= 0x54
typedef enum SPCATEGORYTYPE {
  SPCT_COMMAND,
  SPCT_DICTATION,
  SPCT_SLEEP,
  SPCT_SUB_COMMAND,
  SPCT_SUB_DICTATION
} SPCATEGORYTYPE;
#endif

[object, local, uuid (C2B5F241-DAA0-4507-9e16-5a1eaa2b7a5c), pointer_default (unique), restricted]
interface ISpRecognizer : ISpProperties {
  HRESULT SetRecognizer ([in] ISpObjectToken *pRecognizer);
  HRESULT GetRecognizer ([out] ISpObjectToken **ppRecognizer);
  HRESULT SetInput ([in] IUnknown *pUnkInput,[in] WINBOOL fAllowFormatChanges);
  HRESULT GetInputObjectToken ([out] ISpObjectToken **ppToken);
  HRESULT GetInputStream ([out] ISpStreamFormat **ppStream);
  HRESULT CreateRecoContext ([out] ISpRecoContext **ppNewCtxt);
  HRESULT GetRecoProfile ([out] ISpObjectToken **ppToken);
  HRESULT SetRecoProfile ([in] ISpObjectToken *pToken);
  HRESULT IsSharedInstance (void);
  HRESULT GetRecoState ([out] SPRECOSTATE *pState);
  HRESULT SetRecoState ([in] SPRECOSTATE NewState);
  HRESULT GetStatus ([out] SPRECOGNIZERSTATUS *pStatus);
  HRESULT GetFormat ([in] SPSTREAMFORMATTYPE WaveFormatType,[out] GUID *pFormatId,[out] WAVEFORMATEX **ppCoMemWFEX);
  [local] HRESULT IsUISupported ([in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData,[out] WINBOOL *pfSupported);
  [local] HRESULT DisplayUI ([in] HWND hwndParent,[in] LPCWSTR pszTitle,[in] LPCWSTR pszTypeOfUI,[in] void *pvExtraData,[in] ULONG cbExtraData);
  HRESULT EmulateRecognition ([in] ISpPhrase *pPhrase);
};

#if _SAPI_BLD_ >= 0x53
[object, uuid (21b501a0-0ec7-46c9-92c3-A2BC784C54B9), pointer_default (unique), restricted]
interface ISpSerializeState : IUnknown {
  HRESULT GetSerializedState ([out] BYTE **ppbData,[out] ULONG *pulSize,[in] DWORD dwReserved);
  HRESULT SetSerializedState ([in] BYTE *pbData,[in] ULONG ulSize,[in] DWORD dwReserved);
};

[object, local, uuid (8fc6d974-C81E-4098-93c5-0147f61ed4d3), pointer_default (unique), restricted]
interface ISpRecognizer2 : IUnknown {
  HRESULT EmulateRecognitionEx ([in] ISpPhrase *pPhrase,[in] DWORD dwCompareFlags);
  HRESULT SetTrainingState ([in] WINBOOL fDoingTraining,[in] WINBOOL fAdaptFromTrainingData);
  HRESULT ResetAcousticModelAdaptation ();
}

#if _SAPI_BLD_ >= 0x54
[object, local, uuid (DA0CD0F9-14a2-4f09-8c2a-85cc48979345), pointer_default (unique), restricted]
interface ISpRecoCategory : IUnknown {
  HRESULT GetType ([out] SPCATEGORYTYPE *peCategoryType);
}

[object, local, uuid (DF1B943C-5838-4aa2-8706-D7CD5B333499), pointer_default (unique), restricted]
interface ISpRecognizer3 : IUnknown {
  HRESULT GetCategory ([in] SPCATEGORYTYPE categoryType,[out] ISpRecoCategory **ppCategory);
  HRESULT SetActiveCategory ([in] ISpRecoCategory *pCategory);
  HRESULT GetActiveCategory ([out] ISpRecoCategory **ppCategory);
}
#endif

typedef [restricted, hidden] struct SPNORMALIZATIONLIST {
  ULONG ulSize;
  WCHAR **ppszzNormalizedList;
} SPNORMALIZATIONLIST;

[object, local, uuid (C360CE4B-76d1-4214-AD68-52657d5083da), pointer_default (unique), restricted]
interface ISpEnginePronunciation : IUnknown {
  HRESULT Normalize ([in, string] LPCWSTR pszWord,[in, string] LPCWSTR pszLeftContext,[in, string] LPCWSTR pszRightContext,[in] LANGID LangID,[out] SPNORMALIZATIONLIST *pNormalizationList);
  HRESULT GetPronunciations ([in, string] LPCWSTR pszWord,[in, string] LPCWSTR pszLeftContext,[in, string] LPCWSTR pszRightContext,[in] LANGID LangID,[in, out] SPWORDPRONUNCIATIONLIST *pEnginePronunciationList);
}

typedef [restricted, hidden] struct SPDISPLAYTOKEN {
  const WCHAR *pszLexical;
  const WCHAR *pszDisplay;
  BYTE bDisplayAttributes;
} SPDISPLAYTOKEN;

typedef [restricted, hidden] struct SPDISPLAYPHRASE {
  ULONG ulNumTokens;
  SPDISPLAYTOKEN *pTokens;
} SPDISPLAYPHRASE;

[object, local, uuid (C8D7C7E2-0dde-44b7-AFE3-B0C991FBEB5E), pointer_default (unique)]
interface ISpDisplayAlternates : IUnknown {
  HRESULT GetDisplayAlternates ([in] const SPDISPLAYPHRASE *pPhrase,[in] ULONG cRequestCount,[out] SPDISPLAYPHRASE **ppCoMemPhrases,[out] ULONG *pcPhrasesReturned);
  HRESULT SetFullStopTrailSpace ([in] ULONG ulTrailSpace);
}
#endif

[uuid (C866CA3A-32f7-11d2-9602-00c04f8ee628), version (5.4)]
library SpeechLib {
  importlib ("stdole32.tlb");
  importlib ("stdole2.tlb");

interface ISpeechDataKey;
interface ISpeechObjectToken;
interface ISpeechObjectTokens;
interface ISpeechObjectTokenCategory;
interface ISpeechAudioBufferInfo;
interface ISpeechAudioStatus;
interface ISpeechAudioFormat;
interface ISpeechWaveFormatEx;
interface ISpeechBaseStream;
interface ISpeechFileStream;
interface ISpeechMemoryStream;
interface ISpeechCustomStream;
interface ISpeechAudio;
interface ISpeechMMSysAudio;
interface ISpeechVoice;
interface ISpeechVoiceStatus;
dispinterface _ISpeechVoiceEvents;
interface ISpeechRecognizer;
interface ISpeechRecognizerStatus;
interface ISpeechRecoContext;
interface ISpeechRecoGrammar;
dispinterface _ISpeechRecoContextEvents;
interface ISpeechGrammarRule;
interface ISpeechGrammarRules;
interface ISpeechGrammarRuleState;
interface ISpeechGrammarRuleStateTransition;
interface ISpeechGrammarRuleStateTransitions;
interface ISpeechTextSelectionInformation;
interface ISpeechRecoResult;
#if _SAPI_BLD_ >= 0x53
interface ISpeechRecoResult2;
#endif
interface ISpeechRecoResultTimes;
interface ISpeechPhraseAlternate;
interface ISpeechPhraseAlternates;
interface ISpeechPhraseInfo;
interface ISpeechPhraseElement;
interface ISpeechPhraseElements;
interface ISpeechPhraseReplacement;
interface ISpeechPhraseReplacements;
interface ISpeechPhraseProperty;
interface ISpeechPhraseProperties;
interface ISpeechPhraseRule;
interface ISpeechPhraseRules;
interface ISpeechLexicon;
interface ISpeechLexiconWords;
interface ISpeechLexiconWord;
interface ISpeechLexiconPronunciations;
interface ISpeechLexiconPronunciation;

typedef long SpeechLanguageId;
cpp_quote("#define __SpeechStringConstants_MODULE_DEFINED__")
[uuid (E58442E4-0c80-402c-9559-867337a39765)] module SpeechStringConstants {
  const BSTR SpeechRegistryUserRoot = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech";
  const BSTR SpeechRegistryLocalMachineRoot = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech";
  const BSTR SpeechCategoryAudioOut = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioOutput";
  const BSTR SpeechCategoryAudioIn = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AudioInput";
  const BSTR SpeechCategoryVoices = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Voices";
  const BSTR SpeechCategoryRecognizers = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\Recognizers";
  const BSTR SpeechCategoryAppLexicons = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\AppLexicons";
  const BSTR SpeechCategoryPhoneConverters = L"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Speech\\PhoneConverters";
  const BSTR SpeechCategoryRecoProfiles = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\RecoProfiles";
  const BSTR SpeechTokenIdUserLexicon = L"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Speech\\CurrentUserLexicon";
  const BSTR SpeechTokenValueCLSID = L"CLSID";
  const BSTR SpeechTokenKeyFiles = L"Files";
  const BSTR SpeechTokenKeyUI = L"UI";
  const BSTR SpeechTokenKeyAttributes = L"Attributes";
  const BSTR SpeechVoiceCategoryTTSRate = L"DefaultTTSRate";
  const BSTR SpeechPropertyResourceUsage = L"ResourceUsage";
  const BSTR SpeechPropertyHighConfidenceThreshold = L"HighConfidenceThreshold";
  const BSTR SpeechPropertyNormalConfidenceThreshold = L"NormalConfidenceThreshold";
  const BSTR SpeechPropertyLowConfidenceThreshold = L"LowConfidenceThreshold";
  const BSTR SpeechPropertyResponseSpeed = L"ResponseSpeed";
  const BSTR SpeechPropertyComplexResponseSpeed = L"ComplexResponseSpeed";
  const BSTR SpeechPropertyAdaptationOn = L"AdaptationOn";
  const BSTR SpeechDictationTopicSpelling = L"Spelling";
  const BSTR SpeechGrammarTagWildcard = L"...";
  const BSTR SpeechGrammarTagDictation = L"*";
  const BSTR SpeechGrammarTagUnlimitedDictation = L"*+";
  const BSTR SpeechEngineProperties = L"EngineProperties";
  const BSTR SpeechAddRemoveWord = L"AddRemoveWord";
  const BSTR SpeechUserTraining = L"UserTraining";
  const BSTR SpeechMicTraining = L"MicTraining";
  const BSTR SpeechRecoProfileProperties = L"RecoProfileProperties";
  const BSTR SpeechAudioProperties = L"AudioProperties";
  const BSTR SpeechAudioVolume = L"AudioVolume";
  const BSTR SpeechVoiceSkipTypeSentence = L"Sentence";
  const BSTR SpeechAudioFormatGUIDWave = L"{C31ADBAE-527F-4ff5-A230-F62BB61FF70C}";
  const BSTR SpeechAudioFormatGUIDText = L"{7CEEF9F9-3D13-11d2-9EE7-00C04F797396}";
};
[uuid (F3E092B2-6bdc-410f-BCB2-4c5ed4424180)] module SpeechConstants {
  const float Speech_Default_Weight = DEFAULT_WEIGHT;
  const LONG Speech_Max_Word_Length = SP_MAX_WORD_LENGTH;
  const LONG Speech_Max_Pron_Length = SP_MAX_PRON_LENGTH;
  const LONG Speech_StreamPos_Asap = SP_STREAMPOS_ASAP;
  const LONG Speech_StreamPos_RealTime = SP_STREAMPOS_REALTIME;
  const LONG SpeechAllElements = SPPR_ALL_ELEMENTS;
};

typedef [hidden] 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
} DISPID_SpeechDataKey;

typedef [hidden] 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
} DISPID_SpeechObjectToken;

typedef enum SpeechDataKeyLocation {
  SDKLDefaultLocation = SPDKL_DefaultLocation,
  SDKLCurrentUser = SPDKL_CurrentUser,
  SDKLLocalMachine = SPDKL_LocalMachine,
  SDKLCurrentConfig = SPDKL_CurrentConfig
} SpeechDataKeyLocation;

#define CLSCTXALL (CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER)

typedef enum SpeechTokenContext {
  STCInprocServer = CLSCTX_INPROC_SERVER,
  STCInprocHandler = CLSCTX_INPROC_HANDLER,
  STCLocalServer = CLSCTX_LOCAL_SERVER,
  STCRemoteServer = CLSCTX_REMOTE_SERVER,
  STCAll = CLSCTXALL
} SpeechTokenContext;

typedef enum SpeechTokenShellFolder {
  STSF_AppData = 0x001a,
  STSF_LocalAppData = 0x001c,
  STSF_CommonAppData = 0x0023,
  STSF_FlagCreate = 0x8000
} SpeechTokenShellFolder;

typedef [hidden] enum DISPID_SpeechObjectTokens {
  DISPID_SOTsCount = 1,
  DISPID_SOTsItem = DISPID_VALUE,
  DISPID_SOTs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechObjectTokens;

typedef [hidden] enum DISPID_SpeechObjectTokenCategory {
  DISPID_SOTCId = 1,
  DISPID_SOTCDefault,
  DISPID_SOTCSetId,
  DISPID_SOTCGetDataKey,
  DISPID_SOTCEnumerateTokens,
} DISPID_SpeechObjectTokenCategory;

[object, uuid (CE17C09B-4efa-44d5-A4C9-59d9585ab0cd), dual, pointer_default (unique)]
interface ISpeechDataKey : IDispatch {
  [id (DISPID_SDKSetBinaryValue)] HRESULT SetBinaryValue ([in]const BSTR ValueName,[in]VARIANT Value);
  [id (DISPID_SDKGetBinaryValue)] HRESULT GetBinaryValue ([in]const BSTR ValueName,[out, retval]VARIANT *Value);
  [id (DISPID_SDKSetStringValue)] HRESULT SetStringValue ([in]const BSTR ValueName,[in]const BSTR Value);
  [id (DISPID_SDKGetStringValue)] HRESULT GetStringValue ([in]const BSTR ValueName,[out, retval]BSTR *Value);
  [id (DISPID_SDKSetLongValue)] HRESULT SetLongValue ([in]const BSTR ValueName,[in]long Value);
  [id (DISPID_SDKGetlongValue)] HRESULT GetLongValue ([in]const BSTR ValueName,[out, retval]long *Value);
  [id (DISPID_SDKOpenKey)] HRESULT OpenKey ([in]const BSTR SubKeyName,[out, retval]ISpeechDataKey **SubKey);
  [id (DISPID_SDKCreateKey)] HRESULT CreateKey ([in]const BSTR SubKeyName,[out, retval]ISpeechDataKey **SubKey);
  [id (DISPID_SDKDeleteKey)] HRESULT DeleteKey ([in]const BSTR SubKeyName);
  [id (DISPID_SDKDeleteValue)] HRESULT DeleteValue ([in]const BSTR ValueName);
  [id (DISPID_SDKEnumKeys)] HRESULT EnumKeys ([in]long Index,[out, retval]BSTR *SubKeyName);
  [id (DISPID_SDKEnumValues)] HRESULT EnumValues ([in]long Index,[out, retval]BSTR *ValueName);
};

[object, uuid (C74A3ADC-B727-4500-A84A-B526721C8B8C), dual, pointer_default (unique)]
interface ISpeechObjectToken : IDispatch {
  [propget, id (DISPID_SOTId)] HRESULT Id ([out, retval]BSTR *ObjectId);
  [propget, id (DISPID_SOTDataKey), hidden] HRESULT DataKey ([out, retval]ISpeechDataKey **DataKey);
  [propget, id (DISPID_SOTCategory)] HRESULT Category ([out, retval]ISpeechObjectTokenCategory **Category);
  [id (DISPID_SOTGetDescription)] HRESULT GetDescription ([in, defaultvalue (0)]long Locale,[out, retval]BSTR *Description);
  [hidden, id (DISPID_SOTSetId)] HRESULT SetId ([in] BSTR Id,[in, defaultvalue ("")] BSTR CategoryID,[in, defaultvalue (0)]VARIANT_BOOL CreateIfNotExist);
  [id (DISPID_SOTGetAttribute)] HRESULT GetAttribute ([in] BSTR AttributeName,[out, retval]BSTR *AttributeValue);
  [id (DISPID_SOTCreateInstance)] HRESULT CreateInstance ([in, defaultvalue (NULL)] IUnknown *pUnkOuter,[in, defaultvalue (STCAll)] SpeechTokenContext ClsContext,[out, retval]IUnknown **Object);
  [hidden, id (DISPID_SOTRemove)] HRESULT Remove ([in]BSTR ObjectStorageCLSID);
  [hidden, id (DISPID_SOTGetStorageFileName)] HRESULT GetStorageFileName ([in]BSTR ObjectStorageCLSID,[in]BSTR KeyName,[in]BSTR FileName,[in]SpeechTokenShellFolder Folder,[out, retval]BSTR *FilePath);
  [hidden, id (DISPID_SOTRemoveStorageFileName)] HRESULT RemoveStorageFileName ([in]BSTR ObjectStorageCLSID,[in]BSTR KeyName,[in]VARIANT_BOOL DeleteFile);
  [hidden, id (DISPID_SOTIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[in, defaultvalue (NULL)]IUnknown *Object,[out, retval] VARIANT_BOOL *Supported);
  [hidden, id (DISPID_SOTDisplayUI)] HRESULT DisplayUI ([in]long hWnd,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[in, defaultvalue (NULL)]IUnknown *Object);
  [id (DISPID_SOTMatchesAttributes)] HRESULT MatchesAttributes ([in]BSTR Attributes,[out, retval] VARIANT_BOOL *Matches);
};

[object, uuid (9285b776-2e7b-4bc0-B53E-580eb6fa967f), dual, pointer_default (unique)]
interface ISpeechObjectTokens : IDispatch {
  [propget, id (DISPID_SOTsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechObjectToken **Token);
  [propget, restricted, id (DISPID_NEWENUM)] HRESULT _NewEnum ([out, retval] IUnknown **ppEnumVARIANT);
};

[object, uuid (CA7EAC50-2d01-4145-86d4-5ae7d70f4469), dual, pointer_default (unique)]
interface ISpeechObjectTokenCategory : IDispatch {
  [propget, id (DISPID_SOTCId)] HRESULT Id ([out, retval] BSTR *Id);
  [propput, id (DISPID_SOTCDefault)] HRESULT Default ([in] const BSTR TokenId);
  [propget, id (DISPID_SOTCDefault)] HRESULT Default ([out, retval] BSTR *TokenId);
  [id (DISPID_SOTCSetId)] HRESULT SetId ([in] const BSTR Id,[in, defaultvalue (0)]VARIANT_BOOL CreateIfNotExist);
  [hidden, id (DISPID_SOTCGetDataKey)] HRESULT GetDataKey ([in, defaultvalue (SDKLDefaultLocation)]SpeechDataKeyLocation Location,[out, retval]ISpeechDataKey **DataKey);
  [id (DISPID_SOTCEnumerateTokens)] HRESULT EnumerateTokens ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **Tokens);
};

typedef enum SpeechAudioFormatType {
  SAFTDefault = -1,
  SAFTNoAssignedFormat = 0,
  SAFTText,
  SAFTNonStandardFormat,
  SAFTExtendedAudioFormat,
  SAFT8kHz8BitMono,
  SAFT8kHz8BitStereo,
  SAFT8kHz16BitMono,
  SAFT8kHz16BitStereo,
  SAFT11kHz8BitMono,
  SAFT11kHz8BitStereo,
  SAFT11kHz16BitMono,
  SAFT11kHz16BitStereo,
  SAFT12kHz8BitMono,
  SAFT12kHz8BitStereo,
  SAFT12kHz16BitMono,
  SAFT12kHz16BitStereo,
  SAFT16kHz8BitMono,
  SAFT16kHz8BitStereo,
  SAFT16kHz16BitMono,
  SAFT16kHz16BitStereo,
  SAFT22kHz8BitMono,
  SAFT22kHz8BitStereo,
  SAFT22kHz16BitMono,
  SAFT22kHz16BitStereo,
  SAFT24kHz8BitMono,
  SAFT24kHz8BitStereo,
  SAFT24kHz16BitMono,
  SAFT24kHz16BitStereo,
  SAFT32kHz8BitMono,
  SAFT32kHz8BitStereo,
  SAFT32kHz16BitMono,
  SAFT32kHz16BitStereo,
  SAFT44kHz8BitMono,
  SAFT44kHz8BitStereo,
  SAFT44kHz16BitMono,
  SAFT44kHz16BitStereo,
  SAFT48kHz8BitMono,
  SAFT48kHz8BitStereo,
  SAFT48kHz16BitMono,
  SAFT48kHz16BitStereo,
  SAFTTrueSpeech_8kHz1BitMono,
  SAFTCCITT_ALaw_8kHzMono,
  SAFTCCITT_ALaw_8kHzStereo,
  SAFTCCITT_ALaw_11kHzMono,
  SAFTCCITT_ALaw_11kHzStereo,
  SAFTCCITT_ALaw_22kHzMono,
  SAFTCCITT_ALaw_22kHzStereo,
  SAFTCCITT_ALaw_44kHzMono,
  SAFTCCITT_ALaw_44kHzStereo,

  SAFTCCITT_uLaw_8kHzMono,
  SAFTCCITT_uLaw_8kHzStereo,
  SAFTCCITT_uLaw_11kHzMono,
  SAFTCCITT_uLaw_11kHzStereo,
  SAFTCCITT_uLaw_22kHzMono,
  SAFTCCITT_uLaw_22kHzStereo,
  SAFTCCITT_uLaw_44kHzMono,
  SAFTCCITT_uLaw_44kHzStereo,

  SAFTADPCM_8kHzMono,
  SAFTADPCM_8kHzStereo,
  SAFTADPCM_11kHzMono,
  SAFTADPCM_11kHzStereo,
  SAFTADPCM_22kHzMono,
  SAFTADPCM_22kHzStereo,
  SAFTADPCM_44kHzMono,
  SAFTADPCM_44kHzStereo,
  SAFTGSM610_8kHzMono,
  SAFTGSM610_11kHzMono,
  SAFTGSM610_22kHzMono,
  SAFTGSM610_44kHzMono,
} SpeechAudioFormatType;

typedef [hidden] enum DISPID_SpeechAudioFormat {
  DISPID_SAFType = 1,
  DISPID_SAFGuid,
  DISPID_SAFGetWaveFormatEx,
  DISPID_SAFSetWaveFormatEx
} DISPID_SpeechAudioFormat;

typedef [hidden] enum DISPID_SpeechBaseStream {
  DISPID_SBSFormat = 1,
  DISPID_SBSRead,
  DISPID_SBSWrite,
  DISPID_SBSSeek
} DISPID_SpeechBaseStream;

typedef enum SpeechStreamSeekPositionType {
  SSSPTRelativeToStart = STREAM_SEEK_SET,
  SSSPTRelativeToCurrentPosition = STREAM_SEEK_CUR,
  SSSPTRelativeToEnd = STREAM_SEEK_END
} SpeechStreamSeekPositionType;

typedef [hidden] enum DISPID_SpeechAudio {
  DISPID_SAStatus = 200,
  DISPID_SABufferInfo,
  DISPID_SADefaultFormat,
  DISPID_SAVolume,
  DISPID_SABufferNotifySize,
  DISPID_SAEventHandle,
  DISPID_SASetState
} DISPID_SpeechAudio;

typedef enum SpeechAudioState {
  SASClosed = SPAS_CLOSED,
  SASStop = SPAS_STOP,
  SASPause = SPAS_PAUSE,
  SASRun = SPAS_RUN
} SpeechAudioState;

typedef [hidden] enum DISPID_SpeechMMSysAudio {
  DISPID_SMSADeviceId = 300,
  DISPID_SMSALineId,
  DISPID_SMSAMMHandle
} DISPID_SpeechMMSysAudio;

typedef [hidden] enum DISPID_SpeechFileStream {
  DISPID_SFSOpen = 100,
  DISPID_SFSClose
} DISPID_SpeechFileStream;

typedef enum SpeechStreamFileMode {
  SSFMOpenForRead = SPFM_OPEN_READONLY,
  SSFMOpenReadWrite = SPFM_OPEN_READWRITE,
  SSFMCreate = SPFM_CREATE,
  SSFMCreateForWrite = SPFM_CREATE_ALWAYS,
} SpeechStreamFileMode;

typedef [hidden] enum DISPID_SpeechCustomStream {
  DISPID_SCSBaseStream = 100
} DISPID_SpeechCustomStream;

typedef [hidden] enum DISPID_SpeechMemoryStream {
  DISPID_SMSSetData = 100,
  DISPID_SMSGetData
} DISPID_SpeechMemoryStream;

typedef [hidden] enum DISPID_SpeechAudioStatus {
  DISPID_SASFreeBufferSpace = 1,
  DISPID_SASNonBlockingIO,
  DISPID_SASState,
  DISPID_SASCurrentSeekPosition,
  DISPID_SASCurrentDevicePosition
} DISPID_SpeechAudioStatus;

typedef [hidden] enum DISPID_SpeechAudioBufferInfo {
  DISPID_SABIMinNotification = 1,
  DISPID_SABIBufferSize,
  DISPID_SABIEventBias
} DISPID_SpeechAudioBufferInfo;

typedef [hidden] enum DISPID_SpeechWaveFormatEx {
  DISPID_SWFEFormatTag = 1,
  DISPID_SWFEChannels,
  DISPID_SWFESamplesPerSec,
  DISPID_SWFEAvgBytesPerSec,
  DISPID_SWFEBlockAlign,
  DISPID_SWFEBitsPerSample,
  DISPID_SWFEExtraData
} DISPID_SpeechWaveFormatEx;

typedef [hidden] 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
} DISPID_SpeechVoice;

typedef enum SpeechVoicePriority {
  SVPNormal = SPVPRI_NORMAL,
  SVPAlert = SPVPRI_ALERT,
  SVPOver = SPVPRI_OVER
} SpeechVoicePriority;

typedef 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,
#if _SAPI_BLD_ >= 0x53
  SVSFParseSapi = SPF_PARSE_SAPI,
  SVSFParseSsml = SPF_PARSE_SSML,
  SVSFParseAutodetect = SPF_PARSE_AUTODETECT,
#endif
  SVSFNLPMask = SPF_NLP_MASK,
#if _SAPI_BLD_ >= 0x53
  SVSFParseMask = SPF_PARSE_MASK,
#endif
  SVSFVoiceMask = SPF_VOICE_MASK,
  SVSFUnusedFlags = SPF_UNUSED_FLAGS,
} SpeechVoiceSpeakFlags;

typedef enum SpeechVoiceEvents {
  SVEStartInputStream = 0x2,
  SVEEndInputStream = 0x4,
  SVEVoiceChange = 0x8,
  SVEBookmark = 0x10,
  SVEWordBoundary = 0x20,
  SVEPhoneme = 0x40,
  SVESentenceBoundary = 0x80,
  SVEViseme = 0x100,
  SVEAudioLevel = 0x200,
  SVEPrivate = 0x8000,
  SVEAllEvents = 0x83fe
} SpeechVoiceEvents;

typedef [hidden] 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
} DISPID_SpeechVoiceStatus;

typedef enum SpeechRunState {
  SRSEDone = SPRS_DONE,
  SRSEIsSpeaking = SPRS_IS_SPEAKING
} SpeechRunState;

[object, uuid (E6E9C590-3e18-40e3-8299-061f98bde7c7), dual, pointer_default (unique)]
interface ISpeechAudioFormat : IDispatch {
  [propget, id (DISPID_SAFType)] HRESULT Type ([out, retval]SpeechAudioFormatType *AudioFormat);
  [propput, id (DISPID_SAFType)] HRESULT Type ([in]SpeechAudioFormatType AudioFormat);
  [propget, hidden, id (DISPID_SAFGuid)] HRESULT Guid ([out, retval]BSTR *Guid);
  [propput, hidden, id (DISPID_SAFGuid)] HRESULT Guid ([in]BSTR Guid);
  [hidden, id (DISPID_SAFGetWaveFormatEx)] HRESULT GetWaveFormatEx ([out, retval]ISpeechWaveFormatEx **SpeechWaveFormatEx);
  [hidden, id (DISPID_SAFSetWaveFormatEx)] HRESULT SetWaveFormatEx ([in]ISpeechWaveFormatEx *SpeechWaveFormatEx);
}

[object, uuid (6450336f-7d49-4ced-8097-49d6dee37294), dual, pointer_default (unique)]
interface ISpeechBaseStream : IDispatch {
  [propget, id (DISPID_SBSFormat)] HRESULT Format ([out, retval]ISpeechAudioFormat **AudioFormat);
  [propputref, id (DISPID_SBSFormat)] HRESULT Format ([in]ISpeechAudioFormat *AudioFormat);
  [id (DISPID_SBSRead)] HRESULT Read ([out]VARIANT *Buffer,[in]long NumberOfBytes,[out, retval]long *BytesRead);
  [id (DISPID_SBSWrite)] HRESULT Write ([in]VARIANT Buffer,[out, retval]long *BytesWritten);
  [id (DISPID_SBSSeek)] HRESULT Seek ([in]VARIANT Position,[in, defaultvalue (SSSPTRelativeToStart)]SpeechStreamSeekPositionType Origin,[out, retval]VARIANT *NewPosition);
};

[object, uuid (CFF8E175-019e-11d3-A08E-00c04f8ef9b5), dual, pointer_default (unique)]
interface ISpeechAudio : ISpeechBaseStream {
  [propget, id (DISPID_SAStatus)] HRESULT Status ([out, retval]ISpeechAudioStatus **Status);
  [propget, id (DISPID_SABufferInfo)] HRESULT BufferInfo ([out, retval]ISpeechAudioBufferInfo **BufferInfo);
  [propget, id (DISPID_SADefaultFormat)] HRESULT DefaultFormat ([out, retval]ISpeechAudioFormat **StreamFormat);
  [propget, id (DISPID_SAVolume)] HRESULT Volume ([out, retval]long *Volume);
  [propput, id (DISPID_SAVolume)] HRESULT Volume ([in]long Volume);
  [propget, id (DISPID_SABufferNotifySize)] HRESULT BufferNotifySize ([out, retval]long *BufferNotifySize);
  [propput, id (DISPID_SABufferNotifySize)] HRESULT BufferNotifySize ([in]long BufferNotifySize);
  [propget, hidden, id (DISPID_SAEventHandle)] HRESULT EventHandle ([out, retval]long *EventHandle);
  [id (DISPID_SASetState), hidden] HRESULT SetState ([in] SpeechAudioState State);
};

[object, uuid (3c76af6d-1fd7-4831-81d1-3b71d5a13c44), dual, pointer_default (unique)]
interface ISpeechMMSysAudio : ISpeechAudio {
  [propget, id (DISPID_SMSADeviceId)] HRESULT DeviceId ([out, retval] long *DeviceId);
  [propput, id (DISPID_SMSADeviceId)] HRESULT DeviceId ([in] long DeviceId);
  [propget, id (DISPID_SMSALineId)] HRESULT LineId ([out, retval] long *LineId);
  [propput, id (DISPID_SMSALineId)] HRESULT LineId ([in] long LineId);
  [propget, hidden, id (DISPID_SMSAMMHandle)] HRESULT MMHandle ([out, retval] long *Handle);
};

[object, uuid (AF67F125-AB39-4e93-B4A2-CC2E66E182A7), dual, pointer_default (unique)]
interface ISpeechFileStream : ISpeechBaseStream {
  [id (DISPID_SFSOpen)] HRESULT Open ([in] BSTR FileName,[in, defaultvalue (SSFMOpenForRead)] SpeechStreamFileMode FileMode,[in, defaultvalue (0)]VARIANT_BOOL DoEvents);
  [id (DISPID_SFSClose)] HRESULT Close (void);
};

[object, uuid (1a9e9f4f-104f-4db8-A115-EFD7FD0C97AE), dual, pointer_default (unique)]
interface ISpeechCustomStream : ISpeechBaseStream {
  [propget, id (DISPID_SCSBaseStream)] HRESULT BaseStream ([out, retval] IUnknown **ppUnkStream);
  [propputref, id (DISPID_SCSBaseStream)] HRESULT BaseStream ([in] IUnknown *pUnkStream);
};

[object, uuid (EEB14B68-808b-4abe-A5EA-B51DA7588008), dual, pointer_default (unique)]
interface ISpeechMemoryStream : ISpeechBaseStream {
  [id (DISPID_SMSSetData)] HRESULT SetData ([in] VARIANT Data);
  [id (DISPID_SMSGetData)] HRESULT GetData ([out, retval] VARIANT *pData);
};

[object, uuid (C62D9C91-7458-47f6-862d-1ef86fb0b278), dual, pointer_default (unique)]
interface ISpeechAudioStatus : IDispatch {
  [propget, id (DISPID_SASFreeBufferSpace)] HRESULT FreeBufferSpace ([out, retval]long *FreeBufferSpace);
  [propget, id (DISPID_SASNonBlockingIO)] HRESULT NonBlockingIO ([out, retval]long *NonBlockingIO);
  [propget, id (DISPID_SASState)] HRESULT State ([out, retval] SpeechAudioState *State);
  [propget, id (DISPID_SASCurrentSeekPosition)] HRESULT CurrentSeekPosition ([out, retval]VARIANT *CurrentSeekPosition);
  [propget, id (DISPID_SASCurrentDevicePosition)] HRESULT CurrentDevicePosition ([out, retval]VARIANT *CurrentDevicePosition);
};

[object, uuid (11b103d8-1142-4edf-A093-82fb3915f8cc), dual, pointer_default (unique)]
interface ISpeechAudioBufferInfo : IDispatch {
  [propget, id (DISPID_SABIMinNotification)] HRESULT MinNotification ([out, retval]long *MinNotification);
  [propput, id (DISPID_SABIMinNotification)] HRESULT MinNotification ([in]long MinNotification);
  [propget, id (DISPID_SABIBufferSize)] HRESULT BufferSize ([out, retval]long *BufferSize);
  [propput, id (DISPID_SABIBufferSize)] HRESULT BufferSize ([in]long BufferSize);
  [propget, id (DISPID_SABIEventBias)] HRESULT EventBias ([out, retval]long *EventBias);
  [propput, id (DISPID_SABIEventBias)] HRESULT EventBias ([in]long EventBias);
}

[object, uuid (7a1ef0d5-1581-4741-88e4-209a49f11a10), dual, pointer_default (unique)]
interface ISpeechWaveFormatEx : IDispatch {
  [propget, id (DISPID_SWFEFormatTag)] HRESULT FormatTag ([out, retval]short *FormatTag);
  [propput, id (DISPID_SWFEFormatTag)] HRESULT FormatTag ([in]short FormatTag);
  [propget, id (DISPID_SWFEChannels)] HRESULT Channels ([out, retval]short *Channels);
  [propput, id (DISPID_SWFEChannels)] HRESULT Channels ([in]short Channels);
  [propget, id (DISPID_SWFESamplesPerSec)] HRESULT SamplesPerSec ([out, retval]long *SamplesPerSec);
  [propput, id (DISPID_SWFESamplesPerSec)] HRESULT SamplesPerSec ([in]long SamplesPerSec);
  [propget, id (DISPID_SWFEAvgBytesPerSec)] HRESULT AvgBytesPerSec ([out, retval]long *AvgBytesPerSec);
  [propput, id (DISPID_SWFEAvgBytesPerSec)] HRESULT AvgBytesPerSec ([in]long AvgBytesPerSec);
  [propget, id (DISPID_SWFEBlockAlign)] HRESULT BlockAlign ([out, retval]short *BlockAlign);
  [propput, id (DISPID_SWFEBlockAlign)] HRESULT BlockAlign ([in]short BlockAlign);
  [propget, id (DISPID_SWFEBitsPerSample)] HRESULT BitsPerSample ([out, retval]short *BitsPerSample);
  [propput, id (DISPID_SWFEBitsPerSample)] HRESULT BitsPerSample ([in]short BitsPerSample);
  [propget, id (DISPID_SWFEExtraData)] HRESULT ExtraData ([out, retval]VARIANT *ExtraData);
  [propput, id (DISPID_SWFEExtraData)] HRESULT ExtraData ([in]VARIANT ExtraData);
}

[object, uuid (269316d8-57bd-11d2-9eee-00c04f797396), dual, pointer_default (unique)]
interface ISpeechVoice : IDispatch {
  [propget, id (DISPID_SVStatus)] HRESULT Status ([out, retval] ISpeechVoiceStatus **Status);
  [propget, id (DISPID_SVVoice)] HRESULT Voice ([out, retval] ISpeechObjectToken **Voice);
  [propputref, id (DISPID_SVVoice)] HRESULT Voice ([in]ISpeechObjectToken *Voice);
  [propget, id (DISPID_SVAudioOutput)] HRESULT AudioOutput ([out, retval]ISpeechObjectToken **AudioOutput);
  [propputref, id (DISPID_SVAudioOutput)] HRESULT AudioOutput ([in]ISpeechObjectToken *AudioOutput);
  [propget, id (DISPID_SVAudioOutputStream)] HRESULT AudioOutputStream ([out, retval]ISpeechBaseStream **AudioOutputStream);
  [propputref, id (DISPID_SVAudioOutputStream)] HRESULT AudioOutputStream ([in]ISpeechBaseStream *AudioOutputStream);
  [propget, id (DISPID_SVRate)] HRESULT Rate ([out, retval] long *Rate);
  [propput, id (DISPID_SVRate)] HRESULT Rate ([in] long Rate);
  [propget, id (DISPID_SVVolume)] HRESULT Volume ([out, retval] long *Volume);
  [propput, id (DISPID_SVVolume)] HRESULT Volume ([in] long Volume);
  [propput, hidden, id (DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] HRESULT AllowAudioOutputFormatChangesOnNextSet ([in] VARIANT_BOOL Allow);
  [propget, hidden, id (DISPID_SVAllowAudioOuputFormatChangesOnNextSet)] HRESULT AllowAudioOutputFormatChangesOnNextSet ([out, retval] VARIANT_BOOL *Allow);
  [propget, id (DISPID_SVEventInterests)] HRESULT EventInterests ([out, retval] SpeechVoiceEvents *EventInterestFlags);
  [propput, id (DISPID_SVEventInterests)] HRESULT EventInterests ([in] SpeechVoiceEvents EventInterestFlags);
  [propput, id (DISPID_SVPriority)] HRESULT Priority ([in] SpeechVoicePriority Priority);
  [propget, id (DISPID_SVPriority)] HRESULT Priority ([out, retval] SpeechVoicePriority *Priority);
  [propput, id (DISPID_SVAlertBoundary)] HRESULT AlertBoundary ([in] SpeechVoiceEvents Boundary);
  [propget, id (DISPID_SVAlertBoundary)] HRESULT AlertBoundary ([out, retval] SpeechVoiceEvents *Boundary);
  [propput, id (DISPID_SVSyncronousSpeakTimeout)] HRESULT SynchronousSpeakTimeout ([in] long msTimeout);
  [propget, id (DISPID_SVSyncronousSpeakTimeout)] HRESULT SynchronousSpeakTimeout ([out, retval] long *msTimeout);
  [id (DISPID_SVSpeak)] HRESULT Speak ([in] BSTR Text,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber);
  [id (DISPID_SVSpeakStream)] HRESULT SpeakStream ([in] ISpeechBaseStream *Stream,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber);
  [id (DISPID_SVPause)] HRESULT Pause (void);
  [id (DISPID_SVResume)] HRESULT Resume (void);
  [id (DISPID_SVSkip)] HRESULT Skip ([in]const BSTR Type,[in]long NumItems,[out, retval]long *NumSkipped);
  [id (DISPID_SVGetVoices)] HRESULT GetVoices ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens);
  [id (DISPID_SVGetAudioOutputs)] HRESULT GetAudioOutputs ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens);
  [id (DISPID_SVWaitUntilDone)] HRESULT WaitUntilDone ([in]long msTimeout,[out, retval]VARIANT_BOOL *Done);
  [hidden, id (DISPID_SVSpeakCompleteEvent)] HRESULT SpeakCompleteEvent ([out, retval]long *Handle);
  [id (DISPID_SVIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[out, retval] VARIANT_BOOL *Supported);
  [id (DISPID_SVDisplayUI)] HRESULT DisplayUI ([in]long hWndParent,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData);
};

[object, uuid (8be47b07-57f6-11d2-9eee-00c04f797396), dual, pointer_default (unique)]
interface ISpeechVoiceStatus : IDispatch {
  [propget, id (DISPID_SVSCurrentStreamNumber)] HRESULT CurrentStreamNumber ([out, retval] long *StreamNumber);
  [propget, id (DISPID_SVSLastStreamNumberQueued)] HRESULT LastStreamNumberQueued ([out, retval] long *StreamNumber);
  [propget, id (DISPID_SVSLastResult)] HRESULT LastHResult ([out, retval]long *HResult);
  [propget, id (DISPID_SVSRunningState)] HRESULT RunningState ([out, retval] SpeechRunState *State);
  [propget, id (DISPID_SVSInputWordPosition)] HRESULT InputWordPosition ([out, retval] long *Position);
  [propget, id (DISPID_SVSInputWordLength)] HRESULT InputWordLength ([out, retval] long *Length);
  [propget, id (DISPID_SVSInputSentencePosition)] HRESULT InputSentencePosition ([out, retval] long *Position);
  [propget, id (DISPID_SVSInputSentenceLength)] HRESULT InputSentenceLength ([out, retval] long *Length);
  [propget, id (DISPID_SVSLastBookmark)] HRESULT LastBookmark ([out, retval] BSTR *Bookmark);
  [propget, id (DISPID_SVSLastBookmarkId), hidden] HRESULT LastBookmarkId ([out, retval] long *BookmarkId);
  [propget, id (DISPID_SVSPhonemeId)] HRESULT PhonemeId ([out, retval] short *PhoneId);
  [propget, id (DISPID_SVSVisemeId)] HRESULT VisemeId ([out, retval] short *VisemeId);
};

typedef 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,
} SpeechVisemeType;

typedef enum SpeechVisemeFeature {
  SVF_None = 0,
  SVF_Stressed = SPVFEATURE_STRESSED,
  SVF_Emphasis = SPVFEATURE_EMPHASIS
} SpeechVisemeFeature;

typedef [hidden] enum DISPID_SpeechVoiceEvent {
  DISPID_SVEStreamStart = 1,
  DISPID_SVEStreamEnd,
  DISPID_SVEVoiceChange,
  DISPID_SVEBookmark,
  DISPID_SVEWord,
  DISPID_SVEPhoneme,
  DISPID_SVESentenceBoundary,
  DISPID_SVEViseme,
  DISPID_SVEAudioLevel,
  DISPID_SVEEnginePrivate
} DISPID_SpeechVoiceEvent;

typedef [hidden] 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
} DISPID_SpeechRecognizer;

typedef enum SpeechRecognizerState {
  SRSInactive = SPRST_INACTIVE,
  SRSActive = SPRST_ACTIVE,
  SRSActiveAlways = SPRST_ACTIVE_ALWAYS,
  SRSInactiveWithPurge = SPRST_INACTIVE_WITH_PURGE,
} SpeechRecognizerState;

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

typedef enum SpeechFormatType {
  SFTInput = SPWF_INPUT,
  SFTSREngine = SPWF_SRENGINE
} SpeechFormatType;

typedef [hidden] enum DISPID_SpeechRecognizerStatus {
  DISPID_SRSAudioStatus = 1,
  DISPID_SRSCurrentStreamPosition,
  DISPID_SRSCurrentStreamNumber,
  DISPID_SRSNumberOfActiveRules,
  DISPID_SRSClsidEngine,
  DISPID_SRSSupportedLanguages
} DISPID_SpeechRecognizerStatus;

typedef [hidden] 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
} DISPID_SpeechRecoContext;

typedef enum SpeechRetainedAudioOptions {
  SRAONone = SPAO_NONE,
  SRAORetainAudio = SPAO_RETAIN_AUDIO
} SpeechRetainedAudioOptions;

typedef enum SpeechBookmarkOptions {
  SBONone = SPBO_NONE,
  SBOPause = SPBO_PAUSE
} SpeechBookmarkOptions;

typedef enum SpeechInterference {
  SINone = SPINTERFERENCE_NONE,
  SINoise = SPINTERFERENCE_NOISE,
  SINoSignal = SPINTERFERENCE_NOSIGNAL,
  SITooLoud = SPINTERFERENCE_TOOLOUD,
  SITooQuiet = SPINTERFERENCE_TOOQUIET,
  SITooFast = SPINTERFERENCE_TOOFAST,
  SITooSlow = SPINTERFERENCE_TOOSLOW
} SpeechInterference;

typedef enum SpeechRecoEvents {
  SREStreamEnd = 0x1,
  SRESoundStart = 0x2,
  SRESoundEnd = 0x4,
  SREPhraseStart = 0x8,
  SRERecognition = 0x10,
  SREHypothesis = 0x20,
  SREBookmark = 0x40,
  SREPropertyNumChange = 0x80,
  SREPropertyStringChange = 0x100,
  SREFalseRecognition = 0x200,
  SREInterference = 0x400,
  SRERequestUI = 0x800,
  SREStateChange = 0x1000,
  SREAdaptation = 0x2000,
  SREStreamStart = 0x4000,
  SRERecoOtherContext = 0x8000,
  SREAudioLevel = 0x10000,
  SREPrivate = 0x40000,
  SREAllEvents = 0x5ffff
} SpeechRecoEvents;

typedef enum SpeechRecoContextState {
  SRCS_Disabled = SPCS_DISABLED,
  SRCS_Enabled = SPCS_ENABLED
} SpeechRecoContextState;

typedef [hidden] 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
} DISPIDSPRG;

typedef enum SpeechLoadOption {
  SLOStatic = SPLO_STATIC,
  SLODynamic = SPLO_DYNAMIC
} SpeechLoadOption;

typedef enum SpeechWordPronounceable {
  SWPUnknownWordUnpronounceable = SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE,
  SWPUnknownWordPronounceable = SPWP_UNKNOWN_WORD_PRONOUNCEABLE,
  SWPKnownWordPronounceable = SPWP_KNOWN_WORD_PRONOUNCEABLE
} SpeechWordPronounceable;

typedef enum SpeechGrammarState {
  SGSEnabled = SPGS_ENABLED,
  SGSDisabled = SPGS_DISABLED,
  SGSExclusive = SPGS_EXCLUSIVE,
} SpeechGrammarState;

typedef enum SpeechRuleState {
  SGDSInactive = SPRS_INACTIVE,
  SGDSActive = SPRS_ACTIVE,
  SGDSActiveWithAutoPause = SPRS_ACTIVE_WITH_AUTO_PAUSE,
#if _SAPI_BLD_ >= 0x053
  SGDSActiveUserDelimited = SPRS_ACTIVE_USER_DELIMITED
#endif
} SpeechRuleState;

typedef enum SpeechRuleAttributes {
  SRATopLevel = SPRAF_TopLevel,
  SRADefaultToActive = SPRAF_Active,
  SRAExport = SPRAF_Export,
  SRAImport = SPRAF_Import,
  SRAInterpreter = SPRAF_Interpreter,
  SRADynamic = SPRAF_Dynamic,
#if _SAPI_BLD_ >= 0x053
  SRARoot = SPRAF_Root
#endif
} SpeechRuleAttributes;

typedef enum SpeechGrammarWordType {
  SGDisplay = SPWT_DISPLAY,
  SGLexical = SPWT_LEXICAL,
  SGPronounciation = SPWT_PRONUNCIATION,
#if _SAPI_BLD_ >= 0x053
  SGLexicalNoSpecialChars = SPWT_LEXICAL_NO_SPECIAL_CHARS
#endif
} SpeechGrammarWordType;

typedef [hidden] 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
} DISPID_SpeechRecoContextEvents;

typedef enum SpeechRecognitionType {
  SRTStandard = 0,
  SRTAutopause = SPREF_AutoPause,
  SRTEmulated = SPREF_Emulated
#if _SAPI_BLD_ >= 0x053
  ,
  SRTSMLTimeout = SPREF_SMLTimeout,
  SRTExtendableParse = SPREF_ExtendableParse,
  SRTReSent = SPREF_ReSent
#endif
} SpeechRecognitionType;

typedef [hidden] enum DISPID_SpeechGrammarRule {
  DISPID_SGRAttributes = 1,
  DISPID_SGRInitialState,
  DISPID_SGRName,
  DISPID_SGRId,
  DISPID_SGRClear,
  DISPID_SGRAddResource,
  DISPID_SGRAddState
} DISPID_SpeechGrammarRule;

typedef [hidden] enum DISPID_SpeechGrammarRules {
  DISPID_SGRsCount = 1,
  DISPID_SGRsDynamic,
  DISPID_SGRsAdd,
  DISPID_SGRsCommit,
  DISPID_SGRsCommitAndSave,
  DISPID_SGRsFindRule,
  DISPID_SGRsItem = DISPID_VALUE,
  DISPID_SGRs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechGrammarRules;

typedef [hidden] enum DISPID_SpeechGrammarRuleState {
  DISPID_SGRSRule = 1,
  DISPID_SGRSTransitions,
  DISPID_SGRSAddWordTransition,
  DISPID_SGRSAddRuleTransition,
  DISPID_SGRSAddSpecialTransition
} DISPID_SpeechGrammarRuleState;

typedef enum SpeechSpecialTransitionType {
  SSTTWildcard = 1,
  SSTTDictation,
  SSTTTextBuffer
} SpeechSpecialTransitionType;

typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransitions {
  DISPID_SGRSTsCount = 1,
  DISPID_SGRSTsItem = DISPID_VALUE,
  DISPID_SGRSTs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechGrammarRuleStateTransitions;

typedef [hidden] enum DISPID_SpeechGrammarRuleStateTransition {
  DISPID_SGRSTType = 1,
  DISPID_SGRSTText,
  DISPID_SGRSTRule,
  DISPID_SGRSTWeight,
  DISPID_SGRSTPropertyName,
  DISPID_SGRSTPropertyId,
  DISPID_SGRSTPropertyValue,
  DISPID_SGRSTNextState
} DISPID_SpeechGrammarRuleStateTransition;

typedef enum SpeechGrammarRuleStateTransitionType {
  SGRSTTEpsilon = 0,
  SGRSTTWord,
  SGRSTTRule,
  SGRSTTDictation,
  SGRSTTWildcard,
  SGRSTTTextBuffer
} SpeechGrammarRuleStateTransitionType;

typedef [hidden] enum DISPIDSPTSI {
  DISPIDSPTSI_ActiveOffset = 1,
  DISPIDSPTSI_ActiveLength,
  DISPIDSPTSI_SelectionOffset,
  DISPIDSPTSI_SelectionLength
} DISPIDSPTSI;

typedef [hidden] enum DISPID_SpeechRecoResult {
  DISPID_SRRRecoContext = 1,
  DISPID_SRRTimes,
  DISPID_SRRAudioFormat,
  DISPID_SRRPhraseInfo,
  DISPID_SRRAlternates,
  DISPID_SRRAudio,
  DISPID_SRRSpeakAudio,
  DISPID_SRRSaveToMemory,
  DISPID_SRRDiscardResultInfo
} DISPID_SpeechRecoResult;

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

#if _SAPI_BLD_ >= 0x53
typedef enum SpeechEmulationCompareFlags {
  SECFIgnoreCase = 0x1,
  SECFIgnoreKanaType = 0x10000,
  SECFIgnoreWidth = 0x20000,
  SECFNoSpecialChars = 0x20000000,
  SECFEmulateResult = 0x40000000,
  SECFDefault = SECFIgnoreCase | SECFIgnoreKanaType | SECFIgnoreWidth
} SpeechEmulationCompareFlags;

typedef [hidden] enum DISPID_SpeechXMLRecoResult {
  DISPID_SRRGetXMLResult = DISPID_SRRDiscardResultInfo + 1,
  DISPID_SRRGetXMLErrorInfo = DISPID_SRRGetXMLResult + 1
} DISPID_SpeechXMLRecoResult;

typedef [hidden] enum DISPID_SpeechRecoResult2 {
  DISPID_SRRSetTextFeedback = DISPID_SRRGetXMLErrorInfo + 1
} DISPID_SpeechRecoResult2;
#endif

typedef [hidden] enum DISPID_SpeechPhraseBuilder {
  DISPID_SPPBRestorePhraseFromMemory = 1
} DISPID_SpeechPhraseBuilder;

typedef [hidden] enum DISPID_SpeechRecoResultTimes {
  DISPID_SRRTStreamTime = 1,
  DISPID_SRRTLength,
  DISPID_SRRTTickCount,
  DISPID_SRRTOffsetFromStart
} DISPID_SpeechRecoResultTimes;

typedef [hidden] enum DISPID_SpeechPhraseAlternate {
  DISPID_SPARecoResult = 1,
  DISPID_SPAStartElementInResult,
  DISPID_SPANumberOfElementsInResult,
  DISPID_SPAPhraseInfo,
  DISPID_SPACommit
} DISPID_SpeechPhraseAlternate;

typedef [hidden] enum DISPID_SpeechPhraseAlternates {
  DISPID_SPAsCount = 1,
  DISPID_SPAsItem = DISPID_VALUE,
  DISPID_SPAs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechPhraseAlternates;

typedef [hidden] 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
} DISPID_SpeechPhraseInfo;

typedef [hidden] 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
} DISPID_SpeechPhraseElement;

typedef enum SpeechEngineConfidence {
  SECLowConfidence = -1,
  SECNormalConfidence = 0,
  SECHighConfidence = 1
} SpeechEngineConfidence;

typedef [hidden] enum DISPID_SpeechPhraseElements {
  DISPID_SPEsCount = 1,
  DISPID_SPEsItem = DISPID_VALUE,
  DISPID_SPEs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechPhraseElements;

typedef [hidden] enum DISPID_SpeechPhraseReplacement {
  DISPID_SPRDisplayAttributes = 1,
  DISPID_SPRText,
  DISPID_SPRFirstElement,
  DISPID_SPRNumberOfElements
} DISPID_SpeechPhraseReplacement;

typedef [hidden] enum DISPID_SpeechPhraseReplacements {
  DISPID_SPRsCount = 1,
  DISPID_SPRsItem = DISPID_VALUE,
  DISPID_SPRs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechPhraseReplacements;

typedef [hidden] enum DISPID_SpeechPhraseProperty {
  DISPID_SPPName = 1,
  DISPID_SPPId,
  DISPID_SPPValue,
  DISPID_SPPFirstElement,
  DISPID_SPPNumberOfElements,
  DISPID_SPPEngineConfidence,
  DISPID_SPPConfidence,
  DISPID_SPPParent,
  DISPID_SPPChildren
} DISPID_SpeechPhraseProperty;

typedef [hidden] enum DISPID_SpeechPhraseProperties {
  DISPID_SPPsCount = 1,
  DISPID_SPPsItem = DISPID_VALUE,
  DISPID_SPPs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechPhraseProperties;

typedef [hidden] enum DISPID_SpeechPhraseRule {
  DISPID_SPRuleName = 1,
  DISPID_SPRuleId,
  DISPID_SPRuleFirstElement,
  DISPID_SPRuleNumberOfElements,
  DISPID_SPRuleParent,
  DISPID_SPRuleChildren,
  DISPID_SPRuleConfidence,
  DISPID_SPRuleEngineConfidence
} DISPID_SpeechPhraseRule;

typedef [hidden] enum DISPID_SpeechPhraseRules {
  DISPID_SPRulesCount = 1,
  DISPID_SPRulesItem = DISPID_VALUE,
  DISPID_SPRules_NewEnum = DISPID_NEWENUM
} DISPID_SpeechPhraseRules;

typedef [hidden] enum DISPID_SpeechLexicon {
  DISPID_SLGenerationId = 1,
  DISPID_SLGetWords,
  DISPID_SLAddPronunciation,
  DISPID_SLAddPronunciationByPhoneIds,
  DISPID_SLRemovePronunciation,
  DISPID_SLRemovePronunciationByPhoneIds,
  DISPID_SLGetPronunciations,
  DISPID_SLGetGenerationChange
} DISPID_SpeechLexicon;

typedef enum SpeechLexiconType {
  SLTUser = eLEXTYPE_USER,
  SLTApp = eLEXTYPE_APP
} SpeechLexiconType;

typedef enum SpeechPartOfSpeech {
  SPSNotOverriden = SPPS_NotOverriden,
  SPSUnknown = SPPS_Unknown,
  SPSNoun = SPPS_Noun,
  SPSVerb = SPPS_Verb,
  SPSModifier = SPPS_Modifier,
  SPSFunction = SPPS_Function,
  SPSInterjection = SPPS_Interjection,
#if _SAPI_BLD_ >= 0x53
  SPSLMA = SPPS_LMA,
  SPSSuppressWord = SPPS_SuppressWord
#endif
} SpeechPartOfSpeech;

typedef [hidden] enum DISPID_SpeechLexiconWords {
  DISPID_SLWsCount = 1,
  DISPID_SLWsItem = DISPID_VALUE,
  DISPID_SLWs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechLexiconWords;

typedef enum SpeechWordType {
  SWTAdded = eWORDTYPE_ADDED,
  SWTDeleted = eWORDTYPE_DELETED
} SpeechWordType;

typedef [hidden] enum DISPID_SpeechLexiconWord {
  DISPID_SLWLangId = 1,
  DISPID_SLWType,
  DISPID_SLWWord,
  DISPID_SLWPronunciations
} DISPID_SpeechLexiconWord;

typedef [hidden] enum DISPID_SpeechLexiconProns {
  DISPID_SLPsCount = 1,
  DISPID_SLPsItem = DISPID_VALUE,
  DISPID_SLPs_NewEnum = DISPID_NEWENUM
} DISPID_SpeechLexiconProns;

typedef [hidden] enum DISPID_SpeechLexiconPronunciation {
  DISPID_SLPType = 1,
  DISPID_SLPLangId,
  DISPID_SLPPartOfSpeech,
  DISPID_SLPPhoneIds,
  DISPID_SLPSymbolic,
} DISPID_SpeechLexiconPronunciation;

typedef [hidden] enum DISPID_SpeechPhoneConverter {
  DISPID_SPCLangId = 1,
  DISPID_SPCPhoneToId,
  DISPID_SPCIdToPhone
} DISPID_SpeechPhoneConverter;

[uuid (A372ACD1-3bef-4bbd-8ffb-CB3E2B416AF8)]
dispinterface _ISpeechVoiceEvents {
  properties:
  methods:
  [id (DISPID_SVEStreamStart)] void StartStream ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SVEStreamEnd)] void EndStream ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SVEVoiceChange)] void VoiceChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechObjectToken *VoiceObjectToken);
  [id (DISPID_SVEBookmark)] void Bookmark ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR Bookmark,[in]long BookmarkId);
  [id (DISPID_SVEWord)] void Word ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long CharacterPosition,[in]long Length);
  [id (DISPID_SVESentenceBoundary)] void Sentence ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long CharacterPosition,[in]long Length);
  [id (DISPID_SVEPhoneme)] void Phoneme ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long Duration,[in]short NextPhoneId,[in]SpeechVisemeFeature Feature,[in]short CurrentPhoneId);
  [id (DISPID_SVEViseme)] void Viseme ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long Duration,[in]SpeechVisemeType NextVisemeId,[in]SpeechVisemeFeature Feature,[in]SpeechVisemeType CurrentVisemeId);
  [id (DISPID_SVEAudioLevel)] void AudioLevel ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long AudioLevel);
  [id (DISPID_SVEEnginePrivate)] void EnginePrivate ([in]long StreamNumber,[in]long StreamPosition,[in]VARIANT EngineData);
};

[object, uuid (2d5f1c0c-BD75-4b08-9478-3b11fea2586c), dual, pointer_default (unique)]
interface ISpeechRecognizer : IDispatch {
  [propputref, id (DISPID_SRRecognizer)] HRESULT Recognizer ([in]ISpeechObjectToken *Recognizer);
  [propget, id (DISPID_SRRecognizer)] HRESULT Recognizer ([out, retval]ISpeechObjectToken **Recognizer);
  [propput, hidden, id (DISPID_SRAllowAudioInputFormatChangesOnNextSet)] HRESULT AllowAudioInputFormatChangesOnNextSet ([in] VARIANT_BOOL Allow);
  [propget, hidden, id (DISPID_SRAllowAudioInputFormatChangesOnNextSet)] HRESULT AllowAudioInputFormatChangesOnNextSet ([out, retval] VARIANT_BOOL *Allow);
  [propputref, id (DISPID_SRAudioInput)] HRESULT AudioInput ([in, defaultvalue (0)]ISpeechObjectToken *AudioInput);
  [propget, id (DISPID_SRAudioInput)] HRESULT AudioInput ([out, retval]ISpeechObjectToken **AudioInput);
  [propputref, id (DISPID_SRAudioInputStream)] HRESULT AudioInputStream ([in, defaultvalue (0)]ISpeechBaseStream *AudioInputStream);
  [propget, id (DISPID_SRAudioInputStream)] HRESULT AudioInputStream ([out, retval]ISpeechBaseStream **AudioInputStream);
  [propget, id (DISPID_SRIsShared)] HRESULT IsShared ([out, retval]VARIANT_BOOL *Shared);
  [propput, id (DISPID_SRState)] HRESULT State ([in] SpeechRecognizerState State);
  [propget, id (DISPID_SRState)] HRESULT State ([out, retval] SpeechRecognizerState *State);
  [propget, id (DISPID_SRStatus)] HRESULT Status ([out, retval]ISpeechRecognizerStatus **Status);
  [propputref, id (DISPID_SRProfile)] HRESULT Profile ([in, defaultvalue (0)]ISpeechObjectToken *Profile);
  [propget, id (DISPID_SRProfile)] HRESULT Profile ([out, retval]ISpeechObjectToken **Profile);
  [id (DISPID_SREmulateRecognition)] HRESULT EmulateRecognition ([in]VARIANT TextElements,[in, defaultvalue (NULL)]VARIANT *ElementDisplayAttributes,[in, defaultvalue (0)]long LanguageId);
  [id (DISPID_SRCreateRecoContext)] HRESULT CreateRecoContext ([out, retval]ISpeechRecoContext **NewContext);
  [id (DISPID_SRGetFormat)] HRESULT GetFormat ([in] SpeechFormatType Type,[out, retval]ISpeechAudioFormat **Format);
  [id (DISPID_SRSetPropertyNumber), hidden] HRESULT SetPropertyNumber ([in]const BSTR Name,[in]long Value,[out, retval]VARIANT_BOOL *Supported);
  [id (DISPID_SRGetPropertyNumber), hidden] HRESULT GetPropertyNumber ([in]const BSTR Name,[in, out]long *Value,[out, retval]VARIANT_BOOL *Supported);
  [id (DISPID_SRSetPropertyString), hidden] HRESULT SetPropertyString ([in]const BSTR Name,[in]const BSTR Value,[out, retval]VARIANT_BOOL *Supported);
  [id (DISPID_SRGetPropertyString), hidden] HRESULT GetPropertyString ([in]const BSTR Name,[in, out]BSTR *Value,[out, retval]VARIANT_BOOL *Supported);
  [id (DISPID_SRIsUISupported)] HRESULT IsUISupported ([in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData,[out, retval] VARIANT_BOOL *Supported);
  [id (DISPID_SRDisplayUI)] HRESULT DisplayUI ([in]long hWndParent,[in]BSTR Title,[in]const BSTR TypeOfUI,[in, defaultvalue (NULL)]const VARIANT *ExtraData);
  [id (DISPID_SRGetRecognizers)] HRESULT GetRecognizers ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens);
  [id (DISPID_SVGetAudioInputs)] HRESULT GetAudioInputs ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens);
  [id (DISPID_SVGetProfiles)] HRESULT GetProfiles ([in, defaultvalue ("")]BSTR RequiredAttributes,[in, defaultvalue ("")]BSTR OptionalAttributes,[out, retval]ISpeechObjectTokens **ObjectTokens);
};

[object, uuid (BFF9E781-53ec-484e-BB8A-0e1b5551e35c), dual, pointer_default (unique)]
interface ISpeechRecognizerStatus : IDispatch {
  [propget, id (DISPID_SRSAudioStatus)] HRESULT AudioStatus ([out, retval]ISpeechAudioStatus **AudioStatus);
  [propget, id (DISPID_SRSCurrentStreamPosition)] HRESULT CurrentStreamPosition ([out, retval]VARIANT *pCurrentStreamPos);
  [propget, id (DISPID_SRSCurrentStreamNumber)] HRESULT CurrentStreamNumber ([out, retval]long *StreamNumber);
  [propget, id (DISPID_SRSNumberOfActiveRules)] HRESULT NumberOfActiveRules ([out, retval]long *NumberOfActiveRules);
  [propget, id (DISPID_SRSClsidEngine)] HRESULT ClsidEngine ([out, retval]BSTR *ClsidEngine);
  [propget, id (DISPID_SRSSupportedLanguages)] HRESULT SupportedLanguages ([out, retval]VARIANT *SupportedLanguages);
};

[object, uuid (580aa49d-7e1e-4809-B8E2-57da806104b8), dual, pointer_default (unique)]
interface ISpeechRecoContext : IDispatch {
  [propget, id (DISPID_SRCRecognizer)] HRESULT Recognizer ([out, retval]ISpeechRecognizer **Recognizer);
  [propget, id (DISPID_SRCAudioInInterferenceStatus)] HRESULT AudioInputInterferenceStatus ([out, retval]SpeechInterference *Interference);
  [propget, id (DISPID_SRCRequestedUIType)] HRESULT RequestedUIType ([out, retval]BSTR *UIType);
  [propputref, id (DISPID_SRCVoice)] HRESULT Voice ([in]ISpeechVoice *Voice);
  [propget, id (DISPID_SRCVoice)] HRESULT Voice ([out, retval]ISpeechVoice **Voice);
  [propput, hidden, id (DISPID_SRAllowVoiceFormatMatchingOnNextSet)] HRESULT AllowVoiceFormatMatchingOnNextSet ([in] VARIANT_BOOL Allow);
  [propget, hidden, id (DISPID_SRAllowVoiceFormatMatchingOnNextSet)] HRESULT AllowVoiceFormatMatchingOnNextSet ([out, retval] VARIANT_BOOL *pAllow);
  [propput, id (DISPID_SRCVoicePurgeEvent)] HRESULT VoicePurgeEvent ([in]SpeechRecoEvents EventInterest);
  [propget, id (DISPID_SRCVoicePurgeEvent)] HRESULT VoicePurgeEvent ([out, retval]SpeechRecoEvents *EventInterest);
  [propput, id (DISPID_SRCEventInterests)] HRESULT EventInterests ([in]SpeechRecoEvents EventInterest);
  [propget, id (DISPID_SRCEventInterests)] HRESULT EventInterests ([out, retval]SpeechRecoEvents *EventInterest);
  [propput, id (DISPID_SRCCmdMaxAlternates)] HRESULT CmdMaxAlternates ([in] long MaxAlternates);
  [propget, id (DISPID_SRCCmdMaxAlternates)] HRESULT CmdMaxAlternates ([out, retval] long *MaxAlternates);
  [propput, id (DISPID_SRCState)] HRESULT State ([in] SpeechRecoContextState State);
  [propget, id (DISPID_SRCState)] HRESULT State ([out, retval] SpeechRecoContextState *State);
  [propput, id (DISPID_SRCRetainedAudio)] HRESULT RetainedAudio ([in]SpeechRetainedAudioOptions Option);
  [propget, id (DISPID_SRCRetainedAudio)] HRESULT RetainedAudio ([out, retval]SpeechRetainedAudioOptions *Option);
  [propputref, id (DISPID_SRCRetainedAudioFormat)] HRESULT RetainedAudioFormat ([in] ISpeechAudioFormat *Format);
  [propget, id (DISPID_SRCRetainedAudioFormat)] HRESULT RetainedAudioFormat ([out, retval] ISpeechAudioFormat **Format);
  [id (DISPID_SRCPause)] HRESULT Pause (void);
  [id (DISPID_SRCResume)] HRESULT Resume (void);
  [id (DISPID_SRCCreateGrammar)] HRESULT CreateGrammar ([in, defaultvalue (0)]VARIANT GrammarId,[out, retval]ISpeechRecoGrammar **Grammar);
  [id (DISPID_SRCCreateResultFromMemory)] HRESULT CreateResultFromMemory ([in]VARIANT *ResultBlock,[out, retval]ISpeechRecoResult **Result);
  [id (DISPID_SRCBookmark)] HRESULT Bookmark ([in]SpeechBookmarkOptions Options,[in]VARIANT StreamPos,[in]VARIANT BookmarkId);
  [id (DISPID_SRCSetAdaptationData)] HRESULT SetAdaptationData ([in]BSTR AdaptationString);
};

[object, uuid (B6D6F79F-2158-4e50-B5BC-9a9ccd852a09), dual, pointer_default (unique)]
interface ISpeechRecoGrammar : IDispatch {
  [propget, id (DISPID_SRGId)] HRESULT Id ([out, retval]VARIANT *Id);
  [propget, id (DISPID_SRGRecoContext)] HRESULT RecoContext ([out, retval] ISpeechRecoContext **RecoContext);
  [propput, id (DISPID_SRGState)] HRESULT State ([in]SpeechGrammarState State);
  [propget, id (DISPID_SRGState)] HRESULT State ([out, retval]SpeechGrammarState *State);
  [propget, id (DISPID_SRGRules)] HRESULT Rules ([out, retval]ISpeechGrammarRules **Rules);
  [id (DISPID_SRGReset)] HRESULT Reset ([in, defaultvalue (0)]SpeechLanguageId NewLanguage);
  [id (DISPID_SRGCmdLoadFromFile)] HRESULT CmdLoadFromFile ([in]const BSTR FileName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGCmdLoadFromObject)] HRESULT CmdLoadFromObject ([in]const BSTR ClassId,[in]const BSTR GrammarName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGCmdLoadFromResource)] HRESULT CmdLoadFromResource ([in]long hModule,[in]VARIANT ResourceName,[in]VARIANT ResourceType,[in]SpeechLanguageId LanguageId,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGCmdLoadFromMemory)] HRESULT CmdLoadFromMemory ([in] VARIANT GrammarData,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGCmdLoadFromProprietaryGrammar)] HRESULT CmdLoadFromProprietaryGrammar ([in]const BSTR ProprietaryGuid,[in]const BSTR ProprietaryString,[in]VARIANT ProprietaryData,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGCmdSetRuleState)] HRESULT CmdSetRuleState ([in]const BSTR Name,[in]SpeechRuleState State);
  [id (DISPID_SRGCmdSetRuleIdState)] HRESULT CmdSetRuleIdState ([in]long RuleId,[in]SpeechRuleState State);
  [id (DISPID_SRGDictationLoad)] HRESULT DictationLoad ([in, defaultvalue ("")] const BSTR TopicName,[in, defaultvalue (SLOStatic)]SpeechLoadOption LoadOption);
  [id (DISPID_SRGDictationUnload)] HRESULT DictationUnload (void);
  [id (DISPID_SRGDictationSetState)] HRESULT DictationSetState ([in]SpeechRuleState State);
  [id (DISPID_SRGSetWordSequenceData)] HRESULT SetWordSequenceData ([in]const BSTR Text,[in]long TextLength,[in]ISpeechTextSelectionInformation *Info);
  [id (DISPID_SRGSetTextSelection)] HRESULT SetTextSelection ([in]ISpeechTextSelectionInformation *Info);
  [id (DISPID_SRGIsPronounceable)] HRESULT IsPronounceable ([in]const BSTR Word,[out, retval]SpeechWordPronounceable *WordPronounceable);
};

[uuid (7b8fcb42-0e9d-4f00-A048-7b04d6179d3d)]
dispinterface _ISpeechRecoContextEvents {
  properties:
  methods:
  [id (DISPID_SRCEStartStream)] void StartStream ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCEEndStream)] void EndStream ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT_BOOL StreamReleased);
  [id (DISPID_SRCEBookmark)] void Bookmark ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT BookmarkId,[in]SpeechBookmarkOptions Options);
  [id (DISPID_SRCESoundStart)] void SoundStart ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCESoundEnd)] void SoundEnd ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCEPhraseStart)] void PhraseStart ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCERecognition)] void Recognition ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechRecognitionType RecognitionType,[in]ISpeechRecoResult *Result);
  [id (DISPID_SRCEHypothesis)] void Hypothesis ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechRecoResult *Result);
  [id (DISPID_SRCEPropertyNumberChange)] void PropertyNumberChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR PropertyName,[in]long NewNumberValue);
  [id (DISPID_SRCEPropertyStringChange)] void PropertyStringChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR PropertyName,[in]BSTR NewStringValue);
  [id (DISPID_SRCEFalseRecognition)] void FalseRecognition ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]ISpeechRecoResult *Result);
  [id (DISPID_SRCEInterference)] void Interference ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechInterference Interference);
  [id (DISPID_SRCERequestUI)] void RequestUI ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]BSTR UIType);
  [id (DISPID_SRCERecognizerStateChange)] void RecognizerStateChange ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]SpeechRecognizerState NewState);
  [id (DISPID_SRCEAdaptation)] void Adaptation ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCERecognitionForOtherContext)] void RecognitionForOtherContext ([in]long StreamNumber,[in]VARIANT StreamPosition);
  [id (DISPID_SRCEAudioLevel)] void AudioLevel ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]long AudioLevel);
  [id (DISPID_SRCEEnginePrivate)] void EnginePrivate ([in]long StreamNumber,[in]VARIANT StreamPosition,[in]VARIANT EngineData);
};

[object, uuid (AFE719CF-5dd1-44f2-999c-7a399f1cfccc), dual, pointer_default (unique)]
interface ISpeechGrammarRule : IDispatch {
  [propget, id (DISPID_SGRAttributes)] HRESULT Attributes ([out, retval] SpeechRuleAttributes *Attributes);
  [propget, id (DISPID_SGRInitialState)] HRESULT InitialState ([out, retval] ISpeechGrammarRuleState **State);
  [propget, id (DISPID_SGRName)] HRESULT Name ([out, retval] BSTR *Name);
  [propget, id (DISPID_SGRId)] HRESULT Id ([out, retval] long *Id);
  [id (DISPID_SGRClear)] HRESULT Clear ();
  [id (DISPID_SGRAddResource)] HRESULT AddResource ([in]const BSTR ResourceName,[in]const BSTR ResourceValue);
  [id (DISPID_SGRAddState)] HRESULT AddState ([out, retval] ISpeechGrammarRuleState **State);
};

[object, uuid (6ffa3b44-FC2D-40d1-8afc-32911c7f1ad1), dual, pointer_default (unique)]
interface ISpeechGrammarRules : IDispatch {
  [propget, id (DISPID_SGRsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SGRsFindRule)] HRESULT FindRule ([in]VARIANT RuleNameOrId,[out, retval]ISpeechGrammarRule **Rule);
  [id (DISPID_SGRsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechGrammarRule **Rule);
  [propget, id (DISPID_SGRs_NewEnum), restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
  [propget, id (DISPID_SGRsDynamic)] HRESULT Dynamic ([out, retval] VARIANT_BOOL *Dynamic);
  [id (DISPID_SGRsAdd)] HRESULT Add ([in] BSTR RuleName,[in] SpeechRuleAttributes Attributes,[in, defaultvalue (0)] long RuleId,[out, retval] ISpeechGrammarRule **Rule);
  [id (DISPID_SGRsCommit)] HRESULT Commit (void);
  [id (DISPID_SGRsCommitAndSave)] HRESULT CommitAndSave ([out] BSTR *ErrorText,[out, retval] VARIANT *SaveStream);
};

[object, uuid (D4286F2C-EE67-45ae-B928-28d695362eda), dual, pointer_default (unique)]
interface ISpeechGrammarRuleState : IDispatch {
  [propget, id (DISPID_SGRSRule)] HRESULT Rule ([out, retval] ISpeechGrammarRule **Rule);
  [propget, id (DISPID_SGRSTransitions)] HRESULT Transitions ([out, retval] ISpeechGrammarRuleStateTransitions **Transitions);
  [id (DISPID_SGRSAddWordTransition)] HRESULT AddWordTransition ([in]ISpeechGrammarRuleState *DestState,[in]const BSTR Words, [in, defaultvalue (" ")]const BSTR Separators, [in, defaultvalue (SGLexical)]SpeechGrammarWordType Type, [in, defaultvalue ("")]const BSTR PropertyName, [in, defaultvalue (0)]long PropertyId, [in, defaultvalue (0)]VARIANT *PropertyValue, [in, defaultvalue (1)]float Weight);
  [id (DISPID_SGRSAddRuleTransition)] HRESULT AddRuleTransition ([in]ISpeechGrammarRuleState *DestinationState,[in]ISpeechGrammarRule *Rule,[in, defaultvalue ("")]const BSTR PropertyName,[in, defaultvalue (0)]long PropertyId,[in, defaultvalue (0)]VARIANT *PropertyValue,[in, defaultvalue (1)]float Weight);
  [id (DISPID_SGRSAddSpecialTransition)] HRESULT AddSpecialTransition ([in]ISpeechGrammarRuleState *DestinationState,[in]SpeechSpecialTransitionType Type,[in, defaultvalue ("")]const BSTR PropertyName,[in, defaultvalue (0)]long PropertyId,[in, defaultvalue (0)]VARIANT *PropertyValue,[in, defaultvalue (1)]float Weight);
};

[object, uuid (EABCE657-75bc-44a2-AA7F-C56476742963), dual, pointer_default (unique)]
interface ISpeechGrammarRuleStateTransitions : IDispatch {
  [propget, id (DISPID_SGRSTsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SGRSTsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechGrammarRuleStateTransition **Transition);
  [propget, restricted, id (DISPID_SGRSTs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (CAFD1DB1-41d1-4a06-9863-E2E81DA17A9A), dual, pointer_default (unique)]
interface ISpeechGrammarRuleStateTransition : IDispatch {
  [propget, id (DISPID_SGRSTType)] HRESULT Type ([out, retval] SpeechGrammarRuleStateTransitionType *Type);
  [propget, id (DISPID_SGRSTText)] HRESULT Text ([out, retval] BSTR *Text);
  [propget, id (DISPID_SGRSTRule)] HRESULT Rule ([out, retval] ISpeechGrammarRule **Rule);
  [propget, id (DISPID_SGRSTWeight)] HRESULT Weight ([out, retval] VARIANT *Weight);
  [propget, id (DISPID_SGRSTPropertyName)] HRESULT PropertyName ([out, retval] BSTR *PropertyName);
  [propget, id (DISPID_SGRSTPropertyId)] HRESULT PropertyId ([out, retval] long *PropertyId);
  [propget, id (DISPID_SGRSTPropertyValue)] HRESULT PropertyValue ([out, retval] VARIANT *PropertyValue);
  [propget, id (DISPID_SGRSTNextState)] HRESULT NextState ([out, retval] ISpeechGrammarRuleState **NextState);
};

[object, uuid (3b9c7e7a-6eee-4ded-9092-11657279adbe), dual, pointer_default (unique)]
interface ISpeechTextSelectionInformation : IDispatch {
  [propput, id (DISPIDSPTSI_ActiveOffset)] HRESULT ActiveOffset ([in]long ActiveOffset);
  [propget, id (DISPIDSPTSI_ActiveOffset)] HRESULT ActiveOffset ([out, retval]long *ActiveOffset);
  [propput, id (DISPIDSPTSI_ActiveLength)] HRESULT ActiveLength ([in]long ActiveLength);
  [propget, id (DISPIDSPTSI_ActiveLength)] HRESULT ActiveLength ([out, retval]long *ActiveLength);
  [propput, id (DISPIDSPTSI_SelectionOffset)] HRESULT SelectionOffset ([in]long SelectionOffset);
  [propget, id (DISPIDSPTSI_SelectionOffset)] HRESULT SelectionOffset ([out, retval]long *SelectionOffset);
  [propput, id (DISPIDSPTSI_SelectionLength)] HRESULT SelectionLength ([in]long SelectionLength);
  [propget, id (DISPIDSPTSI_SelectionLength)] HRESULT SelectionLength ([out, retval]long *SelectionLength);
};

[object, uuid (ED2879CF-CED9-4ee6-A534-DE0191D5468D), dual, pointer_default (unique)]
interface ISpeechRecoResult : IDispatch {
  [propget, id (DISPID_SRRRecoContext)] HRESULT RecoContext ([out, retval]ISpeechRecoContext **RecoContext);
  [propget, id (DISPID_SRRTimes)] HRESULT Times ([out, retval]ISpeechRecoResultTimes **Times);
  [propputref, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([in]ISpeechAudioFormat *Format);
  [propget, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([out, retval]ISpeechAudioFormat **Format);
  [propget, id (DISPID_SRRPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo);
  [id (DISPID_SRRAlternates)] HRESULT Alternates ([in] long RequestCount,[in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechPhraseAlternates **Alternates);
  [id (DISPID_SRRAudio)] HRESULT Audio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechMemoryStream **Stream);
  [id (DISPID_SRRSpeakAudio)] HRESULT SpeakAudio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber);
  [id (DISPID_SRRSaveToMemory)] HRESULT SaveToMemory ([out, retval] VARIANT *ResultBlock);
  [id (DISPID_SRRDiscardResultInfo)] HRESULT DiscardResultInfo ([in]SpeechDiscardType ValueTypes);
};

#if _SAPI_BLD_ >= 0x53
[object, uuid (AAEC54AF-8f85-4924-944d-B79D39D72E19), dual, pointer_default (unique)]
interface ISpeechXMLRecoResult : ISpeechRecoResult {
  [id (DISPID_SRRGetXMLResult)] HRESULT GetXMLResult ([in] SPXMLRESULTOPTIONS Options,[out, retval] BSTR *pResult);
  [id (DISPID_SRRGetXMLErrorInfo)] HRESULT GetXMLErrorInfo ([out] long *LineNumber,[out]BSTR *ScriptLine,[out]BSTR *Source,[out]BSTR *Description,[out]long *ResultCode,[out, retval]VARIANT_BOOL *IsError);
};

[object, uuid (8e0a246d-D3C8-45de-8657-04290c458c3c), dual, pointer_default (unique)]
interface ISpeechRecoResult2: ISpeechRecoResult {
  [id (DISPID_SRRSetTextFeedback)] HRESULT SetTextFeedback ([in]BSTR Feedback,[in]VARIANT_BOOL WasSuccessful);
}

[object, uuid (6d60eb64-ACED-40a6-BBF3-4e557f71dee2), dual, hidden, pointer_default (unique)]
interface ISpeechRecoResultDispatch : IDispatch {
  [propget, id (DISPID_SRRRecoContext)] HRESULT RecoContext ([out, retval]ISpeechRecoContext **RecoContext);
  [propget, id (DISPID_SRRTimes)] HRESULT Times ([out, retval]ISpeechRecoResultTimes **Times);
  [propputref, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([in]ISpeechAudioFormat *Format);
  [propget, id (DISPID_SRRAudioFormat)] HRESULT AudioFormat ([out, retval]ISpeechAudioFormat **Format);
  [propget, id (DISPID_SRRPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo);
  [id (DISPID_SRRAlternates)] HRESULT Alternates ([in] long RequestCount,[in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechPhraseAlternates **Alternates);
  [id (DISPID_SRRAudio)] HRESULT Audio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[out, retval] ISpeechMemoryStream **Stream);
  [id (DISPID_SRRSpeakAudio)] HRESULT SpeakAudio ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (SPF_DEFAULT)] SpeechVoiceSpeakFlags Flags,[out, retval]long *StreamNumber);
  [id (DISPID_SRRSaveToMemory)] HRESULT SaveToMemory ([out, retval] VARIANT *ResultBlock);
  [id (DISPID_SRRDiscardResultInfo)] HRESULT DiscardResultInfo ([in]SpeechDiscardType ValueTypes);
  [id (DISPID_SRRGetXMLResult)] HRESULT GetXMLResult ([in] SPXMLRESULTOPTIONS Options,[out, retval] BSTR *pResult);
  [id (DISPID_SRRGetXMLErrorInfo)] HRESULT GetXMLErrorInfo ([out] long *LineNumber,[out]BSTR *ScriptLine,[out]BSTR *Source,[out]BSTR *Description,[out]HRESULT *ResultCode,[out, retval]VARIANT_BOOL *IsError);
  [id (DISPID_SRRSetTextFeedback)] HRESULT SetTextFeedback ([in] BSTR Feedback,[in] VARIANT_BOOL WasSuccessful);
};
#endif

[object, uuid (3b151836-DF3A-4e0a-846c-D2ADC9334333), dual, pointer_default (unique)]
interface ISpeechPhraseInfoBuilder : IDispatch {
  [id (DISPID_SPPBRestorePhraseFromMemory)] HRESULT RestorePhraseFromMemory ([in] VARIANT *PhraseInMemory,[out, retval] ISpeechPhraseInfo **PhraseInfo);
};

[object, uuid (62b3b8fb-F6E7-41be-BDCB-056b1c29efc0), dual, pointer_default (unique)]
interface ISpeechRecoResultTimes : IDispatch {
  [propget, id (DISPID_SRRTStreamTime)] HRESULT StreamTime ([out, retval]VARIANT *Time);
  [propget, id (DISPID_SRRTLength)] HRESULT Length ([out, retval]VARIANT *Length);
  [propget, id (DISPID_SRRTTickCount)] HRESULT TickCount ([out, retval]long *TickCount);
  [propget, id (DISPID_SRRTOffsetFromStart)] HRESULT OffsetFromStart ([out, retval]VARIANT *OffsetFromStart);
};

[object, uuid (27864a2a-2b9f-4cb8-92d3-0d2722fd1e73), dual, pointer_default (unique)]
interface ISpeechPhraseAlternate : IDispatch {
  [propget, id (DISPID_SPARecoResult)] HRESULT RecoResult ([out, retval]ISpeechRecoResult **RecoResult);
  [propget, id (DISPID_SPAStartElementInResult)] HRESULT StartElementInResult ([out, retval]long *StartElement);
  [propget, id (DISPID_SPANumberOfElementsInResult)] HRESULT NumberOfElementsInResult ([out, retval]long *NumberOfElements);
  [propget, id (DISPID_SPAPhraseInfo)] HRESULT PhraseInfo ([out, retval]ISpeechPhraseInfo **PhraseInfo);
  [id (DISPID_SPACommit)] HRESULT Commit (void);
};

[object, uuid (B238B6D5-F276-4c3d-A6C1-2974801c3cc2), dual, pointer_default (unique)]
interface ISpeechPhraseAlternates : IDispatch {
  [propget, id (DISPID_SPAsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SPAsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseAlternate **PhraseAlternate);
  [propget, restricted, id (DISPID_SPAs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (961559cf-4e67-4662-8bf0-D93F1FCD61B3), dual, pointer_default (unique)]
interface ISpeechPhraseInfo : IDispatch {
  [propget, id (DISPID_SPILanguageId)] HRESULT LanguageId ([out, retval]long *LanguageId);
  [propget, id (DISPID_SPIGrammarId)] HRESULT GrammarId ([out, retval]VARIANT *GrammarId);
  [propget, id (DISPID_SPIStartTime)] HRESULT StartTime ([out, retval]VARIANT *StartTime);
  [propget, id (DISPID_SPIAudioStreamPosition)] HRESULT AudioStreamPosition ([out, retval]VARIANT *AudioStreamPosition);
  [propget, id (DISPID_SPIAudioSizeBytes)] HRESULT AudioSizeBytes ([out, retval]long *pAudioSizeBytes);
  [propget, id (DISPID_SPIRetainedSizeBytes)] HRESULT RetainedSizeBytes ([out, retval]long *RetainedSizeBytes);
  [propget, id (DISPID_SPIAudioSizeTime)] HRESULT AudioSizeTime ([out, retval]long *AudioSizeTime);
  [propget, id (DISPID_SPIRule)] HRESULT Rule ([out, retval]ISpeechPhraseRule **Rule);
  [propget, id (DISPID_SPIProperties)] HRESULT Properties ([out, retval]ISpeechPhraseProperties **Properties);
  [propget, id (DISPID_SPIElements)] HRESULT Elements ([out, retval]ISpeechPhraseElements **Elements);
  [propget, id (DISPID_SPIReplacements)] HRESULT Replacements ([out, retval]ISpeechPhraseReplacements **Replacements);
  [propget, id (DISPID_SPIEngineId)] HRESULT EngineId ([out, retval]BSTR *EngineIdGuid);
  [propget, id (DISPID_SPIEnginePrivateData)] HRESULT EnginePrivateData ([out, retval]VARIANT *PrivateData);
  [id (DISPID_SPISaveToMemory)] HRESULT SaveToMemory ([out, retval]VARIANT *PhraseBlock);
  [id (DISPID_SPIGetText)] HRESULT GetText ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (-1)] VARIANT_BOOL UseReplacements,[out, retval]BSTR *Text);
  [id (DISPID_SPIGetDisplayAttributes)] HRESULT GetDisplayAttributes ([in, defaultvalue (0)] long StartElement,[in, defaultvalue (SPPR_ALL_ELEMENTS)] long Elements,[in, defaultvalue (-1)] VARIANT_BOOL UseReplacements,[out, retval]SpeechDisplayAttributes *DisplayAttributes);
};

[object, uuid (E6176F96-E373-4801-B223-3b62c068c0b4), dual, pointer_default (unique)]
interface ISpeechPhraseElement : IDispatch {
  [propget, id (DISPID_SPEAudioTimeOffset)] HRESULT AudioTimeOffset ([out, retval]long *AudioTimeOffset);
  [propget, id (DISPID_SPEAudioSizeTime)] HRESULT AudioSizeTime ([out, retval]long *AudioSizeTime);
  [propget, id (DISPID_SPEAudioStreamOffset)] HRESULT AudioStreamOffset ([out, retval]long *AudioStreamOffset);
  [propget, id (DISPID_SPEAudioSizeBytes)] HRESULT AudioSizeBytes ([out, retval]long *AudioSizeBytes);
  [propget, id (DISPID_SPERetainedStreamOffset)] HRESULT RetainedStreamOffset ([out, retval]long *RetainedStreamOffset);
  [propget, id (DISPID_SPERetainedSizeBytes)] HRESULT RetainedSizeBytes ([out, retval]long *RetainedSizeBytes);
  [propget, id (DISPID_SPEDisplayText)] HRESULT DisplayText ([out, retval]BSTR *DisplayText);
  [propget, id (DISPID_SPELexicalForm)] HRESULT LexicalForm ([out, retval]BSTR *LexicalForm);
  [propget, id (DISPID_SPEPronunciation)] HRESULT Pronunciation ([out, retval]VARIANT *Pronunciation);
  [propget, id (DISPID_SPEDisplayAttributes)] HRESULT DisplayAttributes ([out, retval]SpeechDisplayAttributes *DisplayAttributes);
  [propget, id (DISPID_SPERequiredConfidence)] HRESULT RequiredConfidence ([out, retval]SpeechEngineConfidence *RequiredConfidence);
  [propget, id (DISPID_SPEActualConfidence)] HRESULT ActualConfidence ([out, retval]SpeechEngineConfidence *ActualConfidence);
  [propget, id (DISPID_SPEEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *EngineConfidence);
};

[object, uuid (0626b328-3478-467d-A0B3-D0853B93DDA3), dual, pointer_default (unique)]
interface ISpeechPhraseElements : IDispatch {
  [propget, id (DISPID_SPEsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SPEsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseElement **Element);
  [propget, restricted, id (DISPID_SPEs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (2890a410-53a7-4fb5-94ec-06d4998e3d02), dual, pointer_default (unique)]
interface ISpeechPhraseReplacement : IDispatch {
  [propget, id (DISPID_SPRDisplayAttributes)] HRESULT DisplayAttributes ([out, retval]SpeechDisplayAttributes *DisplayAttributes);
  [propget, id (DISPID_SPRText)] HRESULT Text ([out, retval]BSTR *Text);
  [propget, id (DISPID_SPRFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement);
  [propget, id (DISPID_SPRNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements);
};

[object, uuid (38bc662f-2257-4525-959e-2069d2596c05), dual, pointer_default (unique)]
interface ISpeechPhraseReplacements : IDispatch {
  [propget, id (DISPID_SPRsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SPRsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseReplacement **Reps);
  [propget, restricted, id (DISPID_SPRs_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (CE563D48-961e-4732-A2E1-378a42b430be), dual, pointer_default (unique)]
interface ISpeechPhraseProperty : IDispatch {
  [propget, id (DISPID_SPPName)] HRESULT Name ([out, retval]BSTR *Name);
  [propget, id (DISPID_SPPId)] HRESULT Id ([out, retval]long *Id);
  [propget, id (DISPID_SPPValue)] HRESULT Value ([out, retval]VARIANT *Value);
  [propget, id (DISPID_SPPFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement);
  [propget, id (DISPID_SPPNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements);
  [propget, id (DISPID_SPPEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *Confidence);
  [propget, id (DISPID_SPPConfidence)] HRESULT Confidence ([out, retval]SpeechEngineConfidence *Confidence);
  [propget, id (DISPID_SPPParent)] HRESULT Parent ([out, retval]ISpeechPhraseProperty **ParentProperty);
  [propget, id (DISPID_SPPChildren)] HRESULT Children ([out, retval]ISpeechPhraseProperties **Children);
};

[object, uuid (08166b47-102e-4b23-A599-BDB98DBFD1F4), dual, pointer_default (unique)]
interface ISpeechPhraseProperties : IDispatch {
  [propget, id (DISPID_SPPsCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SPPsItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseProperty **Property);
  [propget, id (DISPID_SPPs_NewEnum), restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (A7BFE112-A4A0-48d9-B602-C313843F6964), dual, pointer_default (unique)]
interface ISpeechPhraseRule : IDispatch {
  [propget, id (DISPID_SPRuleName)] HRESULT Name ([out, retval]BSTR *Name);
  [propget, id (DISPID_SPRuleId)] HRESULT Id ([out, retval]long *Id);
  [propget, id (DISPID_SPRuleFirstElement)] HRESULT FirstElement ([out, retval]long *FirstElement);
  [propget, id (DISPID_SPRuleNumberOfElements)] HRESULT NumberOfElements ([out, retval]long *NumberOfElements);
  [propget, id (DISPID_SPRuleParent)] HRESULT Parent ([out, retval]ISpeechPhraseRule **Parent);
  [propget, id (DISPID_SPRuleChildren)] HRESULT Children ([out, retval]ISpeechPhraseRules **Children);
  [propget, id (DISPID_SPRuleConfidence)] HRESULT Confidence ([out, retval]SpeechEngineConfidence *ActualConfidence);
  [propget, id (DISPID_SPRuleEngineConfidence)] HRESULT EngineConfidence ([out, retval]float *EngineConfidence);
};

[object, uuid (9047d593-01dd-4b72-81a3-E4A0CA69F407), dual, pointer_default (unique)]
interface ISpeechPhraseRules : IDispatch {
  [propget, id (DISPID_SPRulesCount)] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_SPRulesItem)] HRESULT Item ([in] long Index,[out, retval]ISpeechPhraseRule **Rule);
  [propget, restricted, id (DISPID_SPRules_NewEnum)] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (8d199862-415e-47d5-AC4F-FAA608B424E6), dual, pointer_default (unique)]
interface ISpeechLexiconWords : IDispatch {
  [id (DISPID_SLWsCount), propget] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechLexiconWord **Word);
  [id (DISPID_NEWENUM), propget, restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (3da7627a-C7AE-4b23-8708-638c50362c25), dual, pointer_default (unique)]
interface ISpeechLexicon : IDispatch {
  [id (DISPID_SLGenerationId), propget, hidden] HRESULT GenerationId ([out, retval]long *GenerationId);
  [id (DISPID_SLGetWords)] HRESULT GetWords ([in, defaultvalue (eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType Flags,[out, defaultvalue (NULL)]long *GenerationID,[out, retval]ISpeechLexiconWords **Words);
  [id (DISPID_SLAddPronunciation)] HRESULT AddPronunciation ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue ("")]BSTR bstrPronunciation);
  [hidden, id (DISPID_SLAddPronunciationByPhoneIds)] HRESULT AddPronunciationByPhoneIds ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (NULL)]VARIANT *PhoneIds);
  [id (DISPID_SLRemovePronunciation)] HRESULT RemovePronunciation ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue ("")]BSTR bstrPronunciation);
  [id (DISPID_SLRemovePronunciationByPhoneIds), hidden] HRESULT RemovePronunciationByPhoneIds ([in]BSTR bstrWord,[in]SpeechLanguageId LangId,[in, defaultvalue (SPSUnknown)]SpeechPartOfSpeech PartOfSpeech,[in, defaultvalue (NULL)]VARIANT *PhoneIds);
  [id (DISPID_SLGetPronunciations)] HRESULT GetPronunciations ([in]BSTR bstrWord,[in, defaultvalue (0)]SpeechLanguageId LangId,[in, defaultvalue (eLEXTYPE_USER | eLEXTYPE_APP)]SpeechLexiconType TypeFlags,[out, retval]ISpeechLexiconPronunciations **ppPronunciations);
  [id (DISPID_SLGetGenerationChange), hidden] HRESULT GetGenerationChange ([in, out]long *GenerationID,[out, retval]ISpeechLexiconWords **ppWords);
};

[object, uuid (4e5b933c-C9BE-48ed-8842-1ee51bb1d4ff), dual, pointer_default (unique)]
interface ISpeechLexiconWord : IDispatch {
  [id (DISPID_SLWLangId), propget] HRESULT LangId ([out, retval]SpeechLanguageId *LangId);
  [id (DISPID_SLWType), propget] HRESULT Type ([out, retval]SpeechWordType *WordType);
  [id (DISPID_SLWWord), propget] HRESULT Word ([out, retval]BSTR *Word);
  [id (DISPID_SLWPronunciations), propget] HRESULT Pronunciations ([out, retval]ISpeechLexiconPronunciations **Pronunciations);
};

[object, uuid (72829128-5682-4704-A0D4-3e2bb6f2ead3), dual, pointer_default (unique)]
interface ISpeechLexiconPronunciations : IDispatch {
  [id (DISPID_SLPsCount), propget] HRESULT Count ([out, retval] long *Count);
  [id (DISPID_VALUE)] HRESULT Item ([in] long Index,[out, retval]ISpeechLexiconPronunciation **Pronunciation);
  [id (DISPID_NEWENUM), propget, restricted] HRESULT _NewEnum ([out, retval] IUnknown **EnumVARIANT);
};

[object, uuid (95252c5d-9e43-4f4a-9899-48ee73352f9f), dual, pointer_default (unique)]
interface ISpeechLexiconPronunciation : IDispatch {
  [id (DISPID_SLPType), propget] HRESULT Type ([out, retval]SpeechLexiconType *LexiconType);
  [id (DISPID_SLPLangId), propget] HRESULT LangId ([out, retval]SpeechLanguageId *LangId);
  [id (DISPID_SLPPartOfSpeech), propget] HRESULT PartOfSpeech ([out, retval]SpeechPartOfSpeech *PartOfSpeech);
  [id (DISPID_SLPPhoneIds), propget] HRESULT PhoneIds ([out, retval]VARIANT *PhoneIds);
  [id (DISPID_SLPSymbolic), propget] HRESULT Symbolic ([out, retval]BSTR *Symbolic);
};

[object, uuid (C3E4F353-433f-43d6-89a1-6a62a7054c3d), dual, pointer_default (unique)]
interface ISpeechPhoneConverter : IDispatch {
  [propget, id (DISPID_SPCLangId)] HRESULT LanguageId ([out, retval]SpeechLanguageId *LanguageId);
  [propput, id (DISPID_SPCLangId)] HRESULT LanguageId ([in]SpeechLanguageId LanguageId);
  [id (DISPID_SPCPhoneToId)] HRESULT PhoneToId ([in]const BSTR Phonemes,[out, retval]VARIANT *IdArray);
  [id (DISPID_SPCIdToPhone)] HRESULT IdToPhone ([in]const VARIANT IdArray,[out, retval]BSTR *Phonemes);
}

  [uuid (E2AE5372-5d40-11d2-960e-00c04f8ee628), hidden]
  coclass SpNotifyTranslator {
    interface ISpNotifyTranslator;
  }
  
  [uuid (A910187F-0c7a-45ac-92cc-59edafb77b53)]
  coclass SpObjectTokenCategory {
    [default] interface ISpeechObjectTokenCategory;
    interface ISpObjectTokenCategory;
  }
  
  [uuid (EF411752-3736-4cb4-9c8c-8ef4ccb58efe)]
  coclass SpObjectToken {
    [default] interface ISpeechObjectToken;
    interface ISpObjectToken;
  }
  
  [uuid (96749373-3391-11d2-9ee3-00c04f797396), hidden]
  coclass SpResourceManager {
    [default] interface ISpResourceManager;
  };
  
  [uuid (7013943a-E2EC-11d2-A086-00c04f8ef9b5), hidden]
  coclass SpStreamFormatConverter {
    [default] interface ISpStreamFormatConverter;
  };
  
  [uuid (AB1890A0-E91F-11d2-BB91-00c04f8ee6c0), hidden]
  coclass SpMMAudioEnum {
    interface IEnumSpObjectTokens;
  };
  
  [uuid (CF3D2E50-53f2-11d2-960c-00c04f8ee628)]
  coclass SpMMAudioIn {
    [default] interface ISpeechMMSysAudio;
    interface ISpEventSource;
    interface ISpEventSink;
    interface ISpObjectWithToken;
    interface ISpMMSysAudio;
  };
  
  [uuid (A8C680EB-3d32-11d2-9ee7-00c04f797396)]
  coclass SpMMAudioOut {
    [default] interface ISpeechMMSysAudio;
    interface ISpEventSource;
    interface ISpEventSink;
    interface ISpObjectWithToken;
    interface ISpMMSysAudio;
  };
  
  [uuid (715d9c59-4442-11d2-9605-00c04f8ee628), hidden]
  coclass SpStream {
    interface ISpStream;
  };
  
  [uuid (96749377-3391-11d2-9ee3-00c04f797396)]
  coclass SpVoice {
    [default] interface ISpeechVoice;
    interface ISpVoice;
#if _SAPI_BLD_ >= 0x53
    interface ISpPhoneticAlphabetSelection;
#endif
    [default, source] dispinterface _ISpeechVoiceEvents;
  };
  [uuid (47206204-5eca-11d2-960f-00c04f8ee628)]
  coclass SpSharedRecoContext {
    [default] interface ISpeechRecoContext;
    interface ISpRecoContext;
#if _SAPI_BLD_ >= 0x53
    interface ISpRecoContext2;
    interface ISpPhoneticAlphabetSelection;
#endif
    [default, source] dispinterface _ISpeechRecoContextEvents;
  };

  [uuid (41b89b6b-9399-11d2-9623-00c04f8ee628)]
  coclass SpInprocRecognizer {
    [default] interface ISpeechRecognizer;
    interface ISpRecognizer;
#if _SAPI_BLD_ >= 0x053
    interface ISpRecognizer2;
#if _SAPI_BLD_ >= 0x54
    interface ISpRecognizer3;
#endif
    interface ISpSerializeState;
#endif
  };
  
  [uuid (3bee4890-4fe9-4a37-8c1e-5e7e12791c1f)]
  coclass SpSharedRecognizer {
    [default] interface ISpeechRecognizer;
    interface ISpRecognizer;
#if _SAPI_BLD_ >= 0x53
    interface ISpRecognizer2;
#if _SAPI_BLD_ >= 0x054
    interface ISpRecognizer3;
#endif
    interface ISpSerializeState;
#endif
  };
  
  [uuid (0655e396-25d0-11d3-9c26-00c04f8ef87c)]
  coclass SpLexicon {
    [default] interface ISpeechLexicon;
    interface ISpLexicon;
#if _SAPI_BLD_ >= 0x53
    interface ISpPhoneticAlphabetSelection;
#endif
  };
  
  [uuid (C9E37C15-DF92-4727-85d6-72e5eeb6995a)]
  coclass SpUnCompressedLexicon {
    [default] interface ISpeechLexicon;
    interface ISpLexicon;
    interface ISpObjectWithToken;
#if _SAPI_BLD_ >= 0x53
    interface ISpPhoneticAlphabetSelection;
#endif
  };
  
  [uuid (90903716-2f42-11d3-9c26-00c04f8ef87c), hidden]
  coclass SpCompressedLexicon {
    [default] interface ISpLexicon;
    interface ISpObjectWithToken;
  };

#if _SAPI_BLD_ >= 0x053
  [uuid (0d722f1a-9fcf-4e62-96d8-6df8f01a26aa)]
  coclass SpShortcut {
    interface ISpShortcut;
    interface ISpObjectWithToken;
  };
#endif

  [uuid (9185f743-1143-4c28-86b5-BFF14F20E5C8)]
  coclass SpPhoneConverter {
    [default] interface ISpeechPhoneConverter;
    interface ISpPhoneConverter;
#if _SAPI_BLD_ >= 0x53
    interface ISpPhoneticAlphabetSelection;
#endif
  };

#if _SAPI_BLD_ >= 0x53
  [uuid (4f414126-DFE3-4629-99ee-797978317ead)]
  coclass SpPhoneticAlphabetConverter {
    interface ISpPhoneticAlphabetConverter;
  };
#endif

  [uuid (455f24e9-7396-4a16-9715-7c0fdbe3efe3), hidden]
  coclass SpNullPhoneConverter {
    [default] interface ISpPhoneConverter;
  };
  
  [uuid (0f92030a-CBFD-4ab8-A164-FF5985547FF6)]
  coclass SpTextSelectionInformation {
    [default] interface ISpeechTextSelectionInformation;
  };
  
  [uuid (C23FC28D-C55F-4720-8b32-91f73c2bd5d1)]
  coclass SpPhraseInfoBuilder {
    [default] interface ISpeechPhraseInfoBuilder;
  };
  
  [uuid (9ef96870-E160-4792-820d-48cf0649e4ec)]
  coclass SpAudioFormat {
    [default] interface ISpeechAudioFormat;
  };
  
  [uuid (C79A574C-63be-44b9-801f-283f87f898be)]
  coclass SpWaveFormatEx {
    [default] interface ISpeechWaveFormatEx;
  };
  
  [uuid (73ad6842-ACE0-45e8-A4DD-8795881a2c2a)]
  coclass SpInProcRecoContext {
    [default] interface ISpeechRecoContext;
    interface ISpRecoContext;
#if _SAPI_BLD_ >= 0x53
    interface ISpRecoContext2;
    interface ISpPhoneticAlphabetSelection;
#endif
    [default, source] dispinterface _ISpeechRecoContextEvents;
  };
  
  [uuid (8dbef13f-1948-4aa8-8cf0-048eebed95d8)]
  coclass SpCustomStream {
    [default] interface ISpeechCustomStream;
    interface ISpStream;
  };
  
  [uuid (947812b3-2ae1-4644-BA86-9e90ded7ec91)]
  coclass SpFileStream {
    [default] interface ISpeechFileStream;
    interface ISpStream;
  };
  
  [uuid (5fb7ef7d-DFF4-468a-B6B7-2fcbd188f994)]
  coclass SpMemoryStream {
    [default] interface ISpeechMemoryStream;
    interface ISpStream;
  };

#if _SAPI_BLD_ >= 0x53
  interface ISpXMLRecoResult;
  interface ISpRecoGrammar2;
  interface ISpeechResourceLoader;
#endif
}