From 34e8be1e9d0beef9dac160e08d6e297d5b4a26cf Mon Sep 17 00:00:00 2001 From: Duncan Ogilvie Date: Sat, 18 Jan 2025 18:05:11 +0100 Subject: [PATCH] Add test headers from Jonas --- btparser/tests/jonas-big.h | 2366 ++++++++++++++++++++++++++++++++++ btparser/tests/jonas-small.h | 72 ++ 2 files changed, 2438 insertions(+) create mode 100644 btparser/tests/jonas-big.h create mode 100644 btparser/tests/jonas-small.h diff --git a/btparser/tests/jonas-big.h b/btparser/tests/jonas-big.h new file mode 100644 index 0000000..ba41d9a --- /dev/null +++ b/btparser/tests/jonas-big.h @@ -0,0 +1,2366 @@ +struct tagRECT{ LONG left; LONG top; LONG right; LONG bottom; }; +struct tagPOINT{ LONG x; LONG y; }; +struct tagSIZE{ LONG cx; LONG cy; }; +struct tagPOINTS{ SHORT x; SHORT y; }; +struct tagENUMUILANG{ ULONG NumOfEnumUILang; ULONG SizeOfEnumUIBuffer; LANGID* pEnumUIBuffer; }; +struct tagHW_PROFILE_INFOA{ DWORD dwDockInfo; CHAR szHwProfileGuid[39]; CHAR szHwProfileName[80]; }; +struct tagHW_PROFILE_INFOW{ DWORD dwDockInfo; WCHAR szHwProfileGuid[39]; WCHAR szHwProfileName[80]; }; +struct tagACTCTXA{ ULONG cbSize; DWORD dwFlags; LPCSTR lpSource; USHORT wProcessorArchitecture; LANGID wLangId; LPCSTR lpAssemblyDirectory; LPCSTR lpResourceName; LPCSTR lpApplicationName; HMODULE hModule; }; +struct tagACTCTXW{ ULONG cbSize; DWORD dwFlags; LPCWSTR lpSource; USHORT wProcessorArchitecture; LANGID wLangId; LPCWSTR lpAssemblyDirectory; LPCWSTR lpResourceName; LPCWSTR lpApplicationName; HMODULE hModule; }; +struct tagACTCTX_SECTION_KEYED_DATA_2600{ ULONG cbSize; ULONG ulDataFormatVersion; PVOID lpData; ULONG ulLength; PVOID lpSectionGlobalData; ULONG ulSectionGlobalDataLength; PVOID lpSectionBase; ULONG ulSectionTotalLength; HANDLE hActCtx; ULONG ulAssemblyRosterIndex; }; +struct tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA{ PVOID lpInformation; PVOID lpSectionBase; ULONG ulSectionLength; PVOID lpSectionGlobalDataBase; ULONG ulSectionGlobalDataLength; }; +struct tagACTCTX_SECTION_KEYED_DATA{ ULONG cbSize; ULONG ulDataFormatVersion; PVOID lpData; ULONG ulLength; PVOID lpSectionGlobalData; ULONG ulSectionGlobalDataLength; PVOID lpSectionBase; ULONG ulSectionTotalLength; HANDLE hActCtx; ULONG ulAssemblyRosterIndex; ULONG ulFlags; ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata; }; +struct tagXFORM{ FLOAT eM11; FLOAT eM12; FLOAT eM21; FLOAT eM22; FLOAT eDx; FLOAT eDy; }; +struct tagBITMAP{ LONG bmType; LONG bmWidth; LONG bmHeight; LONG bmWidthBytes; WORD bmPlanes; WORD bmBitsPixel; LPVOID bmBits; }; +struct tagRGBTRIPLE{ BYTE rgbtBlue; BYTE rgbtGreen; BYTE rgbtRed; }; +struct tagRGBQUAD{ BYTE rgbBlue; BYTE rgbGreen; BYTE rgbRed; BYTE rgbReserved; }; +struct tagCIEXYZ{ FXPT2DOT30 ciexyzX; FXPT2DOT30 ciexyzY; FXPT2DOT30 ciexyzZ; }; +struct tagICEXYZTRIPLE{ CIEXYZ ciexyzRed; CIEXYZ ciexyzGreen; CIEXYZ ciexyzBlue; }; +struct tagLOGCOLORSPACEA{ DWORD lcsSignature; DWORD lcsVersion; DWORD lcsSize; LCSCSTYPE lcsCSType; LCSGAMUTMATCH lcsIntent; CIEXYZTRIPLE lcsEndpoints; DWORD lcsGammaRed; DWORD lcsGammaGreen; DWORD lcsGammaBlue; CHAR lcsFilename[260]; }; +struct tagLOGCOLORSPACEW{ DWORD lcsSignature; DWORD lcsVersion; DWORD lcsSize; LCSCSTYPE lcsCSType; LCSGAMUTMATCH lcsIntent; CIEXYZTRIPLE lcsEndpoints; DWORD lcsGammaRed; DWORD lcsGammaGreen; DWORD lcsGammaBlue; WCHAR lcsFilename[260]; }; +struct tagBITMAPCOREHEADER{ DWORD bcSize; WORD bcWidth; WORD bcHeight; WORD bcPlanes; WORD bcBitCount; }; +struct tagBITMAPINFOHEADER{ DWORD biSize; LONG biWidth; LONG biHeight; WORD biPlanes; WORD biBitCount; DWORD biCompression; DWORD biSizeImage; LONG biXPelsPerMeter; LONG biYPelsPerMeter; DWORD biClrUsed; DWORD biClrImportant; }; +struct tagBITMAPINFO{ BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[1]; }; +struct tagBITMAPCOREINFO{ BITMAPCOREHEADER bmciHeader; RGBTRIPLE bmciColors[1]; }; +struct tagBITMAPFILEHEADER{ WORD bfType; DWORD bfSize; WORD bfReserved1; WORD bfReserved2; DWORD bfOffBits; }; +struct tagFONTSIGNATURE{ DWORD fsUsb[4]; DWORD fsCsb[2]; }; +struct tagCHARSETINFO{ UINT ciCharset; UINT ciACP; FONTSIGNATURE fs; }; +struct tagLOCALESIGNATURE{ DWORD lsUsb[4]; DWORD lsCsbDefault[2]; DWORD lsCsbSupported[2]; }; +struct tagHANDLETABLE{ HGDIOBJ objectHandle[1]; }; +struct tagMETARECORD{ DWORD rdSize; WORD rdFunction; WORD rdParm[1]; }; +struct tagMETAFILEPICT{ LONG mm; LONG xExt; LONG yExt; HMETAFILE hMF; }; +struct tagMETAHEADER{ WORD mtType; WORD mtHeaderSize; WORD mtVersion; DWORD mtSize; WORD mtNoObjects; DWORD mtMaxRecord; WORD mtNoParameters; }; +struct tagENHMETARECORD{ DWORD iType; DWORD nSize; DWORD dParm[1]; }; +struct tagENHMETAHEADER{ DWORD iType; DWORD nSize; RECTL rclBounds; RECTL rclFrame; DWORD dSignature; DWORD nVersion; DWORD nBytes; DWORD nRecords; WORD nHandles; WORD sReserved; DWORD nDescription; DWORD offDescription; DWORD nPalEntries; SIZEL szlDevice; SIZEL szlMillimeters; DWORD cbPixelFormat; DWORD offPixelFormat; DWORD bOpenGL; SIZEL szlMicrometers; }; +struct tagTEXTMETRICA{ LONG tmHeight; LONG tmAscent; LONG tmDescent; LONG tmInternalLeading; LONG tmExternalLeading; LONG tmAveCharWidth; LONG tmMaxCharWidth; LONG tmWeight; LONG tmOverhang; LONG tmDigitizedAspectX; LONG tmDigitizedAspectY; BYTE tmFirstChar; BYTE tmLastChar; BYTE tmDefaultChar; BYTE tmBreakChar; BYTE tmItalic; BYTE tmUnderlined; BYTE tmStruckOut; BYTE tmPitchAndFamily; BYTE tmCharSet; }; +struct tagTEXTMETRICW{ LONG tmHeight; LONG tmAscent; LONG tmDescent; LONG tmInternalLeading; LONG tmExternalLeading; LONG tmAveCharWidth; LONG tmMaxCharWidth; LONG tmWeight; LONG tmOverhang; LONG tmDigitizedAspectX; LONG tmDigitizedAspectY; WCHAR tmFirstChar; WCHAR tmLastChar; WCHAR tmDefaultChar; WCHAR tmBreakChar; BYTE tmItalic; BYTE tmUnderlined; BYTE tmStruckOut; BYTE tmPitchAndFamily; BYTE tmCharSet; }; +struct tagNEWTEXTMETRICA{ LONG tmHeight; LONG tmAscent; LONG tmDescent; LONG tmInternalLeading; LONG tmExternalLeading; LONG tmAveCharWidth; LONG tmMaxCharWidth; LONG tmWeight; LONG tmOverhang; LONG tmDigitizedAspectX; LONG tmDigitizedAspectY; BYTE tmFirstChar; BYTE tmLastChar; BYTE tmDefaultChar; BYTE tmBreakChar; BYTE tmItalic; BYTE tmUnderlined; BYTE tmStruckOut; BYTE tmPitchAndFamily; BYTE tmCharSet; DWORD ntmFlags; UINT ntmSizeEM; UINT ntmCellHeight; UINT ntmAvgWidth; }; +struct tagNEWTEXTMETRICW{ LONG tmHeight; LONG tmAscent; LONG tmDescent; LONG tmInternalLeading; LONG tmExternalLeading; LONG tmAveCharWidth; LONG tmMaxCharWidth; LONG tmWeight; LONG tmOverhang; LONG tmDigitizedAspectX; LONG tmDigitizedAspectY; WCHAR tmFirstChar; WCHAR tmLastChar; WCHAR tmDefaultChar; WCHAR tmBreakChar; BYTE tmItalic; BYTE tmUnderlined; BYTE tmStruckOut; BYTE tmPitchAndFamily; BYTE tmCharSet; DWORD ntmFlags; UINT ntmSizeEM; UINT ntmCellHeight; UINT ntmAvgWidth; }; +struct tagNEWTEXTMETRICEXA{ NEWTEXTMETRICA ntmTm; FONTSIGNATURE ntmFontSig; }; +struct tagNEWTEXTMETRICEXW{ NEWTEXTMETRICW ntmTm; FONTSIGNATURE ntmFontSig; }; +struct tagPELARRAY{ LONG paXCount; LONG paYCount; LONG paXExt; LONG paYExt; BYTE paRGBs; }; +struct tagLOGBRUSH{ UINT lbStyle; COLORREF lbColor; ULONG_PTR lbHatch; }; +struct tagLOGBRUSH32{ UINT lbStyle; COLORREF lbColor; ULONG lbHatch; }; +struct tagLOGPEN{ UINT lopnStyle; POINT lopnWidth; COLORREF lopnColor; }; +struct tagEXTLOGPEN{ DWORD elpPenStyle; DWORD elpWidth; UINT elpBrushStyle; COLORREF elpColor; ULONG_PTR elpHatch; DWORD elpNumEntries; DWORD elpStyleEntry[1]; }; +struct tagEXTLOGPEN32{ DWORD elpPenStyle; DWORD elpWidth; UINT elpBrushStyle; COLORREF elpColor; ULONG elpHatch; DWORD elpNumEntries; DWORD elpStyleEntry[1]; }; +struct tagPALETTEENTRY{ BYTE peRed; BYTE peGreen; BYTE peBlue; BYTE peFlags; }; +struct tagLOGPALETTE{ WORD palVersion; WORD palNumEntries; PALETTEENTRY palPalEntry[1]; }; +struct tagLOGFONTA{ LONG lfHeight; LONG lfWidth; LONG lfEscapement; LONG lfOrientation; LONG lfWeight; BYTE lfItalic; BYTE lfUnderline; BYTE lfStrikeOut; BYTE lfCharSet; BYTE lfOutPrecision; BYTE lfClipPrecision; BYTE lfQuality; BYTE lfPitchAndFamily; CHAR lfFaceName[32]; }; +struct tagLOGFONTW{ LONG lfHeight; LONG lfWidth; LONG lfEscapement; LONG lfOrientation; LONG lfWeight; BYTE lfItalic; BYTE lfUnderline; BYTE lfStrikeOut; BYTE lfCharSet; BYTE lfOutPrecision; BYTE lfClipPrecision; BYTE lfQuality; BYTE lfPitchAndFamily; WCHAR lfFaceName[32]; }; +struct tagENUMLOGFONTA{ LOGFONTA elfLogFont; BYTE elfFullName[64]; BYTE elfStyle[32]; }; +struct tagENUMLOGFONTW{ LOGFONTW elfLogFont; WCHAR elfFullName[64]; WCHAR elfStyle[32]; }; +struct tagENUMLOGFONTEXA{ LOGFONTA elfLogFont; BYTE elfFullName[64]; BYTE elfStyle[32]; BYTE elfScript[32]; }; +struct tagENUMLOGFONTEXW{ LOGFONTW elfLogFont; WCHAR elfFullName[64]; WCHAR elfStyle[32]; WCHAR elfScript[32]; }; +struct tagPANOSE{ BYTE bFamilyType; BYTE bSerifStyle; BYTE bWeight; BYTE bProportion; BYTE bContrast; BYTE bStrokeVariation; BYTE bArmStyle; BYTE bLetterform; BYTE bMidline; BYTE bXHeight; }; +struct tagEXTLOGFONTA{ LOGFONTA elfLogFont; BYTE elfFullName[64]; BYTE elfStyle[32]; DWORD elfVersion; DWORD elfStyleSize; DWORD elfMatch; DWORD elfReserved; BYTE elfVendorId[4]; DWORD elfCulture; PANOSE elfPanose; }; +struct tagEXTLOGFONTW{ LOGFONTW elfLogFont; WCHAR elfFullName[64]; WCHAR elfStyle[32]; DWORD elfVersion; DWORD elfStyleSize; DWORD elfMatch; DWORD elfReserved; BYTE elfVendorId[4]; DWORD elfCulture; PANOSE elfPanose; }; +struct tagPOLYTEXTA{ int x; int y; UINT n; LPCSTR lpstr; UINT uiFlags; RECT rcl; int* pdx; }; +struct tagPOLYTEXTW{ int x; int y; UINT n; LPCWSTR lpstr; UINT uiFlags; RECT rcl; int* pdx; }; +struct tagPOINTFX{ FIXED x; FIXED y; }; +struct tagTTPOLYCURVE{ WORD wType; WORD cpfx; POINTFX apfx[1]; }; +struct tagTTPOLYGONHEADER{ DWORD cb; DWORD dwType; POINTFX pfxStart; }; +struct tagGCP_RESULTSA{ DWORD lStructSize; LPSTR lpOutString; UINT* lpOrder; int* lpDx; int* lpCaretPos; LPSTR lpClass; LPWSTR lpGlyphs; UINT nGlyphs; int nMaxFit; }; +struct tagGCP_RESULTSW{ DWORD lStructSize; LPWSTR lpOutString; UINT* lpOrder; int* lpDx; int* lpCaretPos; LPSTR lpClass; LPWSTR lpGlyphs; UINT nGlyphs; int nMaxFit; }; +struct tagPIXELFORMATDESCRIPTOR{ WORD nSize; WORD nVersion; DWORD dwFlags; BYTE iPixelType; BYTE cColorBits; BYTE cRedBits; BYTE cRedShift; BYTE cGreenBits; BYTE cGreenShift; BYTE cBlueBits; BYTE cBlueShift; BYTE cAlphaBits; BYTE cAlphaShift; BYTE cAccumBits; BYTE cAccumRedBits; BYTE cAccumGreenBits; BYTE cAccumBlueBits; BYTE cAccumAlphaBits; BYTE cDepthBits; BYTE cStencilBits; BYTE cAuxBuffers; BYTE iLayerType; BYTE bReserved; DWORD dwLayerMask; DWORD dwVisibleMask; DWORD dwDamageMask; }; +struct tagWCRANGE{ WCHAR wcLow; USHORT cGlyphs; }; +struct tagGLYPHSET{ DWORD cbThis; DWORD flAccel; DWORD cGlyphsSupported; DWORD cRanges; WCRANGE ranges[1]; }; +struct tagDESIGNVECTOR{ DWORD dvReserved; DWORD dvNumAxes; LONG dvValues[16]; }; +struct tagAXISINFOA{ LONG axMinValue; LONG axMaxValue; BYTE axAxisName[16]; }; +struct tagAXISINFOW{ LONG axMinValue; LONG axMaxValue; WCHAR axAxisName[16]; }; +struct tagAXESLISTA{ DWORD axlReserved; DWORD axlNumAxes; AXISINFOA axlAxisInfo[16]; }; +struct tagAXESLISTW{ DWORD axlReserved; DWORD axlNumAxes; AXISINFOW axlAxisInfo[16]; }; +struct tagENUMLOGFONTEXDVA{ ENUMLOGFONTEXA elfEnumLogfontEx; DESIGNVECTOR elfDesignVector; }; +struct tagENUMLOGFONTEXDVW{ ENUMLOGFONTEXW elfEnumLogfontEx; DESIGNVECTOR elfDesignVector; }; +struct tagENUMTEXTMETRICA{ NEWTEXTMETRICEXA etmNewTextMetricEx; AXESLISTA etmAxesList; }; +struct tagENUMTEXTMETRICW{ NEWTEXTMETRICEXW etmNewTextMetricEx; AXESLISTW etmAxesList; }; +struct tagDIBSECTION{ BITMAP dsBm; BITMAPINFOHEADER dsBmih; DWORD dsBitfields[3]; HANDLE dshSection; DWORD dsOffset; }; +struct tagCOLORADJUSTMENT{ WORD caSize; WORD caFlags; WORD caIlluminantIndex; WORD caRedGamma; WORD caGreenGamma; WORD caBlueGamma; WORD caReferenceBlack; WORD caReferenceWhite; SHORT caContrast; SHORT caBrightness; SHORT caColorfulness; SHORT caRedGreenTint; }; +struct tagKERNINGPAIR{ WORD wFirst; WORD wSecond; int iKernAmount; }; +struct tagEMR{ DWORD iType; DWORD nSize; }; +struct tagEMRTEXT{ POINTL ptlReference; DWORD nChars; DWORD offString; DWORD fOptions; RECTL rcl; DWORD offDx; }; +struct tagABORTPATH{ EMR emr; }; +struct tagEMRSELECTCLIPPATH{ EMR emr; DWORD iMode; }; +struct tagEMRSETMITERLIMIT{ EMR emr; FLOAT eMiterLimit; }; +struct tagEMRRESTOREDC{ EMR emr; LONG iRelative; }; +struct tagEMRSETARCDIRECTION{ EMR emr; DWORD iArcDirection; }; +struct tagEMRSETMAPPERFLAGS{ EMR emr; DWORD dwFlags; }; +struct tagEMRSETTEXTCOLOR{ EMR emr; COLORREF crColor; }; +struct tagEMRSELECTOBJECT{ EMR emr; DWORD ihObject; }; +struct tagEMRSELECTPALETTE{ EMR emr; DWORD ihPal; }; +struct tagEMRRESIZEPALETTE{ EMR emr; DWORD ihPal; DWORD cEntries; }; +struct tagEMRSETPALETTEENTRIES{ EMR emr; DWORD ihPal; DWORD iStart; DWORD cEntries; PALETTEENTRY aPalEntries[1]; }; +struct tagEMRSETCOLORADJUSTMENT{ EMR emr; COLORADJUSTMENT ColorAdjustment; }; +struct tagEMRGDICOMMENT{ EMR emr; DWORD cbData; BYTE Data[1]; }; +struct tagEMREOF{ EMR emr; DWORD nPalEntries; DWORD offPalEntries; DWORD nSizeLast; }; +struct tagEMRLINETO{ EMR emr; POINTL ptl; }; +struct tagEMROFFSETCLIPRGN{ EMR emr; POINTL ptlOffset; }; +struct tagEMRFILLPATH{ EMR emr; RECTL rclBounds; }; +struct tagEMREXCLUDECLIPRECT{ EMR emr; RECTL rclClip; }; +struct tagEMRSETVIEWPORTORGEX{ EMR emr; POINTL ptlOrigin; }; +struct tagEMRSETVIEWPORTEXTEX{ EMR emr; SIZEL szlExtent; }; +struct tagEMRSCALEVIEWPORTEXTEX{ EMR emr; LONG xNum; LONG xDenom; LONG yNum; LONG yDenom; }; +struct tagEMRSETWORLDTRANSFORM{ EMR emr; XFORM xform; }; +struct tagEMRMODIFYWORLDTRANSFORM{ EMR emr; XFORM xform; DWORD iMode; }; +struct tagEMRSETPIXELV{ EMR emr; POINTL ptlPixel; COLORREF crColor; }; +struct tagEMREXTFLOODFILL{ EMR emr; POINTL ptlStart; COLORREF crColor; DWORD iMode; }; +struct tagEMRELLIPSE{ EMR emr; RECTL rclBox; }; +struct tagEMRROUNDRECT{ EMR emr; RECTL rclBox; SIZEL szlCorner; }; +struct tagEMRARC{ EMR emr; RECTL rclBox; POINTL ptlStart; POINTL ptlEnd; }; +struct tagEMRANGLEARC{ EMR emr; POINTL ptlCenter; DWORD nRadius; FLOAT eStartAngle; FLOAT eSweepAngle; }; +struct tagEMRPOLYLINE{ EMR emr; RECTL rclBounds; DWORD cptl; POINTL aptl[1]; }; +struct tagEMRPOLYLINE16{ EMR emr; RECTL rclBounds; DWORD cpts; POINTS apts[1]; }; +struct tagEMRPOLYDRAW{ EMR emr; RECTL rclBounds; DWORD cptl; POINTL aptl[1]; BYTE abTypes[1]; }; +struct tagEMRPOLYDRAW16{ EMR emr; RECTL rclBounds; DWORD cpts; POINTS apts[1]; BYTE abTypes[1]; }; +struct tagEMRPOLYPOLYLINE{ EMR emr; RECTL rclBounds; DWORD nPolys; DWORD cptl; DWORD aPolyCounts[1]; POINTL aptl[1]; }; +struct tagEMRPOLYPOLYLINE16{ EMR emr; RECTL rclBounds; DWORD nPolys; DWORD cpts; DWORD aPolyCounts[1]; POINTS apts[1]; }; +struct tagEMRINVERTRGN{ EMR emr; RECTL rclBounds; DWORD cbRgnData; BYTE RgnData[1]; }; +struct tagEMRFILLRGN{ EMR emr; RECTL rclBounds; DWORD cbRgnData; DWORD ihBrush; BYTE RgnData[1]; }; +struct tagEMRFRAMERGN{ EMR emr; RECTL rclBounds; DWORD cbRgnData; DWORD ihBrush; SIZEL szlStroke; BYTE RgnData[1]; }; +struct tagEMREXTSELECTCLIPRGN{ EMR emr; DWORD cbRgnData; DWORD iMode; BYTE RgnData[1]; }; +struct tagEMREXTTEXTOUTA{ EMR emr; RECTL rclBounds; DWORD iGraphicsMode; FLOAT exScale; FLOAT eyScale; EMRTEXT emrtext; }; +struct tagEMRPOLYTEXTOUTA{ EMR emr; RECTL rclBounds; DWORD iGraphicsMode; FLOAT exScale; FLOAT eyScale; LONG cStrings; EMRTEXT aemrtext[1]; }; +struct tagEMRBITBLT{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG cxDest; LONG cyDest; DWORD dwRop; LONG xSrc; LONG ySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; }; +struct tagEMRSTRETCHBLT{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG cxDest; LONG cyDest; DWORD dwRop; LONG xSrc; LONG ySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; LONG cxSrc; LONG cySrc; }; +struct tagEMRMASKBLT{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG cxDest; LONG cyDest; DWORD dwRop; LONG xSrc; LONG ySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; LONG xMask; LONG yMask; DWORD iUsageMask; DWORD offBmiMask; DWORD cbBmiMask; DWORD offBitsMask; DWORD cbBitsMask; }; +struct tagEMRPLGBLT{ EMR emr; RECTL rclBounds; POINTL aptlDest[3]; LONG xSrc; LONG ySrc; LONG cxSrc; LONG cySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; LONG xMask; LONG yMask; DWORD iUsageMask; DWORD offBmiMask; DWORD cbBmiMask; DWORD offBitsMask; DWORD cbBitsMask; }; +struct tagEMRSETDIBITSTODEVICE{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG xSrc; LONG ySrc; LONG cxSrc; LONG cySrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; DWORD iUsageSrc; DWORD iStartScan; DWORD cScans; }; +struct tagEMRSTRETCHDIBITS{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG xSrc; LONG ySrc; LONG cxSrc; LONG cySrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; DWORD iUsageSrc; DWORD dwRop; LONG cxDest; LONG cyDest; }; +struct tagEMREXTCREATEFONTINDIRECTW{ EMR emr; DWORD ihFont; EXTLOGFONTW elfw; }; +struct tagEMRCREATEPALETTE{ EMR emr; DWORD ihPal; LOGPALETTE lgpl; }; +struct tagEMRCREATEPEN{ EMR emr; DWORD ihPen; LOGPEN lopn; }; +struct tagEMREXTCREATEPEN{ EMR emr; DWORD ihPen; DWORD offBmi; DWORD cbBmi; DWORD offBits; DWORD cbBits; EXTLOGPEN32 elp; }; +struct tagEMRCREATEBRUSHINDIRECT{ EMR emr; DWORD ihBrush; LOGBRUSH32 lb; }; +struct tagEMRCREATEMONOBRUSH{ EMR emr; DWORD ihBrush; DWORD iUsage; DWORD offBmi; DWORD cbBmi; DWORD offBits; DWORD cbBits; }; +struct tagEMRCREATEDIBPATTERNBRUSHPT{ EMR emr; DWORD ihBrush; DWORD iUsage; DWORD offBmi; DWORD cbBmi; DWORD offBits; DWORD cbBits; }; +struct tagEMRFORMAT{ DWORD dSignature; DWORD nVersion; DWORD cbData; DWORD offData; }; +struct tagEMRGLSRECORD{ EMR emr; DWORD cbData; BYTE Data[1]; }; +struct tagEMRGLSBOUNDEDRECORD{ EMR emr; RECTL rclBounds; DWORD cbData; BYTE Data[1]; }; +struct tagEMRPIXELFORMAT{ EMR emr; PIXELFORMATDESCRIPTOR pfd; }; +struct tagEMRCREATECOLORSPACE{ EMR emr; DWORD ihCS; LOGCOLORSPACEA lcs; }; +struct tagEMRSETCOLORSPACE{ EMR emr; DWORD ihCS; }; +struct tagEMREXTESCAPE{ EMR emr; INT iEscape; INT cbEscData; BYTE EscData[1]; }; +struct tagEMRNAMEDESCAPE{ EMR emr; INT iEscape; INT cbDriver; INT cbEscData; BYTE EscData[1]; }; +struct tagEMRSETICMPROFILE{ EMR emr; DWORD dwFlags; DWORD cbName; DWORD cbData; BYTE Data[1]; }; +struct tagEMRCREATECOLORSPACEW{ EMR emr; DWORD ihCS; LOGCOLORSPACEW lcs; DWORD dwFlags; DWORD cbData; BYTE Data[1]; }; +struct tagCOLORMATCHTOTARGET{ EMR emr; DWORD dwAction; DWORD dwFlags; DWORD cbName; DWORD cbData; BYTE Data[1]; }; +struct tagCOLORCORRECTPALETTE{ EMR emr; DWORD ihPalette; DWORD nFirstEntry; DWORD nPalEntries; DWORD nReserved; }; +struct tagEMRALPHABLEND{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG cxDest; LONG cyDest; DWORD dwRop; LONG xSrc; LONG ySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; LONG cxSrc; LONG cySrc; }; +struct tagEMRGRADIENTFILL{ EMR emr; RECTL rclBounds; DWORD nVer; DWORD nTri; ULONG ulMode; TRIVERTEX Ver[1]; }; +struct tagEMRTRANSPARENTBLT{ EMR emr; RECTL rclBounds; LONG xDest; LONG yDest; LONG cxDest; LONG cyDest; DWORD dwRop; LONG xSrc; LONG ySrc; XFORM xformSrc; COLORREF crBkColorSrc; DWORD iUsageSrc; DWORD offBmiSrc; DWORD cbBmiSrc; DWORD offBitsSrc; DWORD cbBitsSrc; LONG cxSrc; LONG cySrc; }; +struct tagLAYERPLANEDESCRIPTOR{ WORD nSize; WORD nVersion; DWORD dwFlags; BYTE iPixelType; BYTE cColorBits; BYTE cRedBits; BYTE cRedShift; BYTE cGreenBits; BYTE cGreenShift; BYTE cBlueBits; BYTE cBlueShift; BYTE cAlphaBits; BYTE cAlphaShift; BYTE cAccumBits; BYTE cAccumRedBits; BYTE cAccumGreenBits; BYTE cAccumBlueBits; BYTE cAccumAlphaBits; BYTE cDepthBits; BYTE cStencilBits; BYTE cAuxBuffers; BYTE iLayerPlane; BYTE bReserved; COLORREF crTransparent; }; +struct tagCBT_CREATEWNDA{ tagCREATESTRUCTA* lpcs; HWND hwndInsertAfter; }; +struct tagCREATESTRUCTA{ LPVOID lpCreateParams; HINSTANCE hInstance; HMENU hMenu; HWND hwndParent; int cy; int cx; int y; int x; LONG style; LPCSTR lpszName; LPCSTR lpszClass; DWORD dwExStyle; }; +struct tagCBT_CREATEWNDW{ tagCREATESTRUCTW* lpcs; HWND hwndInsertAfter; }; +struct tagCREATESTRUCTW{ LPVOID lpCreateParams; HINSTANCE hInstance; HMENU hMenu; HWND hwndParent; int cy; int cx; int y; int x; LONG style; LPCWSTR lpszName; LPCWSTR lpszClass; DWORD dwExStyle; }; +struct tagCBTACTIVATESTRUCT{ BOOL fMouse; HWND hWndActive; }; +struct tagWTSSESSION_NOTIFICATION{ DWORD cbSize; DWORD dwSessionId; }; +struct tagEVENTMSG{ UINT message; UINT paramL; UINT paramH; DWORD time; HWND hwnd; }; +struct tagCWPSTRUCT{ LPARAM lParam; WPARAM wParam; UINT message; HWND hwnd; }; +struct tagCWPRETSTRUCT{ LRESULT lResult; LPARAM lParam; WPARAM wParam; UINT message; HWND hwnd; }; +struct tagKBDLLHOOKSTRUCT{ DWORD vkCode; DWORD scanCode; DWORD flags; DWORD time; ULONG_PTR dwExtraInfo; }; +struct tagMSLLHOOKSTRUCT{ POINT pt; DWORD mouseData; DWORD flags; DWORD time; ULONG_PTR dwExtraInfo; }; +struct tagDEBUGHOOKINFO{ DWORD idThread; DWORD idThreadInstaller; LPARAM lParam; WPARAM wParam; int code; }; +struct tagMOUSEHOOKSTRUCT{ POINT pt; HWND hwnd; UINT wHitTestCode; ULONG_PTR dwExtraInfo; }; +struct tagMOUSEHOOKSTRUCTEX{ DWORD mouseData; }; +struct tagHARDWAREHOOKSTRUCT{ HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam; }; +struct tagMOUSEMOVEPOINT{ int x; int y; DWORD time; ULONG_PTR dwExtraInfo; }; +struct tagUSEROBJECTFLAGS{ BOOL fInherit; BOOL fReserved; DWORD dwFlags; }; +struct tagWNDCLASSEXA{ UINT cbSize; UINT style; WNDPROC lpfnWndProc; int cbClsExtra; int cbWndExtra; HINSTANCE hInstance; HICON hIcon; HCURSOR hCursor; HBRUSH hbrBackground; LPCSTR lpszMenuName; LPCSTR lpszClassName; HICON hIconSm; }; +struct tagWNDCLASSEXW{ UINT cbSize; UINT style; WNDPROC lpfnWndProc; int cbClsExtra; int cbWndExtra; HINSTANCE hInstance; HICON hIcon; HCURSOR hCursor; HBRUSH hbrBackground; LPCWSTR lpszMenuName; LPCWSTR lpszClassName; HICON hIconSm; }; +struct tagWNDCLASSA{ UINT style; WNDPROC lpfnWndProc; int cbClsExtra; int cbWndExtra; HINSTANCE hInstance; HICON hIcon; HCURSOR hCursor; HBRUSH hbrBackground; LPCSTR lpszMenuName; LPCSTR lpszClassName; }; +struct tagWNDCLASSW{ UINT style; WNDPROC lpfnWndProc; int cbClsExtra; int cbWndExtra; HINSTANCE hInstance; HICON hIcon; HCURSOR hCursor; HBRUSH hbrBackground; LPCWSTR lpszMenuName; LPCWSTR lpszClassName; }; +struct tagMSG{ HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam; DWORD time; POINT pt; }; +struct tagMINMAXINFO{ POINT ptReserved; POINT ptMaxSize; POINT ptMaxPosition; POINT ptMinTrackSize; POINT ptMaxTrackSize; }; +struct tagCOPYDATASTRUCT{ ULONG_PTR dwData; DWORD cbData; PVOID lpData; }; +struct tagMDINEXTMENU{ HMENU hmenuIn; HMENU hmenuNext; HWND hwndNext; }; +struct tagWINDOWPOS{ HWND hwnd; HWND hwndInsertAfter; int x; int y; int cx; int cy; UINT flags; }; +struct tagNCCALCSIZE_PARAMS{ RECT rgrc[3]; PWINDOWPOS lppos; }; +struct tagTRACKMOUSEEVENT{ DWORD cbSize; DWORD dwFlags; HWND hwndTrack; DWORD dwHoverTime; }; +struct tagACCEL{ BYTE fVirt; WORD key; WORD cmd; }; +struct tagPAINTSTRUCT{ HDC hdc; BOOL fErase; RECT rcPaint; BOOL fRestore; BOOL fIncUpdate; BYTE rgbReserved[32]; }; +struct tagWINDOWPLACEMENT{ UINT length; UINT flags; UINT showCmd; POINT ptMinPosition; POINT ptMaxPosition; RECT rcNormalPosition; }; +struct tagNMHDR{ HWND hwndFrom; UINT_PTR idFrom; UINT code; }; +struct tagSTYLESTRUCT{ DWORD styleOld; DWORD styleNew; }; +struct tagMEASUREITEMSTRUCT{ UINT CtlType; UINT CtlID; UINT itemID; UINT itemWidth; UINT itemHeight; ULONG_PTR itemData; }; +struct tagDRAWITEMSTRUCT{ UINT CtlType; UINT CtlID; UINT itemID; UINT itemAction; UINT itemState; HWND hwndItem; HDC hDC; RECT rcItem; ULONG_PTR itemData; }; +struct tagDELETEITEMSTRUCT{ UINT CtlType; UINT CtlID; UINT itemID; HWND hwndItem; ULONG_PTR itemData; }; +struct tagCOMPAREITEMSTRUCT{ UINT CtlType; UINT CtlID; HWND hwndItem; UINT itemID1; ULONG_PTR itemData1; UINT itemID2; ULONG_PTR itemData2; DWORD dwLocaleId; }; +struct tagUPDATELAYEREDWINDOWINFO{ DWORD cbSize; HDC hdcDst; POINT* pptDst; SIZE* psize; HDC hdcSrc; POINT* pptSrc; COLORREF crKey; BLENDFUNCTION* pblend; DWORD dwFlags; RECT* prcDirty; }; +struct tagGETCLIPBMETADATA{ UINT Version; BOOL IsDelayRendered; BOOL IsSynthetic; }; +struct tagMOUSEINPUT{ LONG dx; LONG dy; DWORD mouseData; DWORD dwFlags; DWORD time; ULONG_PTR dwExtraInfo; }; +struct tagKEYBDINPUT{ WORD wVk; WORD wScan; DWORD dwFlags; DWORD time; ULONG_PTR dwExtraInfo; }; +struct tagHARDWAREINPUT{ DWORD uMsg; WORD wParamL; WORD wParamH; }; +struct tagINPUT{ DWORD type; }; +struct tagTOUCHINPUT{ LONG x; LONG y; HANDLE hSource; DWORD dwID; DWORD dwFlags; DWORD dwMask; DWORD dwTime; ULONG_PTR dwExtraInfo; DWORD cxContact; DWORD cyContact; }; +enum tagPOINTER_INPUT_TYPE{ PT_POINTER = 1, PT_TOUCH = 2, PT_PEN = 3, PT_MOUSE = 4, PT_TOUCHPAD = 5 }; +enum tagPOINTER_BUTTON_CHANGE_TYPE{ POINTER_CHANGE_NONE = 0, POINTER_CHANGE_FIRSTBUTTON_DOWN = 1, POINTER_CHANGE_FIRSTBUTTON_UP = 2, POINTER_CHANGE_SECONDBUTTON_DOWN = 3, POINTER_CHANGE_SECONDBUTTON_UP = 4, POINTER_CHANGE_THIRDBUTTON_DOWN = 5, POINTER_CHANGE_THIRDBUTTON_UP = 6, POINTER_CHANGE_FOURTHBUTTON_DOWN = 7, POINTER_CHANGE_FOURTHBUTTON_UP = 8, POINTER_CHANGE_FIFTHBUTTON_DOWN = 9, POINTER_CHANGE_FIFTHBUTTON_UP = 10 }; +struct tagPOINTER_INFO{ POINTER_INPUT_TYPE pointerType; UINT32 pointerId; UINT32 frameId; POINTER_FLAGS pointerFlags; HANDLE sourceDevice; HWND hwndTarget; POINT ptPixelLocation; POINT ptHimetricLocation; POINT ptPixelLocationRaw; POINT ptHimetricLocationRaw; DWORD dwTime; UINT32 historyCount; INT32 InputData; DWORD dwKeyStates; UINT64 PerformanceCount; POINTER_BUTTON_CHANGE_TYPE ButtonChangeType; }; +struct tagPOINTER_TOUCH_INFO{ POINTER_INFO pointerInfo; TOUCH_FLAGS touchFlags; TOUCH_MASK touchMask; RECT rcContact; RECT rcContactRaw; UINT32 orientation; UINT32 pressure; }; +struct tagPOINTER_PEN_INFO{ POINTER_INFO pointerInfo; PEN_FLAGS penFlags; PEN_MASK penMask; UINT32 pressure; UINT32 rotation; INT32 tiltX; INT32 tiltY; }; +struct tagUSAGE_PROPERTIES{ USHORT level; USHORT page; USHORT usage; INT32 logicalMinimum; INT32 logicalMaximum; USHORT unit; USHORT exponent; BYTE count; INT32 physicalMinimum; INT32 physicalMaximum; }; +struct tagPOINTER_TYPE_INFO{ POINTER_INPUT_TYPE type; }; +struct tagINPUT_INJECTION_VALUE{ USHORT page; USHORT usage; INT32 value; USHORT index; }; +struct tagTOUCH_HIT_TESTING_PROXIMITY_EVALUATION{ UINT16 score; POINT adjustedPoint; }; +struct tagTOUCH_HIT_TESTING_INPUT{ UINT32 pointerId; POINT point; RECT boundingBox; RECT nonOccludedBoundingBox; UINT32 orientation; }; +enum tagFEEDBACK_TYPE{ FEEDBACK_TOUCH_CONTACTVISUALIZATION = 1, FEEDBACK_PEN_BARRELVISUALIZATION = 2, FEEDBACK_PEN_TAP = 3, FEEDBACK_PEN_DOUBLETAP = 4, FEEDBACK_PEN_PRESSANDHOLD = 5, FEEDBACK_PEN_RIGHTTAP = 6, FEEDBACK_TOUCH_TAP = 7, FEEDBACK_TOUCH_DOUBLETAP = 8, FEEDBACK_TOUCH_PRESSANDHOLD = 9, FEEDBACK_TOUCH_RIGHTTAP = 10, FEEDBACK_GESTURE_PRESSANDTAP = 11, FEEDBACK_MAX = 4294967295 }; +struct tagINPUT_TRANSFORM{ }; +struct tagLASTINPUTINFO{ UINT cbSize; DWORD dwTime; }; +struct tagTPMPARAMS{ UINT cbSize; RECT rcExclude; }; +struct tagMENUINFO{ DWORD cbSize; DWORD fMask; DWORD dwStyle; UINT cyMax; HBRUSH hbrBack; DWORD dwContextHelpID; ULONG_PTR dwMenuData; }; +struct tagMENUGETOBJECTINFO{ DWORD dwFlags; UINT uPos; HMENU hmenu; PVOID riid; PVOID pvObj; }; +struct tagMENUITEMINFOA{ UINT cbSize; UINT fMask; UINT fType; UINT fState; UINT wID; HMENU hSubMenu; HBITMAP hbmpChecked; HBITMAP hbmpUnchecked; ULONG_PTR dwItemData; LPSTR dwTypeData; UINT cch; HBITMAP hbmpItem; }; +struct tagMENUITEMINFOW{ UINT cbSize; UINT fMask; UINT fType; UINT fState; UINT wID; HMENU hSubMenu; HBITMAP hbmpChecked; HBITMAP hbmpUnchecked; ULONG_PTR dwItemData; LPWSTR dwTypeData; UINT cch; HBITMAP hbmpItem; }; +struct tagDROPSTRUCT{ HWND hwndSource; HWND hwndSink; DWORD wFmt; ULONG_PTR dwData; POINT ptDrop; DWORD dwControlData; }; +struct tagDRAWTEXTPARAMS{ UINT cbSize; int iTabLength; int iLeftMargin; int iRightMargin; UINT uiLengthDrawn; }; +struct tagHELPINFO{ UINT cbSize; int iContextType; int iCtrlId; HANDLE hItemHandle; DWORD_PTR dwContextId; POINT MousePos; }; +struct tagMSGBOXPARAMSA{ UINT cbSize; HWND hwndOwner; HINSTANCE hInstance; LPCSTR lpszText; LPCSTR lpszCaption; DWORD dwStyle; LPCSTR lpszIcon; DWORD_PTR dwContextHelpId; MSGBOXCALLBACK lpfnMsgBoxCallback; DWORD dwLanguageId; }; +struct tagMSGBOXPARAMSW{ UINT cbSize; HWND hwndOwner; HINSTANCE hInstance; LPCWSTR lpszText; LPCWSTR lpszCaption; DWORD dwStyle; LPCWSTR lpszIcon; DWORD_PTR dwContextHelpId; MSGBOXCALLBACK lpfnMsgBoxCallback; DWORD dwLanguageId; }; +struct tagCURSORSHAPE{ int xHotSpot; int yHotSpot; int cx; int cy; int cbWidth; BYTE Planes; BYTE BitsPixel; }; +struct tagSCROLLINFO{ UINT cbSize; UINT fMask; int nMin; int nMax; UINT nPage; int nPos; int nTrackPos; }; +struct tagMDICREATESTRUCTA{ LPCSTR szClass; LPCSTR szTitle; HANDLE hOwner; int x; int y; int cx; int cy; DWORD style; LPARAM lParam; }; +struct tagMDICREATESTRUCTW{ LPCWSTR szClass; LPCWSTR szTitle; HANDLE hOwner; int x; int y; int cx; int cy; DWORD style; LPARAM lParam; }; +struct tagCLIENTCREATESTRUCT{ HANDLE hWindowMenu; UINT idFirstChild; }; +struct tagMULTIKEYHELPA{ DWORD mkSize; CHAR mkKeylist; CHAR szKeyphrase[1]; }; +struct tagMULTIKEYHELPW{ DWORD mkSize; WCHAR mkKeylist; WCHAR szKeyphrase[1]; }; +struct tagHELPWININFOA{ int wStructSize; int x; int y; int dx; int dy; int wMax; CHAR rgchMember[2]; }; +struct tagHELPWININFOW{ int wStructSize; int x; int y; int dx; int dy; int wMax; WCHAR rgchMember[2]; }; +struct tagTouchPredictionParameters{ UINT cbSize; UINT dwLatency; UINT dwSampleTime; UINT bUseHWTimeStamp; }; +enum tagHANDEDNESS{ HANDEDNESS_LEFT = 0, HANDEDNESS_RIGHT = 1 }; +struct tagNONCLIENTMETRICSA{ UINT cbSize; int iBorderWidth; int iScrollWidth; int iScrollHeight; int iCaptionWidth; int iCaptionHeight; LOGFONTA lfCaptionFont; int iSmCaptionWidth; int iSmCaptionHeight; LOGFONTA lfSmCaptionFont; int iMenuWidth; int iMenuHeight; LOGFONTA lfMenuFont; LOGFONTA lfStatusFont; LOGFONTA lfMessageFont; int iPaddedBorderWidth; }; +struct tagNONCLIENTMETRICSW{ UINT cbSize; int iBorderWidth; int iScrollWidth; int iScrollHeight; int iCaptionWidth; int iCaptionHeight; LOGFONTW lfCaptionFont; int iSmCaptionWidth; int iSmCaptionHeight; LOGFONTW lfSmCaptionFont; int iMenuWidth; int iMenuHeight; LOGFONTW lfMenuFont; LOGFONTW lfStatusFont; LOGFONTW lfMessageFont; int iPaddedBorderWidth; }; +struct tagMINIMIZEDMETRICS{ UINT cbSize; int iWidth; int iHorzGap; int iVertGap; int iArrange; }; +struct tagICONMETRICSA{ UINT cbSize; int iHorzSpacing; int iVertSpacing; int iTitleWrap; LOGFONTA lfFont; }; +struct tagICONMETRICSW{ UINT cbSize; int iHorzSpacing; int iVertSpacing; int iTitleWrap; LOGFONTW lfFont; }; +struct tagANIMATIONINFO{ UINT cbSize; int iMinAnimate; }; +struct tagSERIALKEYSA{ UINT cbSize; DWORD dwFlags; LPSTR lpszActivePort; LPSTR lpszPort; UINT iBaudRate; UINT iPortState; UINT iActive; }; +struct tagSERIALKEYSW{ UINT cbSize; DWORD dwFlags; LPWSTR lpszActivePort; LPWSTR lpszPort; UINT iBaudRate; UINT iPortState; UINT iActive; }; +struct tagHIGHCONTRASTA{ UINT cbSize; DWORD dwFlags; LPSTR lpszDefaultScheme; }; +struct tagHIGHCONTRASTW{ UINT cbSize; DWORD dwFlags; LPWSTR lpszDefaultScheme; }; +struct tagFILTERKEYS{ UINT cbSize; DWORD dwFlags; DWORD iWaitMSec; DWORD iDelayMSec; DWORD iRepeatMSec; DWORD iBounceMSec; }; +struct tagSTICKYKEYS{ UINT cbSize; DWORD dwFlags; }; +struct tagMOUSEKEYS{ UINT cbSize; DWORD dwFlags; DWORD iMaxSpeed; DWORD iTimeToMaxSpeed; DWORD iCtrlSpeed; DWORD dwReserved1; DWORD dwReserved2; }; +struct tagACCESSTIMEOUT{ UINT cbSize; DWORD dwFlags; DWORD iTimeOutMSec; }; +struct tagSOUNDSENTRYA{ UINT cbSize; DWORD dwFlags; DWORD iFSTextEffect; DWORD iFSTextEffectMSec; DWORD iFSTextEffectColorBits; DWORD iFSGrafEffect; DWORD iFSGrafEffectMSec; DWORD iFSGrafEffectColor; DWORD iWindowsEffect; DWORD iWindowsEffectMSec; LPSTR lpszWindowsEffectDLL; DWORD iWindowsEffectOrdinal; }; +struct tagSOUNDSENTRYW{ UINT cbSize; DWORD dwFlags; DWORD iFSTextEffect; DWORD iFSTextEffectMSec; DWORD iFSTextEffectColorBits; DWORD iFSGrafEffect; DWORD iFSGrafEffectMSec; DWORD iFSGrafEffectColor; DWORD iWindowsEffect; DWORD iWindowsEffectMSec; LPWSTR lpszWindowsEffectDLL; DWORD iWindowsEffectOrdinal; }; +struct tagTOGGLEKEYS{ UINT cbSize; DWORD dwFlags; }; +struct tagAUDIODESCRIPTION{ UINT cbSize; BOOL Enabled; LCID Locale; }; +struct tagMONITORINFO{ DWORD cbSize; RECT rcMonitor; RECT rcWork; DWORD dwFlags; }; +struct tagMONITORINFOEXA{ CHAR szDevice[32]; }; +struct tagMONITORINFOEXW{ WCHAR szDevice[32]; }; +struct tagGUITHREADINFO{ DWORD cbSize; DWORD flags; HWND hwndActive; HWND hwndFocus; HWND hwndCapture; HWND hwndMenuOwner; HWND hwndMoveSize; HWND hwndCaret; RECT rcCaret; }; +struct tagCURSORINFO{ DWORD cbSize; DWORD flags; HCURSOR hCursor; POINT ptScreenPos; }; +struct tagWINDOWINFO{ DWORD cbSize; RECT rcWindow; RECT rcClient; DWORD dwStyle; DWORD dwExStyle; DWORD dwWindowStatus; UINT cxWindowBorders; UINT cyWindowBorders; ATOM atomWindowType; WORD wCreatorVersion; }; +struct tagTITLEBARINFO{ DWORD cbSize; RECT rcTitleBar; DWORD rgstate[6]; }; +struct tagTITLEBARINFOEX{ DWORD cbSize; RECT rcTitleBar; DWORD rgstate[6]; RECT rgrect[6]; }; +struct tagMENUBARINFO{ DWORD cbSize; RECT rcBar; HMENU hMenu; HWND hwndMenu; BOOL fBarFocused : 1; BOOL fFocused : 1; BOOL fUnused : 30; }; +struct tagSCROLLBARINFO{ DWORD cbSize; RECT rcScrollBar; int dxyLineButton; int xyThumbTop; int xyThumbBottom; int reserved; DWORD rgstate[6]; }; +struct tagCOMBOBOXINFO{ DWORD cbSize; RECT rcItem; RECT rcButton; DWORD stateButton; HWND hwndCombo; HWND hwndItem; HWND hwndList; }; +struct tagALTTABINFO{ DWORD cbSize; int cItems; int cColumns; int cRows; int iColFocus; int iRowFocus; int cxItem; int cyItem; POINT ptStart; }; +struct tagRAWINPUTHEADER{ DWORD dwType; DWORD dwSize; HANDLE hDevice; WPARAM wParam; }; +struct tagRAWMOUSE{ USHORT usFlags; ULONG ulRawButtons; LONG lLastX; LONG lLastY; ULONG ulExtraInformation; }; +struct tagRAWKEYBOARD{ USHORT MakeCode; USHORT Flags; USHORT Reserved; USHORT VKey; UINT Message; ULONG ExtraInformation; }; +struct tagRAWHID{ DWORD dwSizeHid; DWORD dwCount; BYTE bRawData[1]; }; +struct tagRAWINPUT{ RAWINPUTHEADER header; 58744D6F364A6D7754746C38396C6F57674E62557341544E5978553D data; }; +struct tagRID_DEVICE_INFO_MOUSE{ DWORD dwId; DWORD dwNumberOfButtons; DWORD dwSampleRate; BOOL fHasHorizontalWheel; }; +struct tagRID_DEVICE_INFO_KEYBOARD{ DWORD dwType; DWORD dwSubType; DWORD dwKeyboardMode; DWORD dwNumberOfFunctionKeys; DWORD dwNumberOfIndicators; DWORD dwNumberOfKeysTotal; }; +struct tagRID_DEVICE_INFO_HID{ DWORD dwVendorId; DWORD dwProductId; DWORD dwVersionNumber; USHORT usUsagePage; USHORT usUsage; }; +struct tagRID_DEVICE_INFO{ DWORD cbSize; DWORD dwType; }; +struct tagRAWINPUTDEVICE{ USHORT usUsagePage; USHORT usUsage; DWORD dwFlags; HWND hwndTarget; }; +struct tagRAWINPUTDEVICELIST{ HANDLE hDevice; DWORD dwType; }; +enum tagPOINTER_DEVICE_TYPE{ POINTER_DEVICE_TYPE_INTEGRATED_PEN = 1, POINTER_DEVICE_TYPE_EXTERNAL_PEN = 2, POINTER_DEVICE_TYPE_TOUCH = 3, POINTER_DEVICE_TYPE_TOUCH_PAD = 4, POINTER_DEVICE_TYPE_MAX = 4294967295 }; +struct tagPOINTER_DEVICE_INFO{ DWORD displayOrientation; HANDLE device; POINTER_DEVICE_TYPE pointerDeviceType; HMONITOR monitor; ULONG startingCursorId; USHORT maxActiveContacts; WCHAR productString[520]; }; +struct tagPOINTER_DEVICE_PROPERTY{ INT32 logicalMin; INT32 logicalMax; INT32 physicalMin; INT32 physicalMax; UINT32 unit; UINT32 unitExponent; USHORT usagePageId; USHORT usageId; }; +enum tagPOINTER_DEVICE_CURSOR_TYPE{ POINTER_DEVICE_CURSOR_TYPE_UNKNOWN = 0, POINTER_DEVICE_CURSOR_TYPE_TIP = 1, POINTER_DEVICE_CURSOR_TYPE_ERASER = 2, POINTER_DEVICE_CURSOR_TYPE_MAX = 4294967295 }; +struct tagPOINTER_DEVICE_CURSOR_INFO{ UINT32 cursorId; POINTER_DEVICE_CURSOR_TYPE cursor; }; +struct tagCHANGEFILTERSTRUCT{ DWORD cbSize; DWORD ExtStatus; }; +struct tagGESTUREINFO{ UINT cbSize; DWORD dwFlags; DWORD dwID; HWND hwndTarget; POINTS ptsLocation; DWORD dwInstanceID; DWORD dwSequenceID; ULONGLONG ullArguments; UINT cbExtraArgs; }; +struct tagGESTURENOTIFYSTRUCT{ UINT cbSize; DWORD dwFlags; HWND hwndTarget; POINTS ptsLocation; DWORD dwInstanceID; }; +struct tagGESTURECONFIG{ DWORD dwID; DWORD dwWant; DWORD dwBlock; }; +enum tagINPUT_MESSAGE_DEVICE_TYPE{ IMDT_UNAVAILABLE = 0, IMDT_KEYBOARD = 1, IMDT_MOUSE = 2, IMDT_TOUCH = 4, IMDT_PEN = 8, IMDT_TOUCHPAD = 16 }; +enum tagINPUT_MESSAGE_ORIGIN_ID{ IMO_UNAVAILABLE = 0, IMO_HARDWARE = 1, IMO_INJECTED = 2, IMO_SYSTEM = 4 }; +struct tagINPUT_MESSAGE_SOURCE{ INPUT_MESSAGE_DEVICE_TYPE deviceType; INPUT_MESSAGE_ORIGIN_ID originId; }; +enum tagAR_STATE{ AR_ENABLED = 0, AR_DISABLED = 1, AR_SUPPRESSED = 2, AR_REMOTESESSION = 4, AR_MULTIMON = 8, AR_NOSENSOR = 16, AR_NOT_SUPPORTED = 32, AR_DOCKED = 64, AR_LAPTOP = 128 }; +struct tagVS_FIXEDFILEINFO{ DWORD dwSignature; DWORD dwStrucVersion; DWORD dwFileVersionMS; DWORD dwFileVersionLS; DWORD dwProductVersionMS; DWORD dwProductVersionLS; DWORD dwFileFlagsMask; DWORD dwFileFlags; DWORD dwFileOS; DWORD dwFileType; DWORD dwFileSubtype; DWORD dwFileDateMS; DWORD dwFileDateLS; }; +struct tagHSZPAIR{ HSZ hszSvc; HSZ hszTopic; }; +struct tagCONVCONTEXT{ UINT cb; UINT wFlags; UINT wCountryID; int iCodePage; DWORD dwLangID; DWORD dwSecurity; SECURITY_QUALITY_OF_SERVICE qos; }; +struct tagCONVINFO{ DWORD cb; DWORD_PTR hUser; HCONV hConvPartner; HSZ hszSvcPartner; HSZ hszServiceReq; HSZ hszTopic; HSZ hszItem; UINT wFmt; UINT wType; UINT wStatus; UINT wConvst; UINT wLastError; HCONVLIST hConvList; CONVCONTEXT ConvCtxt; HWND hwnd; HWND hwndPartner; }; +struct tagDDEML_MSG_HOOK_DATA{ UINT_PTR uiLo; UINT_PTR uiHi; DWORD cbData; DWORD Data[8]; }; +struct tagMONMSGSTRUCT{ UINT cb; HWND hwndTo; DWORD dwTime; HANDLE hTask; UINT wMsg; WPARAM wParam; LPARAM lParam; DDEML_MSG_HOOK_DATA dmhd; }; +struct tagMONCBSTRUCT{ UINT cb; DWORD dwTime; HANDLE hTask; DWORD dwRet; UINT wType; UINT wFmt; HCONV hConv; HSZ hsz1; HSZ hsz2; HDDEDATA hData; ULONG_PTR dwData1; ULONG_PTR dwData2; CONVCONTEXT cc; DWORD cbData; DWORD Data[8]; }; +struct tagMONHSZSTRUCTA{ UINT cb; BOOL fsAction; DWORD dwTime; HSZ hsz; HANDLE hTask; CHAR str[1]; }; +struct tagMONHSZSTRUCTW{ UINT cb; BOOL fsAction; DWORD dwTime; HSZ hsz; HANDLE hTask; WCHAR str[1]; }; +struct tagMONERRSTRUCT{ UINT cb; UINT wLastError; DWORD dwTime; HANDLE hTask; }; +struct tagMONLINKSTRUCT{ UINT cb; DWORD dwTime; HANDLE hTask; BOOL fEstablished; BOOL fNoData; HSZ hszSvc; HSZ hszTopic; HSZ hszItem; UINT wFmt; BOOL fServer; HCONV hConvServer; HCONV hConvClient; }; +struct tagMONCONVSTRUCT{ UINT cb; BOOL fConnect; DWORD dwTime; HANDLE hTask; HSZ hszSvc; HSZ hszTopic; HCONV hConvClient; HCONV hConvServer; }; +struct tagCRGB{ BYTE bRed; BYTE bGreen; BYTE bBlue; BYTE bExtra; }; +struct mmtime_tag{ UINT wType; 3471752B4B6A2B5631534C654333692F56762F67574179524144343D u; }; +struct tagMCI_GENERIC_PARMS{ DWORD_PTR dwCallback; }; +struct tagMCI_OPEN_PARMSA{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCSTR lpstrDeviceType; LPCSTR lpstrElementName; LPCSTR lpstrAlias; }; +struct tagMCI_OPEN_PARMSW{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCWSTR lpstrDeviceType; LPCWSTR lpstrElementName; LPCWSTR lpstrAlias; }; +struct tagMCI_PLAY_PARMS{ DWORD_PTR dwCallback; DWORD dwFrom; DWORD dwTo; }; +struct tagMCI_SEEK_PARMS{ DWORD_PTR dwCallback; DWORD dwTo; }; +struct tagMCI_STATUS_PARMS{ DWORD_PTR dwCallback; DWORD_PTR dwReturn; DWORD dwItem; DWORD dwTrack; }; +struct tagMCI_INFO_PARMSA{ DWORD_PTR dwCallback; LPSTR lpstrReturn; DWORD dwRetSize; }; +struct tagMCI_INFO_PARMSW{ DWORD_PTR dwCallback; LPWSTR lpstrReturn; DWORD dwRetSize; }; +struct tagMCI_GETDEVCAPS_PARMS{ DWORD_PTR dwCallback; DWORD dwReturn; DWORD dwItem; }; +struct tagMCI_SYSINFO_PARMSA{ DWORD_PTR dwCallback; LPSTR lpstrReturn; DWORD dwRetSize; DWORD dwNumber; UINT wDeviceType; }; +struct tagMCI_SYSINFO_PARMSW{ DWORD_PTR dwCallback; LPWSTR lpstrReturn; DWORD dwRetSize; DWORD dwNumber; UINT wDeviceType; }; +struct tagMCI_SET_PARMS{ DWORD_PTR dwCallback; DWORD dwTimeFormat; DWORD dwAudio; }; +struct tagMCI_BREAK_PARMS{ DWORD_PTR dwCallback; int nVirtKey; HWND hwndBreak; }; +struct tagMCI_SAVE_PARMSA{ DWORD_PTR dwCallback; LPCSTR lpfilename; }; +struct tagMCI_SAVE_PARMSW{ DWORD_PTR dwCallback; LPCWSTR lpfilename; }; +struct tagMCI_LOAD_PARMSA{ DWORD_PTR dwCallback; LPCSTR lpfilename; }; +struct tagMCI_LOAD_PARMSW{ DWORD_PTR dwCallback; LPCWSTR lpfilename; }; +struct tagMCI_RECORD_PARMS{ DWORD_PTR dwCallback; DWORD dwFrom; DWORD dwTo; }; +struct tagMCI_VD_PLAY_PARMS{ DWORD_PTR dwCallback; DWORD dwFrom; DWORD dwTo; DWORD dwSpeed; }; +struct tagMCI_VD_STEP_PARMS{ DWORD_PTR dwCallback; DWORD dwFrames; }; +struct tagMCI_VD_ESCAPE_PARMSA{ DWORD_PTR dwCallback; LPCSTR lpstrCommand; }; +struct tagMCI_VD_ESCAPE_PARMSW{ DWORD_PTR dwCallback; LPCWSTR lpstrCommand; }; +struct tagMCI_WAVE_OPEN_PARMSA{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCSTR lpstrDeviceType; LPCSTR lpstrElementName; LPCSTR lpstrAlias; DWORD dwBufferSeconds; }; +struct tagMCI_WAVE_OPEN_PARMSW{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCWSTR lpstrDeviceType; LPCWSTR lpstrElementName; LPCWSTR lpstrAlias; DWORD dwBufferSeconds; }; +struct tagMCI_WAVE_DELETE_PARMS{ DWORD_PTR dwCallback; DWORD dwFrom; DWORD dwTo; }; +struct tagMCI_WAVE_SET_PARMS{ DWORD_PTR dwCallback; DWORD dwTimeFormat; DWORD dwAudio; UINT wInput; UINT wOutput; WORD wFormatTag; WORD wReserved2; WORD nChannels; WORD wReserved3; DWORD nSamplesPerSec; DWORD nAvgBytesPerSec; WORD nBlockAlign; WORD wReserved4; WORD wBitsPerSample; WORD wReserved5; }; +struct tagMCI_SEQ_SET_PARMS{ DWORD_PTR dwCallback; DWORD dwTimeFormat; DWORD dwAudio; DWORD dwTempo; DWORD dwPort; DWORD dwSlave; DWORD dwMaster; DWORD dwOffset; }; +struct tagMCI_ANIM_OPEN_PARMSA{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCSTR lpstrDeviceType; LPCSTR lpstrElementName; LPCSTR lpstrAlias; DWORD dwStyle; HWND hWndParent; }; +struct tagMCI_ANIM_OPEN_PARMSW{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCWSTR lpstrDeviceType; LPCWSTR lpstrElementName; LPCWSTR lpstrAlias; DWORD dwStyle; HWND hWndParent; }; +struct tagMCI_ANIM_PLAY_PARMS{ DWORD_PTR dwCallback; DWORD dwFrom; DWORD dwTo; DWORD dwSpeed; }; +struct tagMCI_ANIM_STEP_PARMS{ DWORD_PTR dwCallback; DWORD dwFrames; }; +struct tagMCI_ANIM_WINDOW_PARMSA{ DWORD_PTR dwCallback; HWND hWnd; UINT nCmdShow; LPCSTR lpstrText; }; +struct tagMCI_ANIM_WINDOW_PARMSW{ DWORD_PTR dwCallback; HWND hWnd; UINT nCmdShow; LPCWSTR lpstrText; }; +struct tagMCI_ANIM_RECT_PARMS{ DWORD_PTR dwCallback; RECT rc; }; +struct tagMCI_ANIM_UPDATE_PARMS{ DWORD_PTR dwCallback; RECT rc; HDC hDC; }; +struct tagMCI_OVLY_OPEN_PARMSA{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCSTR lpstrDeviceType; LPCSTR lpstrElementName; LPCSTR lpstrAlias; DWORD dwStyle; HWND hWndParent; }; +struct tagMCI_OVLY_OPEN_PARMSW{ DWORD_PTR dwCallback; MCIDEVICEID wDeviceID; LPCWSTR lpstrDeviceType; LPCWSTR lpstrElementName; LPCWSTR lpstrAlias; DWORD dwStyle; HWND hWndParent; }; +struct tagMCI_OVLY_WINDOW_PARMSA{ DWORD_PTR dwCallback; HWND hWnd; UINT nCmdShow; LPCSTR lpstrText; }; +struct tagMCI_OVLY_WINDOW_PARMSW{ DWORD_PTR dwCallback; HWND hWnd; UINT nCmdShow; LPCWSTR lpstrText; }; +struct tagMCI_OVLY_RECT_PARMS{ DWORD_PTR dwCallback; RECT rc; }; +struct tagMCI_OVLY_SAVE_PARMSA{ DWORD_PTR dwCallback; LPCSTR lpfilename; RECT rc; }; +struct tagMCI_OVLY_SAVE_PARMSW{ DWORD_PTR dwCallback; LPCWSTR lpfilename; RECT rc; }; +struct tagMCI_OVLY_LOAD_PARMSA{ DWORD_PTR dwCallback; LPCSTR lpfilename; RECT rc; }; +struct tagMCI_OVLY_LOAD_PARMSW{ DWORD_PTR dwCallback; LPCWSTR lpfilename; RECT rc; }; +struct tagDRVCONFIGINFO{ DWORD dwDCISize; LPCWSTR lpszDCISectionName; LPCWSTR lpszDCIAliasName; }; +struct wavehdr_tag{ LPSTR lpData; DWORD dwBufferLength; DWORD dwBytesRecorded; DWORD_PTR dwUser; DWORD dwFlags; DWORD dwLoops; wavehdr_tag* lpNext; DWORD_PTR reserved; }; +struct tagWAVEOUTCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; DWORD dwSupport; }; +struct tagWAVEOUTCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; DWORD dwSupport; }; +struct tagWAVEOUTCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagWAVEOUTCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagWAVEINCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; }; +struct tagWAVEINCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; }; +struct tagWAVEINCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagWAVEINCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwFormats; WORD wChannels; WORD wReserved1; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct waveformat_tag{ WORD wFormatTag; WORD nChannels; DWORD nSamplesPerSec; DWORD nAvgBytesPerSec; WORD nBlockAlign; }; +struct pcmwaveformat_tag{ WAVEFORMAT wf; WORD wBitsPerSample; }; +struct tagMIDIOUTCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; WORD wTechnology; WORD wVoices; WORD wNotes; WORD wChannelMask; DWORD dwSupport; }; +struct tagMIDIOUTCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; WORD wTechnology; WORD wVoices; WORD wNotes; WORD wChannelMask; DWORD dwSupport; }; +struct tagMIDIOUTCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; WORD wTechnology; WORD wVoices; WORD wNotes; WORD wChannelMask; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIDIOUTCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; WORD wTechnology; WORD wVoices; WORD wNotes; WORD wChannelMask; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIDIINCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwSupport; }; +struct tagMIDIINCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwSupport; }; +struct tagMIDIINCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIDIINCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct midihdr_tag{ LPSTR lpData; DWORD dwBufferLength; DWORD dwBytesRecorded; DWORD_PTR dwUser; DWORD dwFlags; midihdr_tag* lpNext; DWORD_PTR reserved; DWORD dwOffset; DWORD_PTR dwReserved[8]; }; +struct midievent_tag{ DWORD dwDeltaTime; DWORD dwStreamID; DWORD dwEvent; DWORD dwParms[1]; }; +struct midistrmbuffver_tag{ DWORD dwVersion; DWORD dwMid; DWORD dwOEMVersion; }; +struct midiproptimediv_tag{ DWORD cbStruct; DWORD dwTimeDiv; }; +struct midiproptempo_tag{ DWORD cbStruct; DWORD dwTempo; }; +struct tagAUXCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; WORD wTechnology; WORD wReserved1; DWORD dwSupport; }; +struct tagAUXCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; WORD wTechnology; WORD wReserved1; DWORD dwSupport; }; +struct tagAUXCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; WORD wTechnology; WORD wReserved1; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagAUXCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; WORD wTechnology; WORD wReserved1; DWORD dwSupport; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIXERCAPSA{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD fdwSupport; DWORD cDestinations; }; +struct tagMIXERCAPSW{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD fdwSupport; DWORD cDestinations; }; +struct tagMIXERCAPS2A{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; CHAR szPname[32]; DWORD fdwSupport; DWORD cDestinations; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIXERCAPS2W{ WORD wMid; WORD wPid; MMVERSION vDriverVersion; WCHAR szPname[32]; DWORD fdwSupport; DWORD cDestinations; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagMIXERLINEA{ DWORD cbStruct; DWORD dwDestination; DWORD dwSource; DWORD dwLineID; DWORD fdwLine; DWORD_PTR dwUser; DWORD dwComponentType; DWORD cChannels; DWORD cConnections; DWORD cControls; CHAR szShortName[16]; CHAR szName[64]; 6731496E734C3862456F47425458774E4F396F4D30706F6E316B733D Target; }; +struct tagMIXERLINEW{ DWORD cbStruct; DWORD dwDestination; DWORD dwSource; DWORD dwLineID; DWORD fdwLine; DWORD_PTR dwUser; DWORD dwComponentType; DWORD cChannels; DWORD cConnections; DWORD cControls; WCHAR szShortName[16]; WCHAR szName[64]; 5A637830356953364E7A313367303643306959546C4E745A4C43513D Target; }; +struct tagMIXERCONTROLA{ DWORD cbStruct; DWORD dwControlID; DWORD dwControlType; DWORD fdwControl; DWORD cMultipleItems; CHAR szShortName[16]; CHAR szName[64]; 68567157584E372B2F762F466479792F58717331592B3149324C453D Bounds; 5A6242416E6E454C62665555747677707753706F792F526F4C6E633D Metrics; }; +struct tagMIXERCONTROLW{ DWORD cbStruct; DWORD dwControlID; DWORD dwControlType; DWORD fdwControl; DWORD cMultipleItems; WCHAR szShortName[16]; WCHAR szName[64]; 6C645634315930584B43502B714E33455042334F767064415244343D Bounds; 4D51647538564246316266762F41334F673448726951416F746D633D Metrics; }; +struct tagMIXERLINECONTROLSA{ DWORD cbStruct; DWORD dwLineID; DWORD cControls; DWORD cbmxctrl; LPMIXERCONTROLA pamxctrl; }; +struct tagMIXERLINECONTROLSW{ DWORD cbStruct; DWORD dwLineID; DWORD cControls; DWORD cbmxctrl; LPMIXERCONTROLW pamxctrl; }; +struct tagMIXERCONTROLDETAILS_LISTTEXTA{ DWORD dwParam1; DWORD dwParam2; CHAR szName[64]; }; +struct tagMIXERCONTROLDETAILS_LISTTEXTW{ DWORD dwParam1; DWORD dwParam2; WCHAR szName[64]; }; +struct timecaps_tag{ UINT wPeriodMin; UINT wPeriodMax; }; +struct tagJOYCAPSA{ WORD wMid; WORD wPid; CHAR szPname[32]; UINT wXmin; UINT wXmax; UINT wYmin; UINT wYmax; UINT wZmin; UINT wZmax; UINT wNumButtons; UINT wPeriodMin; UINT wPeriodMax; UINT wRmin; UINT wRmax; UINT wUmin; UINT wUmax; UINT wVmin; UINT wVmax; UINT wCaps; UINT wMaxAxes; UINT wNumAxes; UINT wMaxButtons; CHAR szRegKey[32]; CHAR szOEMVxD[260]; }; +struct tagJOYCAPSW{ WORD wMid; WORD wPid; WCHAR szPname[32]; UINT wXmin; UINT wXmax; UINT wYmin; UINT wYmax; UINT wZmin; UINT wZmax; UINT wNumButtons; UINT wPeriodMin; UINT wPeriodMax; UINT wRmin; UINT wRmax; UINT wUmin; UINT wUmax; UINT wVmin; UINT wVmax; UINT wCaps; UINT wMaxAxes; UINT wNumAxes; UINT wMaxButtons; WCHAR szRegKey[32]; WCHAR szOEMVxD[260]; }; +struct tagJOYCAPS2A{ WORD wMid; WORD wPid; CHAR szPname[32]; UINT wXmin; UINT wXmax; UINT wYmin; UINT wYmax; UINT wZmin; UINT wZmax; UINT wNumButtons; UINT wPeriodMin; UINT wPeriodMax; UINT wRmin; UINT wRmax; UINT wUmin; UINT wUmax; UINT wVmin; UINT wVmax; UINT wCaps; UINT wMaxAxes; UINT wNumAxes; UINT wMaxButtons; CHAR szRegKey[32]; CHAR szOEMVxD[260]; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct tagJOYCAPS2W{ WORD wMid; WORD wPid; WCHAR szPname[32]; UINT wXmin; UINT wXmax; UINT wYmin; UINT wYmax; UINT wZmin; UINT wZmax; UINT wNumButtons; UINT wPeriodMin; UINT wPeriodMax; UINT wRmin; UINT wRmax; UINT wUmin; UINT wUmax; UINT wVmin; UINT wVmax; UINT wCaps; UINT wMaxAxes; UINT wNumAxes; UINT wMaxButtons; WCHAR szRegKey[32]; WCHAR szOEMVxD[260]; GUID ManufacturerGuid; GUID ProductGuid; GUID NameGuid; }; +struct joyinfo_tag{ UINT wXpos; UINT wYpos; UINT wZpos; UINT wButtons; }; +struct joyinfoex_tag{ DWORD dwSize; DWORD dwFlags; DWORD dwXpos; DWORD dwYpos; DWORD dwZpos; DWORD dwRpos; DWORD dwUpos; DWORD dwVpos; DWORD dwButtons; DWORD dwButtonNumber; DWORD dwPOV; DWORD dwReserved1; DWORD dwReserved2; }; +RPC_STATUS I_RpcLaunchDatagramReceiveThread( void* pAddress ); +struct tagI_RpcProxyCallbackInterface{ I_RpcProxyIsValidMachineFn IsValidMachineFn; I_RpcProxyGetClientAddressFn GetClientAddressFn; I_RpcProxyGetConnectionTimeoutFn GetConnectionTimeoutFn; I_RpcPerformCalloutFn PerformCalloutFn; I_RpcFreeCalloutStateFn FreeCalloutStateFn; I_RpcProxyGetClientSessionAndResourceUUID GetClientSessionAndResourceUUIDFn; I_RpcProxyFilterIfFn ProxyFilterIfFn; I_RpcProxyUpdatePerfCounterFn RpcProxyUpdatePerfCounterFn; I_RpcProxyUpdatePerfCounterBackendServerFn RpcProxyUpdatePerfCounterBackendServerFn; }; +enum tagExtendedErrorParamTypes{ eeptAnsiString = 1, eeptUnicodeString = 2, eeptLongVal = 3, eeptShortVal = 4, eeptPointerVal = 5, eeptNone = 6, eeptBinary = 7 }; +struct tagBinaryParam{ void* Buffer; short Size; }; +struct tagRPC_EE_INFO_PARAM{ ExtendedErrorParamTypes ParameterType; 5A4A5833714D53703031515342646D563752676757616E533441593D u; }; +struct tagRPC_EXTENDED_ERROR_INFO{ ULONG Version; LPWSTR ComputerName; ULONG ProcessID; 4C6A323276584771362B68666A365861312F374D4D6253626E766B3D u; ULONG GeneratingComponent; ULONG Status; USHORT DetectionLocation; USHORT Flags; int NumberOfParameters; RPC_EE_INFO_PARAM Parameters[4]; }; +struct tagRPC_ERROR_ENUM_HANDLE{ ULONG Signature; void* CurrentPos; void* Head; }; +enum tagRpcLocalAddressFormat{ rlafInvalid = 0, rlafIPv4 = 1, rlafIPv6 = 2 }; +struct tagRPC_CALL_ATTRIBUTES_V1_W{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned short* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned short* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; }; +struct tagRPC_CALL_ATTRIBUTES_V1_A{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned char* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned char* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; }; +enum tagRpcCallType{ rctInvalid = 0, rctNormal = 1, rctTraining = 2, rctGuaranteed = 3 }; +enum tagRpcCallClientLocality{ rcclInvalid = 0, rcclLocal = 1, rcclRemote = 2, rcclClientUnknownLocality = 3 }; +struct tagRPC_CALL_ATTRIBUTES_V2_W{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned short* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned short* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; BOOL KernelModeCaller; unsigned long ProtocolSequence; RpcCallClientLocality IsClientLocal; HANDLE ClientPID; unsigned long CallStatus; RpcCallType CallType; RPC_CALL_LOCAL_ADDRESS_V1* CallLocalAddress; unsigned short OpNum; UUID InterfaceUuid; }; +struct tagRPC_CALL_ATTRIBUTES_V2_A{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned char* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned char* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; BOOL KernelModeCaller; unsigned long ProtocolSequence; unsigned long IsClientLocal; HANDLE ClientPID; unsigned long CallStatus; RpcCallType CallType; RPC_CALL_LOCAL_ADDRESS_V1* CallLocalAddress; unsigned short OpNum; UUID InterfaceUuid; }; +struct tagRPC_CALL_ATTRIBUTES_V3_W{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned short* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned short* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; BOOL KernelModeCaller; unsigned long ProtocolSequence; RpcCallClientLocality IsClientLocal; HANDLE ClientPID; unsigned long CallStatus; RpcCallType CallType; RPC_CALL_LOCAL_ADDRESS_V1* CallLocalAddress; unsigned short OpNum; UUID InterfaceUuid; unsigned long ClientIdentifierBufferLength; unsigned char* ClientIdentifier; }; +struct tagRPC_CALL_ATTRIBUTES_V3_A{ unsigned int Version; unsigned long Flags; unsigned long ServerPrincipalNameBufferLength; unsigned char* ServerPrincipalName; unsigned long ClientPrincipalNameBufferLength; unsigned char* ClientPrincipalName; unsigned long AuthenticationLevel; unsigned long AuthenticationService; BOOL NullSession; BOOL KernelModeCaller; unsigned long ProtocolSequence; unsigned long IsClientLocal; HANDLE ClientPID; unsigned long CallStatus; RpcCallType CallType; RPC_CALL_LOCAL_ADDRESS_V1* CallLocalAddress; unsigned short OpNum; UUID InterfaceUuid; unsigned long ClientIdentifierBufferLength; unsigned char* ClientIdentifier; }; +struct tagNC_ADDRESS{ NET_ADDRESS_INFO_* pAddrInfo; USHORT PortNumber; BYTE PrefixLength; }; +enum tagMEMCTX{ MEMCTX_TASK = 1, MEMCTX_SHARED = 2, MEMCTX_MACSYSTEM = 3, MEMCTX_UNKNOWN = 4294967295, MEMCTX_SAME = 4294967294 }; +enum tagCLSCTX{ CLSCTX_INPROC_SERVER = 1, CLSCTX_INPROC_HANDLER = 2, CLSCTX_LOCAL_SERVER = 4, CLSCTX_INPROC_SERVER16 = 8, CLSCTX_REMOTE_SERVER = 16, CLSCTX_INPROC_HANDLER16 = 32, CLSCTX_RESERVED1 = 64, CLSCTX_RESERVED2 = 128, CLSCTX_RESERVED3 = 256, CLSCTX_RESERVED4 = 512, CLSCTX_NO_CODE_DOWNLOAD = 1024, CLSCTX_RESERVED5 = 2048, CLSCTX_NO_CUSTOM_MARSHAL = 4096, CLSCTX_ENABLE_CODE_DOWNLOAD = 8192, CLSCTX_NO_FAILURE_LOG = 16384, CLSCTX_DISABLE_AAA = 32768, CLSCTX_ENABLE_AAA = 65536, CLSCTX_FROM_DEFAULT_CONTEXT = 131072, CLSCTX_ACTIVATE_X86_SERVER = 262144, CLSCTX_ACTIVATE_32_BIT_SERVER = 262144, CLSCTX_ACTIVATE_64_BIT_SERVER = 524288, CLSCTX_ENABLE_CLOAKING = 1048576, CLSCTX_APPCONTAINER = 4194304, CLSCTX_ACTIVATE_AAA_AS_IU = 8388608, CLSCTX_RESERVED6 = 16777216, CLSCTX_ACTIVATE_ARM32_SERVER = 33554432, CLSCTX_ALLOW_LOWER_TRUST_REGISTRATION = 67108864, CLSCTX_PS_DLL = 2147483648 }; +enum tagMSHLFLAGS{ MSHLFLAGS_NORMAL = 0, MSHLFLAGS_TABLESTRONG = 1, MSHLFLAGS_TABLEWEAK = 2, MSHLFLAGS_NOPING = 4, MSHLFLAGS_RESERVED1 = 8, MSHLFLAGS_RESERVED2 = 16, MSHLFLAGS_RESERVED3 = 32, MSHLFLAGS_RESERVED4 = 64 }; +enum tagMSHCTX{ MSHCTX_LOCAL = 0, MSHCTX_NOSHAREDMEM = 1, MSHCTX_DIFFERENTMACHINE = 2, MSHCTX_INPROC = 3, MSHCTX_CROSSCTX = 4, MSHCTX_CONTAINER = 5 }; +struct tagBLOB{ ULONG cbSize; BYTE* pBlobData; }; +struct tagRemHGLOBAL{ LONG fNullHGlobal; ULONG cbData; byte data[1]; }; +struct tagRemHMETAFILEPICT{ LONG mm; LONG xExt; LONG yExt; ULONG cbData; byte data[1]; }; +struct tagRemHENHMETAFILE{ ULONG cbData; byte data[1]; }; +struct tagRemHBITMAP{ ULONG cbData; byte data[1]; }; +struct tagRemHPALETTE{ ULONG cbData; byte data[1]; }; +struct tagRemBRUSH{ ULONG cbData; byte data[1]; }; +enum tagDVASPECT{ DVASPECT_CONTENT = 1, DVASPECT_THUMBNAIL = 2, DVASPECT_ICON = 4, DVASPECT_DOCPRINT = 8 }; +enum tagSTGC{ STGC_DEFAULT = 0, STGC_OVERWRITE = 1, STGC_ONLYIFCURRENT = 2, STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 4, STGC_CONSOLIDATE = 8 }; +enum tagSTGMOVE{ STGMOVE_MOVE = 0, STGMOVE_COPY = 1, STGMOVE_SHALLOWCOPY = 2 }; +enum tagSTATFLAG{ STATFLAG_DEFAULT = 0, STATFLAG_NONAME = 1, STATFLAG_NOOPEN = 2 }; +union tagCY{ LONGLONG int64; }; +struct tagDEC{ USHORT wReserved; ULONG Hi32; }; +struct tagBSTRBLOB{ ULONG cbSize; BYTE* pData; }; +struct tagCLIPDATA{ ULONG cbSize; LONG ulClipFmt; BYTE* pClipData; }; +struct _tagpropertykey{ GUID fmtid; DWORD pid; }; +struct tagCSPLATFORM{ DWORD dwPlatformId; DWORD dwVersionHi; DWORD dwVersionLo; DWORD dwProcessorArch; }; +struct tagQUERYCONTEXT{ DWORD dwContext; CSPLATFORM Platform; LCID Locale; DWORD dwVersionHi; DWORD dwVersionLo; }; +enum tagTYSPEC{ TYSPEC_CLSID = 0, TYSPEC_FILEEXT = 1, TYSPEC_MIMETYPE = 2, TYSPEC_FILENAME = 3, TYSPEC_PROGID = 4, TYSPEC_PACKAGENAME = 5, TYSPEC_OBJECTID = 6 }; +enum tagREGCLS{ REGCLS_SINGLEUSE = 0, REGCLS_MULTIPLEUSE = 1, REGCLS_MULTI_SEPARATE = 2, REGCLS_SUSPENDED = 4, REGCLS_SURROGATE = 8, REGCLS_AGILE = 16 }; +enum tagCOINITBASE{ COINITBASE_MULTITHREADED = 0 }; +enum tagACTIVATIONTYPE{ ACTIVATIONTYPE_UNCATEGORIZED = 0, ACTIVATIONTYPE_FROM_MONIKER = 1, ACTIVATIONTYPE_FROM_DATA = 2, ACTIVATIONTYPE_FROM_STORAGE = 4, ACTIVATIONTYPE_FROM_STREAM = 8, ACTIVATIONTYPE_FROM_FILE = 16 }; +enum tagEXTCONN{ EXTCONN_STRONG = 1, EXTCONN_WEAK = 2, EXTCONN_CALLABLE = 4 }; +struct tagMULTI_QI{ IID* pIID; IUnknown* pItf; HRESULT hr; }; +struct tagSTATSTG{ LPOLESTR pwcsName; DWORD type; ULARGE_INTEGER cbSize; FILETIME mtime; FILETIME ctime; FILETIME atime; DWORD grfMode; DWORD grfLocksSupported; CLSID clsid; DWORD grfStateBits; DWORD reserved; }; +enum tagSTGTY{ STGTY_STORAGE = 1, STGTY_STREAM = 2, STGTY_LOCKBYTES = 3, STGTY_PROPERTY = 4 }; +enum tagSTREAM_SEEK{ STREAM_SEEK_SET = 0, STREAM_SEEK_CUR = 1, STREAM_SEEK_END = 2 }; +enum tagLOCKTYPE{ LOCK_WRITE = 1, LOCK_EXCLUSIVE = 2, LOCK_ONLYONCE = 4 }; +struct tagRPCOLEMESSAGE{ void* reserved1; RPCOLEDATAREP dataRepresentation; void* Buffer; ULONG cbBuffer; ULONG iMethod; void* reserved2[5]; ULONG rpcFlags; }; +struct tagSOLE_AUTHENTICATION_SERVICE{ DWORD dwAuthnSvc; DWORD dwAuthzSvc; OLECHAR* pPrincipalName; HRESULT hr; }; +enum tagEOLE_AUTHENTICATION_CAPABILITIES{ EOAC_NONE = 0, EOAC_MUTUAL_AUTH = 1, EOAC_STATIC_CLOAKING = 32, EOAC_DYNAMIC_CLOAKING = 64, EOAC_ANY_AUTHORITY = 128, EOAC_MAKE_FULLSIC = 256, EOAC_DEFAULT = 2048, EOAC_SECURE_REFS = 2, EOAC_ACCESS_CONTROL = 4, EOAC_APPID = 8, EOAC_DYNAMIC = 16, EOAC_REQUIRE_FULLSIC = 512, EOAC_AUTO_IMPERSONATE = 1024, EOAC_DISABLE_AAA = 4096, EOAC_NO_CUSTOM_MARSHAL = 8192, EOAC_RESERVED1 = 16384 }; +struct tagSOLE_AUTHENTICATION_INFO{ DWORD dwAuthnSvc; DWORD dwAuthzSvc; void* pAuthInfo; }; +struct tagSOLE_AUTHENTICATION_LIST{ DWORD cAuthInfo; SOLE_AUTHENTICATION_INFO* aAuthInfo; }; +enum tagRPCOPT_PROPERTIES{ COMBND_RPCTIMEOUT = 1, COMBND_SERVER_LOCALITY = 2, COMBND_RESERVED1 = 4, COMBND_RESERVED2 = 5, COMBND_RESERVED3 = 8, COMBND_RESERVED4 = 16 }; +enum tagRPCOPT_SERVER_LOCALITY_VALUES{ SERVER_LOCALITY_PROCESS_LOCAL = 0, SERVER_LOCALITY_MACHINE_LOCAL = 1, SERVER_LOCALITY_REMOTE = 2 }; +enum tagGLOBALOPT_PROPERTIES{ COMGLB_EXCEPTION_HANDLING = 1, COMGLB_APPID = 2, COMGLB_RPC_THREADPOOL_SETTING = 3, COMGLB_RO_SETTINGS = 4, COMGLB_UNMARSHALING_POLICY = 5, COMGLB_PROPERTIES_RESERVED1 = 6, COMGLB_PROPERTIES_RESERVED2 = 7, COMGLB_PROPERTIES_RESERVED3 = 8 }; +enum tagGLOBALOPT_EH_VALUES{ COMGLB_EXCEPTION_HANDLE = 0, COMGLB_EXCEPTION_DONOT_HANDLE_FATAL = 1, COMGLB_EXCEPTION_DONOT_HANDLE = 1, COMGLB_EXCEPTION_DONOT_HANDLE_ANY = 2 }; +enum tagGLOBALOPT_RPCTP_VALUES{ COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL = 0, COMGLB_RPC_THREADPOOL_SETTING_PRIVATE_POOL = 1 }; +enum tagGLOBALOPT_RO_FLAGS{ COMGLB_STA_MODALLOOP_REMOVE_TOUCH_MESSAGES = 1, COMGLB_STA_MODALLOOP_SHARED_QUEUE_REMOVE_INPUT_MESSAGES = 2, COMGLB_STA_MODALLOOP_SHARED_QUEUE_DONOT_REMOVE_INPUT_MESSAGES = 4, COMGLB_FAST_RUNDOWN = 8, COMGLB_RESERVED1 = 16, COMGLB_RESERVED2 = 32, COMGLB_RESERVED3 = 64, COMGLB_STA_MODALLOOP_SHARED_QUEUE_REORDER_POINTER_MESSAGES = 128, COMGLB_RESERVED4 = 256, COMGLB_RESERVED5 = 512, COMGLB_RESERVED6 = 1024 }; +enum tagGLOBALOPT_UNMARSHALING_POLICY_VALUES{ COMGLB_UNMARSHALING_POLICY_NORMAL = 0, COMGLB_UNMARSHALING_POLICY_STRONG = 1, COMGLB_UNMARSHALING_POLICY_HYBRID = 2 }; +enum tagDCOM_CALL_STATE{ DCOM_NONE = 0, DCOM_CALL_COMPLETE = 1, DCOM_CALL_CANCELED = 2 }; +struct tagServerInformation{ DWORD dwServerPid; DWORD dwServerTid; UINT64 ui64ServerAddress; }; +enum tagSTDMSHLFLAGS{ SMEXF_SERVER = 1, SMEXF_HANDLER = 2 }; +struct tagPROPVARIANT{ }; +enum tagCOWAIT_FLAGS{ COWAIT_DEFAULT = 0, COWAIT_WAITALL = 1, COWAIT_ALERTABLE = 2, COWAIT_INPUTAVAILABLE = 4, COWAIT_DISPATCH_CALLS = 8, COWAIT_DISPATCH_WINDOW_MESSAGES = 16 }; +struct tagBIND_OPTS{ DWORD cbStruct; DWORD grfFlags; DWORD grfMode; DWORD dwTickCountDeadline; }; +struct tagBIND_OPTS2{ DWORD cbStruct; DWORD grfFlags; DWORD grfMode; DWORD dwTickCountDeadline; DWORD dwTrackFlags; DWORD dwClassContext; LCID locale; COSERVERINFO* pServerInfo; }; +struct tagBIND_OPTS3{ DWORD cbStruct; DWORD grfFlags; DWORD grfMode; DWORD dwTickCountDeadline; DWORD dwTrackFlags; DWORD dwClassContext; LCID locale; COSERVERINFO* pServerInfo; HWND hwnd; }; +enum tagBIND_FLAGS{ BIND_MAYBOTHERUSER = 1, BIND_JUSTTESTEXISTENCE = 2 }; +enum tagMKSYS{ MKSYS_NONE = 0, MKSYS_GENERICCOMPOSITE = 1, MKSYS_FILEMONIKER = 2, MKSYS_ANTIMONIKER = 3, MKSYS_ITEMMONIKER = 4, MKSYS_POINTERMONIKER = 5, MKSYS_CLASSMONIKER = 7, MKSYS_OBJREFMONIKER = 8, MKSYS_SESSIONMONIKER = 9, MKSYS_LUAMONIKER = 10 }; +enum tagMKREDUCE{ MKRREDUCE_ONE = 196608, MKRREDUCE_TOUSER = 131072, MKRREDUCE_THROUGHUSER = 65536, MKRREDUCE_ALL = 0 }; +struct tagRemSNB{ ULONG ulCntStr; ULONG ulCntChar; OLECHAR rgString[1]; }; +struct tagDVTARGETDEVICE{ DWORD tdSize; WORD tdDriverNameOffset; WORD tdDeviceNameOffset; WORD tdPortNameOffset; WORD tdExtDevmodeOffset; BYTE tdData[1]; }; +struct tagFORMATETC{ CLIPFORMAT cfFormat; DVTARGETDEVICE* ptd; DWORD dwAspect; LONG lindex; DWORD tymed; }; +enum tagADVF{ ADVF_NODATA = 1, ADVF_PRIMEFIRST = 2, ADVF_ONLYONCE = 4, ADVF_DATAONSTOP = 64, ADVFCACHE_NOHANDLER = 8, ADVFCACHE_FORCEBUILTIN = 16, ADVFCACHE_ONSAVE = 32 }; +struct tagSTATDATA{ FORMATETC formatetc; DWORD advf; IAdviseSink* pAdvSink; DWORD dwConnection; }; +enum tagTYMED{ TYMED_HGLOBAL = 1, TYMED_FILE = 2, TYMED_ISTREAM = 4, TYMED_ISTORAGE = 8, TYMED_GDI = 16, TYMED_MFPICT = 32, TYMED_ENHMF = 64, TYMED_NULL = 0 }; +struct tagRemSTGMEDIUM{ DWORD tymed; DWORD dwHandleType; ULONG pData; ULONG pUnkForRelease; ULONG cbData; byte data[1]; }; +struct tagSTGMEDIUM{ DWORD tymed; IUnknown* pUnkForRelease; }; +enum tagDATADIR{ DATADIR_GET = 1, DATADIR_SET = 2 }; +enum tagCALLTYPE{ CALLTYPE_TOPLEVEL = 1, CALLTYPE_NESTED = 2, CALLTYPE_ASYNC = 3, CALLTYPE_TOPLEVEL_CALLPENDING = 4, CALLTYPE_ASYNC_CALLPENDING = 5 }; +enum tagSERVERCALL{ SERVERCALL_ISHANDLED = 0, SERVERCALL_REJECTED = 1, SERVERCALL_RETRYLATER = 2 }; +enum tagPENDINGTYPE{ PENDINGTYPE_TOPLEVEL = 1, PENDINGTYPE_NESTED = 2 }; +enum tagPENDINGMSG{ PENDINGMSG_CANCELCALL = 0, PENDINGMSG_WAITNOPROCESS = 1, PENDINGMSG_WAITDEFPROCESS = 2 }; +struct tagINTERFACEINFO{ IUnknown* pUnk; IID iid; WORD wMethod; }; +struct tagStorageLayout{ DWORD LayoutType; OLECHAR* pwcsElementName; LARGE_INTEGER cOffset; LARGE_INTEGER cBytes; }; +enum tagApplicationType{ ServerApplication = 0, LibraryApplication = 1 }; +enum tagShutdownType{ IdleShutdown = 0, ForcedShutdown = 1 }; +struct tagSAFEARRAYBOUND{ ULONG cElements; LONG lLbound; }; +enum tagSF_TYPE{ SF_ERROR = 10, SF_I1 = 16, SF_I2 = 2, SF_I4 = 3, SF_I8 = 20, SF_BSTR = 8, SF_UNKNOWN = 13, SF_DISPATCH = 9, SF_VARIANT = 12, SF_RECORD = 36, SF_HAVEIID = 32781 }; +struct tagSAFEARRAY{ USHORT cDims; USHORT fFeatures; ULONG cbElements; ULONG cLocks; PVOID pvData; SAFEARRAYBOUND rgsabound[1]; }; +struct tagVARIANT{ }; +enum tagTYPEKIND{ TKIND_ENUM = 0, TKIND_RECORD = 1, TKIND_MODULE = 2, TKIND_INTERFACE = 3, TKIND_DISPATCH = 4, TKIND_COCLASS = 5, TKIND_ALIAS = 6, TKIND_UNION = 7, TKIND_MAX = 8 }; +struct tagTYPEDESC{ VARTYPE vt; }; +struct tagARRAYDESC{ TYPEDESC tdescElem; USHORT cDims; SAFEARRAYBOUND rgbounds[1]; }; +struct tagPARAMDESCEX{ ULONG cBytes; VARIANTARG varDefaultValue; }; +struct tagPARAMDESC{ LPPARAMDESCEX pparamdescex; USHORT wParamFlags; }; +struct tagIDLDESC{ ULONG_PTR dwReserved; USHORT wIDLFlags; }; +struct tagELEMDESC{ TYPEDESC tdesc; }; +struct tagTYPEATTR{ GUID guid; LCID lcid; DWORD dwReserved; MEMBERID memidConstructor; MEMBERID memidDestructor; LPOLESTR lpstrSchema; ULONG cbSizeInstance; TYPEKIND typekind; WORD cFuncs; WORD cVars; WORD cImplTypes; WORD cbSizeVft; WORD cbAlignment; WORD wTypeFlags; WORD wMajorVerNum; WORD wMinorVerNum; TYPEDESC tdescAlias; IDLDESC idldescType; }; +struct tagDISPPARAMS{ VARIANTARG* rgvarg; DISPID* rgdispidNamedArgs; UINT cArgs; UINT cNamedArgs; }; +struct tagEXCEPINFO{ WORD wCode; WORD wReserved; BSTR bstrSource; BSTR bstrDescription; BSTR bstrHelpFile; DWORD dwHelpContext; PVOID pvReserved; SCODE scode; }; +enum tagCALLCONV{ CC_FASTCALL = 0, CC_CDECL = 1, CC_MSCPASCAL = 2, CC_PASCAL = 2, CC_MACPASCAL = 3, CC_STDCALL = 4, CC_FPFASTCALL = 5, CC_SYSCALL = 6, CC_MPWCDECL = 7, CC_MPWPASCAL = 8, CC_MAX = 9 }; +enum tagFUNCKIND{ FUNC_VIRTUAL = 0, FUNC_PUREVIRTUAL = 1, FUNC_NONVIRTUAL = 2, FUNC_STATIC = 3, FUNC_DISPATCH = 4 }; +enum tagINVOKEKIND{ INVOKE_FUNC = 1, INVOKE_PROPERTYGET = 2, INVOKE_PROPERTYPUT = 4, INVOKE_PROPERTYPUTREF = 8 }; +struct tagFUNCDESC{ MEMBERID memid; SCODE* lprgscode; ELEMDESC* lprgelemdescParam; FUNCKIND funckind; INVOKEKIND invkind; CALLCONV callconv; SHORT cParams; SHORT cParamsOpt; SHORT oVft; SHORT cScodes; ELEMDESC elemdescFunc; WORD wFuncFlags; }; +enum tagVARKIND{ VAR_PERINSTANCE = 0, VAR_STATIC = 1, VAR_CONST = 2, VAR_DISPATCH = 3 }; +struct tagVARDESC{ MEMBERID memid; LPOLESTR lpstrSchema; ELEMDESC elemdescVar; WORD wVarFlags; VARKIND varkind; }; +enum tagTYPEFLAGS{ TYPEFLAG_FAPPOBJECT = 1, TYPEFLAG_FCANCREATE = 2, TYPEFLAG_FLICENSED = 4, TYPEFLAG_FPREDECLID = 8, TYPEFLAG_FHIDDEN = 16, TYPEFLAG_FCONTROL = 32, TYPEFLAG_FDUAL = 64, TYPEFLAG_FNONEXTENSIBLE = 128, TYPEFLAG_FOLEAUTOMATION = 256, TYPEFLAG_FRESTRICTED = 512, TYPEFLAG_FAGGREGATABLE = 1024, TYPEFLAG_FREPLACEABLE = 2048, TYPEFLAG_FDISPATCHABLE = 4096, TYPEFLAG_FREVERSEBIND = 8192, TYPEFLAG_FPROXY = 16384 }; +enum tagFUNCFLAGS{ FUNCFLAG_FRESTRICTED = 1, FUNCFLAG_FSOURCE = 2, FUNCFLAG_FBINDABLE = 4, FUNCFLAG_FREQUESTEDIT = 8, FUNCFLAG_FDISPLAYBIND = 16, FUNCFLAG_FDEFAULTBIND = 32, FUNCFLAG_FHIDDEN = 64, FUNCFLAG_FUSESGETLASTERROR = 128, FUNCFLAG_FDEFAULTCOLLELEM = 256, FUNCFLAG_FUIDEFAULT = 512, FUNCFLAG_FNONBROWSABLE = 1024, FUNCFLAG_FREPLACEABLE = 2048, FUNCFLAG_FIMMEDIATEBIND = 4096 }; +enum tagVARFLAGS{ VARFLAG_FREADONLY = 1, VARFLAG_FSOURCE = 2, VARFLAG_FBINDABLE = 4, VARFLAG_FREQUESTEDIT = 8, VARFLAG_FDISPLAYBIND = 16, VARFLAG_FDEFAULTBIND = 32, VARFLAG_FHIDDEN = 64, VARFLAG_FRESTRICTED = 128, VARFLAG_FDEFAULTCOLLELEM = 256, VARFLAG_FUIDEFAULT = 512, VARFLAG_FNONBROWSABLE = 1024, VARFLAG_FREPLACEABLE = 2048, VARFLAG_FIMMEDIATEBIND = 4096 }; +struct tagCLEANLOCALSTORAGE{ IUnknown* pInterface; PVOID pStorage; DWORD flags; }; +struct tagCUSTDATAITEM{ GUID guid; VARIANTARG varValue; }; +struct tagCUSTDATA{ DWORD cCustData; LPCUSTDATAITEM prgCustData; }; +enum tagDESCKIND{ DESCKIND_NONE = 0, DESCKIND_FUNCDESC = 1, DESCKIND_VARDESC = 2, DESCKIND_TYPECOMP = 3, DESCKIND_IMPLICITAPPOBJ = 4, DESCKIND_MAX = 5 }; +union tagBINDPTR{ FUNCDESC* lpfuncdesc; VARDESC* lpvardesc; ITypeComp* lptcomp; }; +enum tagSYSKIND{ SYS_WIN16 = 0, SYS_WIN32 = 1, SYS_MAC = 2, SYS_WIN64 = 3 }; +enum tagLIBFLAGS{ LIBFLAG_FRESTRICTED = 1, LIBFLAG_FCONTROL = 2, LIBFLAG_FHIDDEN = 4, LIBFLAG_FHASDISKIMAGE = 8 }; +struct tagTLIBATTR{ GUID guid; LCID lcid; SYSKIND syskind; WORD wMajorVerNum; WORD wMinorVerNum; WORD wLibFlags; }; +enum tagCHANGEKIND{ CHANGEKIND_ADDMEMBER = 0, CHANGEKIND_DELETEMEMBER = 1, CHANGEKIND_SETNAMES = 2, CHANGEKIND_SETDOCUMENTATION = 3, CHANGEKIND_GENERAL = 4, CHANGEKIND_INVALIDATE = 5, CHANGEKIND_CHANGEFAILED = 6, CHANGEKIND_MAX = 7 }; +struct tagVersionedStream{ GUID guidVersion; IStream* pStream; }; +struct tagCAC{ ULONG cElems; CHAR* pElems; }; +struct tagCAUB{ ULONG cElems; UCHAR* pElems; }; +struct tagCAI{ ULONG cElems; SHORT* pElems; }; +struct tagCAUI{ ULONG cElems; USHORT* pElems; }; +struct tagCAL{ ULONG cElems; LONG* pElems; }; +struct tagCAUL{ ULONG cElems; ULONG* pElems; }; +struct tagCAFLT{ ULONG cElems; FLOAT* pElems; }; +struct tagCADBL{ ULONG cElems; DOUBLE* pElems; }; +struct tagCACY{ ULONG cElems; CY* pElems; }; +struct tagCADATE{ ULONG cElems; DATE* pElems; }; +struct tagCABSTR{ ULONG cElems; BSTR* pElems; }; +struct tagCABSTRBLOB{ ULONG cElems; BSTRBLOB* pElems; }; +struct tagCABOOL{ ULONG cElems; VARIANT_BOOL* pElems; }; +struct tagCASCODE{ ULONG cElems; SCODE* pElems; }; +struct tagCAPROPVARIANT{ ULONG cElems; PROPVARIANT* pElems; }; +struct tagCAH{ ULONG cElems; LARGE_INTEGER* pElems; }; +struct tagCAUH{ ULONG cElems; ULARGE_INTEGER* pElems; }; +struct tagCALPSTR{ ULONG cElems; LPSTR* pElems; }; +struct tagCALPWSTR{ ULONG cElems; LPWSTR* pElems; }; +struct tagCAFILETIME{ ULONG cElems; FILETIME* pElems; }; +struct tagCACLIPDATA{ ULONG cElems; CLIPDATA* pElems; }; +struct tagCACLSID{ ULONG cElems; CLSID* pElems; }; +struct tagPROPSPEC{ ULONG ulKind; }; +struct tagSTATPROPSTG{ LPOLESTR lpwstrName; PROPID propid; VARTYPE vt; }; +struct tagSTATPROPSETSTG{ FMTID fmtid; CLSID clsid; DWORD grfFlags; FILETIME mtime; FILETIME ctime; FILETIME atime; DWORD dwOSVersion; }; +struct tagSTGOPTIONS{ USHORT usVersion; USHORT reserved; ULONG ulSectorSize; WCHAR* pwcsTemplateFile; }; +enum tagCOINIT{ COINIT_APARTMENTTHREADED = 2, COINIT_MULTITHREADED = 0, COINIT_DISABLE_OLE1DDE = 4, COINIT_SPEED_OVER_MEMORY = 8 }; +enum tagCOMSD{ SD_LAUNCHPERMISSIONS = 0, SD_ACCESSPERMISSIONS = 1, SD_LAUNCHRESTRICTIONS = 2, SD_ACCESSRESTRICTIONS = 3 }; +enum tagDISCARDCACHE{ DISCARDCACHE_SAVEIFDIRTY = 0, DISCARDCACHE_NOSAVE = 1 }; +enum tagOLEGETMONIKER{ OLEGETMONIKER_ONLYIFTHERE = 1, OLEGETMONIKER_FORCEASSIGN = 2, OLEGETMONIKER_UNASSIGN = 3, OLEGETMONIKER_TEMPFORUSER = 4 }; +enum tagOLEWHICHMK{ OLEWHICHMK_CONTAINER = 1, OLEWHICHMK_OBJREL = 2, OLEWHICHMK_OBJFULL = 3 }; +enum tagUSERCLASSTYPE{ USERCLASSTYPE_FULL = 1, USERCLASSTYPE_SHORT = 2, USERCLASSTYPE_APPNAME = 3 }; +enum tagOLEMISC{ OLEMISC_RECOMPOSEONRESIZE = 1, OLEMISC_ONLYICONIC = 2, OLEMISC_INSERTNOTREPLACE = 4, OLEMISC_STATIC = 8, OLEMISC_CANTLINKINSIDE = 16, OLEMISC_CANLINKBYOLE1 = 32, OLEMISC_ISLINKOBJECT = 64, OLEMISC_INSIDEOUT = 128, OLEMISC_ACTIVATEWHENVISIBLE = 256, OLEMISC_RENDERINGISDEVICEINDEPENDENT = 512, OLEMISC_INVISIBLEATRUNTIME = 1024, OLEMISC_ALWAYSRUN = 2048, OLEMISC_ACTSLIKEBUTTON = 4096, OLEMISC_ACTSLIKELABEL = 8192, OLEMISC_NOUIACTIVATE = 16384, OLEMISC_ALIGNABLE = 32768, OLEMISC_SIMPLEFRAME = 65536, OLEMISC_SETCLIENTSITEFIRST = 131072, OLEMISC_IMEMODE = 262144, OLEMISC_IGNOREACTIVATEWHENVISIBLE = 524288, OLEMISC_WANTSTOMENUMERGE = 1048576, OLEMISC_SUPPORTSMULTILEVELUNDO = 2097152 }; +enum tagOLECLOSE{ OLECLOSE_SAVEIFDIRTY = 0, OLECLOSE_NOSAVE = 1, OLECLOSE_PROMPTSAVE = 2 }; +enum tagOLERENDER{ OLERENDER_NONE = 0, OLERENDER_DRAW = 1, OLERENDER_FORMAT = 2, OLERENDER_ASIS = 3 }; +struct tagOBJECTDESCRIPTOR{ ULONG cbSize; CLSID clsid; DWORD dwDrawAspect; SIZEL sizel; POINTL pointl; DWORD dwStatus; DWORD dwFullUserTypeName; DWORD dwSrcOfCopy; }; +enum tagOLEUPDATE{ OLEUPDATE_ALWAYS = 1, OLEUPDATE_ONCALL = 3 }; +enum tagOLELINKBIND{ OLELINKBIND_EVENIFCLASSDIFF = 1 }; +enum tagBINDSPEED{ BINDSPEED_INDEFINITE = 1, BINDSPEED_MODERATE = 2, BINDSPEED_IMMEDIATE = 3 }; +enum tagOLECONTF{ OLECONTF_EMBEDDINGS = 1, OLECONTF_LINKS = 2, OLECONTF_OTHERS = 4, OLECONTF_ONLYUSER = 8, OLECONTF_ONLYIFRUNNING = 16 }; +struct tagOIFI{ UINT cb; BOOL fMDIApp; HWND hwndFrame; HACCEL haccel; UINT cAccelEntries; }; +struct tagOleMenuGroupWidths{ LONG width[6]; }; +struct tagOLEVERB{ LONG lVerb; LPOLESTR lpszVerbName; DWORD fuFlags; DWORD grfAttribs; }; +enum tagOLEVERBATTRIB{ OLEVERBATTRIB_NEVERDIRTIES = 1, OLEVERBATTRIB_ONCONTAINERMENU = 2 }; +enum tagDOMNodeType{ NODE_INVALID = 0, NODE_ELEMENT = 1, NODE_ATTRIBUTE = 2, NODE_TEXT = 3, NODE_CDATA_SECTION = 4, NODE_ENTITY_REFERENCE = 5, NODE_ENTITY = 6, NODE_PROCESSING_INSTRUCTION = 7, NODE_COMMENT = 8, NODE_DOCUMENT = 9, NODE_DOCUMENT_TYPE = 10, NODE_DOCUMENT_FRAGMENT = 11, NODE_NOTATION = 12 }; +enum tagXMLEMEM_TYPE{ XMLELEMTYPE_ELEMENT = 0, XMLELEMTYPE_TEXT = 1, XMLELEMTYPE_COMMENT = 2, XMLELEMTYPE_DOCUMENT = 3, XMLELEMTYPE_DTD = 4, XMLELEMTYPE_PI = 5, XMLELEMTYPE_OTHER = 6 }; +struct _tagBINDINFO{ ULONG cbSize; LPWSTR szExtraInfo; STGMEDIUM stgmedData; DWORD grfBindInfoF; DWORD dwBindVerb; LPWSTR szCustomVerb; DWORD cbstgmedData; DWORD dwOptions; DWORD dwOptionsFlags; DWORD dwCodePage; SECURITY_ATTRIBUTES securityAttributes; IID iid; IUnknown* pUnk; DWORD dwReserved; }; +struct _tagRemBINDINFO{ ULONG cbSize; LPWSTR szExtraInfo; DWORD grfBindInfoF; DWORD dwBindVerb; LPWSTR szCustomVerb; DWORD cbstgmedData; DWORD dwOptions; DWORD dwOptionsFlags; DWORD dwCodePage; REMSECURITY_ATTRIBUTES securityAttributes; IID iid; IUnknown* pUnk; DWORD dwReserved; }; +struct tagRemFORMATETC{ DWORD cfFormat; DWORD ptd; DWORD dwAspect; LONG lindex; DWORD tymed; }; +enum tagBINDSTATUS{ BINDSTATUS_FINDINGRESOURCE = 1, BINDSTATUS_CONNECTING = 2, BINDSTATUS_REDIRECTING = 3, BINDSTATUS_BEGINDOWNLOADDATA = 4, BINDSTATUS_DOWNLOADINGDATA = 5, BINDSTATUS_ENDDOWNLOADDATA = 6, BINDSTATUS_BEGINDOWNLOADCOMPONENTS = 7, BINDSTATUS_INSTALLINGCOMPONENTS = 8, BINDSTATUS_ENDDOWNLOADCOMPONENTS = 9, BINDSTATUS_USINGCACHEDCOPY = 10, BINDSTATUS_SENDINGREQUEST = 11, BINDSTATUS_CLASSIDAVAILABLE = 12, BINDSTATUS_MIMETYPEAVAILABLE = 13, BINDSTATUS_CACHEFILENAMEAVAILABLE = 14, BINDSTATUS_BEGINSYNCOPERATION = 15, BINDSTATUS_ENDSYNCOPERATION = 16, BINDSTATUS_BEGINUPLOADDATA = 17, BINDSTATUS_UPLOADINGDATA = 18, BINDSTATUS_ENDUPLOADDATA = 19, BINDSTATUS_PROTOCOLCLASSID = 20, BINDSTATUS_ENCODING = 21, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE = 22, BINDSTATUS_CLASSINSTALLLOCATION = 23, BINDSTATUS_DECODING = 24, BINDSTATUS_LOADINGMIMEHANDLER = 25, BINDSTATUS_CONTENTDISPOSITIONATTACH = 26, BINDSTATUS_FILTERREPORTMIMETYPE = 27, BINDSTATUS_CLSIDCANINSTANTIATE = 28, BINDSTATUS_IUNKNOWNAVAILABLE = 29, BINDSTATUS_DIRECTBIND = 30, BINDSTATUS_RAWMIMETYPE = 31, BINDSTATUS_PROXYDETECTING = 32, BINDSTATUS_ACCEPTRANGES = 33, BINDSTATUS_COOKIE_SENT = 34, BINDSTATUS_COMPACT_POLICY_RECEIVED = 35, BINDSTATUS_COOKIE_SUPPRESSED = 36, BINDSTATUS_COOKIE_STATE_UNKNOWN = 37, BINDSTATUS_COOKIE_STATE_ACCEPT = 38, BINDSTATUS_COOKIE_STATE_REJECT = 39, BINDSTATUS_COOKIE_STATE_PROMPT = 40, BINDSTATUS_COOKIE_STATE_LEASH = 41, BINDSTATUS_COOKIE_STATE_DOWNGRADE = 42, BINDSTATUS_POLICY_HREF = 43, BINDSTATUS_P3P_HEADER = 44, BINDSTATUS_SESSION_COOKIE_RECEIVED = 45, BINDSTATUS_PERSISTENT_COOKIE_RECEIVED = 46, BINDSTATUS_SESSION_COOKIES_ALLOWED = 47, BINDSTATUS_CACHECONTROL = 48, BINDSTATUS_CONTENTDISPOSITIONFILENAME = 49, BINDSTATUS_MIMETEXTPLAINMISMATCH = 50, BINDSTATUS_PUBLISHERAVAILABLE = 51, BINDSTATUS_DISPLAYNAMEAVAILABLE = 52, BINDSTATUS_SSLUX_NAVBLOCKED = 53, BINDSTATUS_SERVER_MIMETYPEAVAILABLE = 54, BINDSTATUS_SNIFFED_CLASSIDAVAILABLE = 55, BINDSTATUS_64BIT_PROGRESS = 56, BINDSTATUS_LAST = 56, BINDSTATUS_RESERVED_0 = 57, BINDSTATUS_RESERVED_1 = 58, BINDSTATUS_RESERVED_2 = 59, BINDSTATUS_RESERVED_3 = 60, BINDSTATUS_RESERVED_4 = 61, BINDSTATUS_RESERVED_5 = 62, BINDSTATUS_RESERVED_6 = 63 }; +struct _tagAUTHENTICATEINFO{ DWORD dwFlags; DWORD dwReserved; }; +enum tagBINDSTRING{ BINDSTRING_HEADERS = 1, BINDSTRING_ACCEPT_MIMES = 2, BINDSTRING_EXTRA_URL = 3, BINDSTRING_LANGUAGE = 4, BINDSTRING_USERNAME = 5, BINDSTRING_PASSWORD = 6, BINDSTRING_UA_PIXELS = 7, BINDSTRING_UA_COLOR = 8, BINDSTRING_OS = 9, BINDSTRING_USER_AGENT = 10, BINDSTRING_ACCEPT_ENCODINGS = 11, BINDSTRING_POST_COOKIE = 12, BINDSTRING_POST_DATA_MIME = 13, BINDSTRING_URL = 14, BINDSTRING_IID = 15, BINDSTRING_FLAG_BIND_TO_OBJECT = 16, BINDSTRING_PTR_BIND_CONTEXT = 17, BINDSTRING_XDR_ORIGIN = 18, BINDSTRING_DOWNLOADPATH = 19, BINDSTRING_ROOTDOC_URL = 20, BINDSTRING_INITIAL_FILENAME = 21, BINDSTRING_PROXY_USERNAME = 22, BINDSTRING_PROXY_PASSWORD = 23, BINDSTRING_ENTERPRISE_ID = 24, BINDSTRING_DOC_URL = 25, BINDSTRING_SAMESITE_COOKIE_LEVEL = 26 }; +enum _tagPI_FLAGS{ PI_PARSE_URL = 1, PI_FILTER_MODE = 2, PI_FORCE_ASYNC = 4, PI_USE_WORKERTHREAD = 8, PI_MIMEVERIFICATION = 16, PI_CLSIDLOOKUP = 32, PI_DATAPROGRESS = 64, PI_SYNCHRONOUS = 128, PI_APARTMENTTHREADED = 256, PI_CLASSINSTALL = 512, PI_PASSONBINDCTX = 8192, PI_NOMIMEHANDLER = 32768, PI_LOADAPPDIRECT = 16384, PD_FORCE_SWITCH = 65536, PI_PREFERDEFAULTHANDLER = 131072 }; +struct _tagPROTOCOLDATA{ DWORD grfFlags; DWORD dwState; LPVOID pData; ULONG cbData; }; +struct _tagStartParam{ IID iid; IBindCtx* pIBindCtx; IUnknown* pItf; }; +enum _tagOIBDG_FLAGS{ OIBDG_APARTMENTTHREADED = 256, OIBDG_DATAONLY = 4096 }; +enum _tagPARSEACTION{ PARSE_CANONICALIZE = 1, PARSE_FRIENDLY = 2, PARSE_SECURITY_URL = 3, PARSE_ROOTDOCUMENT = 4, PARSE_DOCUMENT = 5, PARSE_ANCHOR = 6, PARSE_ENCODE_IS_UNESCAPE = 7, PARSE_DECODE_IS_ESCAPE = 8, PARSE_PATH_FROM_URL = 9, PARSE_URL_FROM_PATH = 10, PARSE_MIME = 11, PARSE_SERVER = 12, PARSE_SCHEMA = 13, PARSE_SITE = 14, PARSE_DOMAIN = 15, PARSE_LOCATION = 16, PARSE_SECURITY_DOMAIN = 17, PARSE_ESCAPE = 18, PARSE_UNESCAPE = 19 }; +enum _tagPSUACTION{ PSU_DEFAULT = 1, PSU_SECURITY_URL_ONLY = 2 }; +enum _tagQUERYOPTION{ QUERY_EXPIRATION_DATE = 1, QUERY_TIME_OF_LAST_CHANGE = 2, QUERY_CONTENT_ENCODING = 3, QUERY_CONTENT_TYPE = 4, QUERY_REFRESH = 5, QUERY_RECOMBINE = 6, QUERY_CAN_NAVIGATE = 7, QUERY_USES_NETWORK = 8, QUERY_IS_CACHED = 9, QUERY_IS_INSTALLEDENTRY = 10, QUERY_IS_CACHED_OR_MAPPED = 11, QUERY_USES_CACHE = 12, QUERY_IS_SECURE = 13, QUERY_IS_SAFE = 14, QUERY_USES_HISTORYFOLDER = 15, QUERY_IS_CACHED_AND_USABLE_OFFLINE = 16 }; +enum _tagINTERNETFEATURELIST{ FEATURE_OBJECT_CACHING = 0, FEATURE_ZONE_ELEVATION = 1, FEATURE_MIME_HANDLING = 2, FEATURE_MIME_SNIFFING = 3, FEATURE_WINDOW_RESTRICTIONS = 4, FEATURE_WEBOC_POPUPMANAGEMENT = 5, FEATURE_BEHAVIORS = 6, FEATURE_DISABLE_MK_PROTOCOL = 7, FEATURE_LOCALMACHINE_LOCKDOWN = 8, FEATURE_SECURITYBAND = 9, FEATURE_RESTRICT_ACTIVEXINSTALL = 10, FEATURE_VALIDATE_NAVIGATE_URL = 11, FEATURE_RESTRICT_FILEDOWNLOAD = 12, FEATURE_ADDON_MANAGEMENT = 13, FEATURE_PROTOCOL_LOCKDOWN = 14, FEATURE_HTTP_USERNAME_PASSWORD_DISABLE = 15, FEATURE_SAFE_BINDTOOBJECT = 16, FEATURE_UNC_SAVEDFILECHECK = 17, FEATURE_GET_URL_DOM_FILEPATH_UNENCODED = 18, FEATURE_TABBED_BROWSING = 19, FEATURE_SSLUX = 20, FEATURE_DISABLE_NAVIGATION_SOUNDS = 21, FEATURE_DISABLE_LEGACY_COMPRESSION = 22, FEATURE_FORCE_ADDR_AND_STATUS = 23, FEATURE_XMLHTTP = 24, FEATURE_DISABLE_TELNET_PROTOCOL = 25, FEATURE_FEEDS = 26, FEATURE_BLOCK_INPUT_PROMPTS = 27, FEATURE_ENTRY_COUNT = 28 }; +enum tagURLZONE{ URLZONE_INVALID = 4294967295, URLZONE_PREDEFINED_MIN = 0, URLZONE_LOCAL_MACHINE = 0, URLZONE_INTRANET = 1, URLZONE_TRUSTED = 2, URLZONE_INTERNET = 3, URLZONE_UNTRUSTED = 4, URLZONE_PREDEFINED_MAX = 999, URLZONE_USER_MIN = 1000, URLZONE_USER_MAX = 10000 }; +enum tagURLTEMPLATE{ URLTEMPLATE_CUSTOM = 0, URLTEMPLATE_PREDEFINED_MIN = 65536, URLTEMPLATE_LOW = 65536, URLTEMPLATE_MEDLOW = 66816, URLTEMPLATE_MEDIUM = 69632, URLTEMPLATE_MEDHIGH = 70912, URLTEMPLATE_HIGH = 73728, URLTEMPLATE_PREDEFINED_MAX = 131072 }; +struct _tagCODEBASEHOLD{ ULONG cbSize; LPWSTR szDistUnit; LPWSTR szCodeBase; DWORD dwVersionMS; DWORD dwVersionLS; DWORD dwStyle; }; +struct _tagSOFTDISTINFO{ ULONG cbSize; DWORD dwFlags; DWORD dwAdState; LPWSTR szTitle; LPWSTR szAbstract; LPWSTR szHREF; DWORD dwInstalledVersionMS; DWORD dwInstalledVersionLS; DWORD dwUpdateVersionMS; DWORD dwUpdateVersionLS; DWORD dwAdvertisedVersionMS; DWORD dwAdvertisedVersionLS; DWORD dwReserved; }; +struct _tagPROTOCOLFILTERDATA{ DWORD cbSize; IInternetProtocolSink* pProtocolSink; IInternetProtocol* pProtocol; IUnknown* pUnk; DWORD dwFilterFlags; }; +struct _tagDATAINFO{ ULONG ulTotalSize; ULONG ulavrPacketSize; ULONG ulConnectSpeed; ULONG ulProcessorSpeed; }; +struct _tagHIT_LOGGING_INFO{ DWORD dwStructSize; LPSTR lpszLoggedUrlName; SYSTEMTIME StartTime; SYSTEMTIME EndTime; LPSTR lpszExtendedInfo; }; +struct _tagPROTOCOL_ARGUMENT{ LPCWSTR szMethod; LPCWSTR szTargetUrl; }; +struct tagSERIALIZEDPROPERTYVALUE{ DWORD dwType; BYTE rgb[1]; }; +enum tagREGKIND{ REGKIND_DEFAULT = 0, REGKIND_REGISTER = 1, REGKIND_NONE = 2 }; +struct tagPARAMDATA{ OLECHAR* szName; VARTYPE vt; }; +struct tagMETHODDATA{ OLECHAR* szName; PARAMDATA* ppdata; DISPID dispid; UINT iMeth; CALLCONV cc; UINT cArgs; WORD wFlags; VARTYPE vtReturn; }; +struct tagINTERFACEDATA{ METHODDATA* pmethdata; UINT cMembers; }; +struct tagOFN_NT4A{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; LPCSTR lpstrFilter; LPSTR lpstrCustomFilter; DWORD nMaxCustFilter; DWORD nFilterIndex; LPSTR lpstrFile; DWORD nMaxFile; LPSTR lpstrFileTitle; DWORD nMaxFileTitle; LPCSTR lpstrInitialDir; LPCSTR lpstrTitle; DWORD Flags; WORD nFileOffset; WORD nFileExtension; LPCSTR lpstrDefExt; LPARAM lCustData; LPOFNHOOKPROC lpfnHook; LPCSTR lpTemplateName; }; +struct tagOFN_NT4W{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; LPCWSTR lpstrFilter; LPWSTR lpstrCustomFilter; DWORD nMaxCustFilter; DWORD nFilterIndex; LPWSTR lpstrFile; DWORD nMaxFile; LPWSTR lpstrFileTitle; DWORD nMaxFileTitle; LPCWSTR lpstrInitialDir; LPCWSTR lpstrTitle; DWORD Flags; WORD nFileOffset; WORD nFileExtension; LPCWSTR lpstrDefExt; LPARAM lCustData; LPOFNHOOKPROC lpfnHook; LPCWSTR lpTemplateName; }; +struct tagOFNA{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; LPCSTR lpstrFilter; LPSTR lpstrCustomFilter; DWORD nMaxCustFilter; DWORD nFilterIndex; LPSTR lpstrFile; DWORD nMaxFile; LPSTR lpstrFileTitle; DWORD nMaxFileTitle; LPCSTR lpstrInitialDir; LPCSTR lpstrTitle; DWORD Flags; WORD nFileOffset; WORD nFileExtension; LPCSTR lpstrDefExt; LPARAM lCustData; LPOFNHOOKPROC lpfnHook; LPCSTR lpTemplateName; void* pvReserved; DWORD dwReserved; DWORD FlagsEx; }; +struct tagOFNW{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; LPCWSTR lpstrFilter; LPWSTR lpstrCustomFilter; DWORD nMaxCustFilter; DWORD nFilterIndex; LPWSTR lpstrFile; DWORD nMaxFile; LPWSTR lpstrFileTitle; DWORD nMaxFileTitle; LPCWSTR lpstrInitialDir; LPCWSTR lpstrTitle; DWORD Flags; WORD nFileOffset; WORD nFileExtension; LPCWSTR lpstrDefExt; LPARAM lCustData; LPOFNHOOKPROC lpfnHook; LPCWSTR lpTemplateName; void* pvReserved; DWORD dwReserved; DWORD FlagsEx; }; +struct tagCHOOSECOLORA{ DWORD lStructSize; HWND hwndOwner; HWND hInstance; COLORREF rgbResult; COLORREF* lpCustColors; DWORD Flags; LPARAM lCustData; LPCCHOOKPROC lpfnHook; LPCSTR lpTemplateName; }; +struct tagCHOOSECOLORW{ DWORD lStructSize; HWND hwndOwner; HWND hInstance; COLORREF rgbResult; COLORREF* lpCustColors; DWORD Flags; LPARAM lCustData; LPCCHOOKPROC lpfnHook; LPCWSTR lpTemplateName; }; +struct tagFINDREPLACEA{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; DWORD Flags; LPSTR lpstrFindWhat; LPSTR lpstrReplaceWith; WORD wFindWhatLen; WORD wReplaceWithLen; LPARAM lCustData; LPFRHOOKPROC lpfnHook; LPCSTR lpTemplateName; }; +struct tagFINDREPLACEW{ DWORD lStructSize; HWND hwndOwner; HINSTANCE hInstance; DWORD Flags; LPWSTR lpstrFindWhat; LPWSTR lpstrReplaceWith; WORD wFindWhatLen; WORD wReplaceWithLen; LPARAM lCustData; LPFRHOOKPROC lpfnHook; LPCWSTR lpTemplateName; }; +struct tagCHOOSEFONTA{ DWORD lStructSize; HWND hwndOwner; HDC hDC; LPLOGFONTA lpLogFont; INT iPointSize; DWORD Flags; COLORREF rgbColors; LPARAM lCustData; LPCFHOOKPROC lpfnHook; LPCSTR lpTemplateName; HINSTANCE hInstance; LPSTR lpszStyle; WORD nFontType; WORD ___MISSING_ALIGNMENT__; INT nSizeMin; INT nSizeMax; }; +struct tagCHOOSEFONTW{ DWORD lStructSize; HWND hwndOwner; HDC hDC; LPLOGFONTW lpLogFont; INT iPointSize; DWORD Flags; COLORREF rgbColors; LPARAM lCustData; LPCFHOOKPROC lpfnHook; LPCWSTR lpTemplateName; HINSTANCE hInstance; LPWSTR lpszStyle; WORD nFontType; WORD ___MISSING_ALIGNMENT__; INT nSizeMin; INT nSizeMax; }; +struct tagPDA{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; HDC hDC; DWORD Flags; WORD nFromPage; WORD nToPage; WORD nMinPage; WORD nMaxPage; WORD nCopies; HINSTANCE hInstance; LPARAM lCustData; LPPRINTHOOKPROC lpfnPrintHook; LPSETUPHOOKPROC lpfnSetupHook; LPCSTR lpPrintTemplateName; LPCSTR lpSetupTemplateName; HGLOBAL hPrintTemplate; HGLOBAL hSetupTemplate; }; +struct tagPDW{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; HDC hDC; DWORD Flags; WORD nFromPage; WORD nToPage; WORD nMinPage; WORD nMaxPage; WORD nCopies; HINSTANCE hInstance; LPARAM lCustData; LPPRINTHOOKPROC lpfnPrintHook; LPSETUPHOOKPROC lpfnSetupHook; LPCWSTR lpPrintTemplateName; LPCWSTR lpSetupTemplateName; HGLOBAL hPrintTemplate; HGLOBAL hSetupTemplate; }; +struct tagPRINTPAGERANGE{ DWORD nFromPage; DWORD nToPage; }; +struct tagPDEXA{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; HDC hDC; DWORD Flags; DWORD Flags2; DWORD ExclusionFlags; DWORD nPageRanges; DWORD nMaxPageRanges; LPPRINTPAGERANGE lpPageRanges; DWORD nMinPage; DWORD nMaxPage; DWORD nCopies; HINSTANCE hInstance; LPCSTR lpPrintTemplateName; LPUNKNOWN lpCallback; DWORD nPropertyPages; HPROPSHEETPAGE* lphPropertyPages; DWORD nStartPage; DWORD dwResultAction; }; +struct tagPDEXW{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; HDC hDC; DWORD Flags; DWORD Flags2; DWORD ExclusionFlags; DWORD nPageRanges; DWORD nMaxPageRanges; LPPRINTPAGERANGE lpPageRanges; DWORD nMinPage; DWORD nMaxPage; DWORD nCopies; HINSTANCE hInstance; LPCWSTR lpPrintTemplateName; LPUNKNOWN lpCallback; DWORD nPropertyPages; HPROPSHEETPAGE* lphPropertyPages; DWORD nStartPage; DWORD dwResultAction; }; +struct tagDEVNAMES{ WORD wDriverOffset; WORD wDeviceOffset; WORD wOutputOffset; WORD wDefault; }; +struct tagPSDA{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; DWORD Flags; POINT ptPaperSize; RECT rtMinMargin; RECT rtMargin; HINSTANCE hInstance; LPARAM lCustData; LPPAGESETUPHOOK lpfnPageSetupHook; LPPAGEPAINTHOOK lpfnPagePaintHook; LPCSTR lpPageSetupTemplateName; HGLOBAL hPageSetupTemplate; }; +struct tagPSDW{ DWORD lStructSize; HWND hwndOwner; HGLOBAL hDevMode; HGLOBAL hDevNames; DWORD Flags; POINT ptPaperSize; RECT rtMinMargin; RECT rtMargin; HINSTANCE hInstance; LPARAM lCustData; LPPAGESETUPHOOK lpfnPageSetupHook; LPPAGEPAINTHOOK lpfnPagePaintHook; LPCWSTR lpPageSetupTemplateName; HGLOBAL hPageSetupTemplate; }; +struct tagCOMPOSITIONFORM{ DWORD dwStyle; POINT ptCurrentPos; RECT rcArea; }; +struct tagCANDIDATEFORM{ DWORD dwIndex; DWORD dwStyle; POINT ptCurrentPos; RECT rcArea; }; +struct tagCANDIDATELIST{ DWORD dwSize; DWORD dwStyle; DWORD dwCount; DWORD dwSelection; DWORD dwPageStart; DWORD dwPageSize; DWORD dwOffset[1]; }; +struct tagREGISTERWORDA{ LPSTR lpReading; LPSTR lpWord; }; +struct tagREGISTERWORDW{ LPWSTR lpReading; LPWSTR lpWord; }; +struct tagRECONVERTSTRING{ DWORD dwSize; DWORD dwVersion; DWORD dwStrLen; DWORD dwStrOffset; DWORD dwCompStrLen; DWORD dwCompStrOffset; DWORD dwTargetStrLen; DWORD dwTargetStrOffset; }; +struct tagSTYLEBUFA{ DWORD dwStyle; CHAR szDescription[32]; }; +struct tagSTYLEBUFW{ DWORD dwStyle; WCHAR szDescription[32]; }; +struct tagIMEMENUITEMINFOA{ UINT cbSize; UINT fType; UINT fState; UINT wID; HBITMAP hbmpChecked; HBITMAP hbmpUnchecked; DWORD dwItemData; CHAR szString[80]; HBITMAP hbmpItem; }; +struct tagIMEMENUITEMINFOW{ UINT cbSize; UINT fType; UINT fState; UINT wID; HBITMAP hbmpChecked; HBITMAP hbmpUnchecked; DWORD dwItemData; WCHAR szString[80]; HBITMAP hbmpItem; }; +struct tagIMECHARPOSITION{ DWORD dwSize; DWORD dwCharPos; POINT pt; UINT cLineHeight; RECT rcDocument; }; +enum tagUASFLAGS{ UAS_NORMAL = 0, UAS_BLOCKED = 1, UAS_NOPARENTENABLE = 2, UAS_MASK = 3 }; +enum tagREADYSTATE{ READYSTATE_UNINITIALIZED = 0, READYSTATE_LOADING = 1, READYSTATE_LOADED = 2, READYSTATE_INTERACTIVE = 3, READYSTATE_COMPLETE = 4 }; +struct tagCONNECTDATA{ IUnknown* pUnk; DWORD dwCookie; }; +struct tagLICINFO{ LONG cbLicInfo; BOOL fRuntimeKeyAvail; BOOL fLicVerified; }; +enum tagGUIDKIND{ GUIDKIND_DEFAULT_SOURCE_DISP_IID = 1 }; +struct tagCONTROLINFO{ ULONG cb; HACCEL hAccel; USHORT cAccel; DWORD dwFlags; }; +enum tagCTRLINFO{ CTRLINFO_EATS_RETURN = 1, CTRLINFO_EATS_ESCAPE = 2 }; +struct tagPOINTF{ FLOAT x; FLOAT y; }; +enum tagXFORMCOORDS{ XFORMCOORDS_POSITION = 1, XFORMCOORDS_SIZE = 2, XFORMCOORDS_HIMETRICTOCONTAINER = 4, XFORMCOORDS_CONTAINERTOHIMETRIC = 8, XFORMCOORDS_EVENTCOMPAT = 16 }; +struct tagPROPPAGEINFO{ ULONG cb; LPOLESTR pszTitle; SIZE size; LPOLESTR pszDocString; LPOLESTR pszHelpFile; DWORD dwHelpContext; }; +enum tagPROPPAGESTATUS{ PROPPAGESTATUS_DIRTY = 1, PROPPAGESTATUS_VALIDATE = 2, PROPPAGESTATUS_CLEAN = 4 }; +struct tagCAUUID{ ULONG cElems; GUID* pElems; }; +enum tagPictureAttributes{ PICTURE_SCALABLE = 1, PICTURE_TRANSPARENT = 2 }; +enum tagACTIVATEFLAGS{ ACTIVATE_WINDOWLESS = 1 }; +enum tagOLEDCFLAGS{ OLEDC_NODRAW = 1, OLEDC_PAINTBKGND = 2, OLEDC_OFFSCREEN = 4 }; +enum tagVIEWSTATUS{ VIEWSTATUS_OPAQUE = 1, VIEWSTATUS_SOLIDBKGND = 2, VIEWSTATUS_DVASPECTOPAQUE = 4, VIEWSTATUS_DVASPECTTRANSPARENT = 8, VIEWSTATUS_SURFACE = 16, VIEWSTATUS_3DSURFACE = 32 }; +enum tagHITRESULT{ HITRESULT_OUTSIDE = 0, HITRESULT_TRANSPARENT = 1, HITRESULT_CLOSE = 2, HITRESULT_HIT = 3 }; +enum tagDVASPECT2{ DVASPECT_OPAQUE = 16, DVASPECT_TRANSPARENT = 32 }; +struct tagExtentInfo{ ULONG cb; DWORD dwExtentMode; SIZEL sizelProposed; }; +enum tagExtentMode{ DVEXTENT_CONTENT = 0, DVEXTENT_INTEGRAL = 1 }; +enum tagAspectInfoFlag{ DVASPECTINFOFLAG_CANOPTIMIZE = 1 }; +struct tagAspectInfo{ ULONG cb; DWORD dwFlags; }; +enum tagPOINTERINACTIVE{ POINTERINACTIVE_ACTIVATEONENTRY = 1, POINTERINACTIVE_DEACTIVATEONLEAVE = 2, POINTERINACTIVE_ACTIVATEONDRAG = 4 }; +struct tagCALPOLESTR{ ULONG cElems; LPOLESTR* pElems; }; +struct tagCADWORD{ ULONG cElems; DWORD* pElems; }; +enum tagPROPBAG2_TYPE{ PROPBAG2_TYPE_UNDEFINED = 0, PROPBAG2_TYPE_DATA = 1, PROPBAG2_TYPE_URL = 2, PROPBAG2_TYPE_OBJECT = 3, PROPBAG2_TYPE_STREAM = 4, PROPBAG2_TYPE_STORAGE = 5, PROPBAG2_TYPE_MONIKER = 6 }; +struct tagPROPBAG2{ DWORD dwType; VARTYPE vt; CLIPFORMAT cfType; DWORD dwHint; LPOLESTR pstrName; CLSID clsid; }; +enum tagQACONTAINERFLAGS{ QACONTAINER_SHOWHATCHING = 1, QACONTAINER_SHOWGRABHANDLES = 2, QACONTAINER_USERMODE = 4, QACONTAINER_DISPLAYASDEFAULT = 8, QACONTAINER_UIDEAD = 16, QACONTAINER_AUTOCLIP = 32, QACONTAINER_MESSAGEREFLECT = 64, QACONTAINER_SUPPORTSMNEMONICS = 128 }; +struct tagQACONTAINER{ ULONG cbSize; IOleClientSite* pClientSite; IAdviseSinkEx* pAdviseSink; IPropertyNotifySink* pPropertyNotifySink; IUnknown* pUnkEventSink; DWORD dwAmbientFlags; OLE_COLOR colorFore; OLE_COLOR colorBack; IFont* pFont; IOleUndoManager* pUndoMgr; DWORD dwAppearance; LONG lcid; HPALETTE hpal; IBindHost* pBindHost; IOleControlSite* pOleControlSite; IServiceProvider* pServiceProvider; }; +struct tagQACONTROL{ ULONG cbSize; DWORD dwMiscStatus; DWORD dwViewStatus; DWORD dwEventCookie; DWORD dwPropNotifyCookie; DWORD dwPointerActivationPolicy; }; +enum tagSTRRET_TYPE{ STRRET_WSTR = 0, STRRET_OFFSET = 1, STRRET_CSTR = 2 }; +enum tagPERCEIVED{ PERCEIVED_TYPE_FIRST = 4294967293, PERCEIVED_TYPE_CUSTOM = 4294967293, PERCEIVED_TYPE_UNSPECIFIED = 4294967294, PERCEIVED_TYPE_FOLDER = 4294967295, PERCEIVED_TYPE_UNKNOWN = 0, PERCEIVED_TYPE_TEXT = 1, PERCEIVED_TYPE_IMAGE = 2, PERCEIVED_TYPE_AUDIO = 3, PERCEIVED_TYPE_VIDEO = 4, PERCEIVED_TYPE_COMPRESSED = 5, PERCEIVED_TYPE_DOCUMENT = 6, PERCEIVED_TYPE_SYSTEM = 7, PERCEIVED_TYPE_APPLICATION = 8, PERCEIVED_TYPE_GAMEMEDIA = 9, PERCEIVED_TYPE_CONTACTS = 10, PERCEIVED_TYPE_LAST = 10 }; +enum tagSHCOLSTATE{ SHCOLSTATE_DEFAULT = 0, SHCOLSTATE_TYPE_STR = 1, SHCOLSTATE_TYPE_INT = 2, SHCOLSTATE_TYPE_DATE = 3, SHCOLSTATE_TYPEMASK = 15, SHCOLSTATE_ONBYDEFAULT = 16, SHCOLSTATE_SLOW = 32, SHCOLSTATE_EXTENDED = 64, SHCOLSTATE_SECONDARYUI = 128, SHCOLSTATE_HIDDEN = 256, SHCOLSTATE_PREFER_VARCMP = 512, SHCOLSTATE_PREFER_FMTCMP = 1024, SHCOLSTATE_NOSORTBYFOLDERNESS = 2048, SHCOLSTATE_VIEWONLY = 65536, SHCOLSTATE_BATCHREAD = 131072, SHCOLSTATE_NO_GROUPBY = 262144, SHCOLSTATE_FIXED_WIDTH = 4096, SHCOLSTATE_NODPISCALE = 8192, SHCOLSTATE_FIXED_RATIO = 16384, SHCOLSTATE_DISPLAYMASK = 61440 }; +enum tagCONDITION_TYPE{ CT_AND_CONDITION = 0, CT_OR_CONDITION = 1, CT_NOT_CONDITION = 2, CT_LEAF_CONDITION = 3 }; +enum tagCONDITION_OPERATION{ COP_IMPLICIT = 0, COP_EQUAL = 1, COP_NOTEQUAL = 2, COP_LESSTHAN = 3, COP_GREATERTHAN = 4, COP_LESSTHANOREQUAL = 5, COP_GREATERTHANOREQUAL = 6, COP_VALUE_STARTSWITH = 7, COP_VALUE_ENDSWITH = 8, COP_VALUE_CONTAINS = 9, COP_VALUE_NOTCONTAINS = 10, COP_DOSWILDCARDS = 11, COP_WORD_EQUAL = 12, COP_WORD_STARTSWITH = 13, COP_APPLICATION_SPECIFIC = 14 }; +struct tagSERIALIZEDPROPSTORAGE{ }; +struct tagDIRECTX_AUDIO_ACTIVATION_PARAMS{ DWORD cbDirectXAudioActivationParams; GUID guidAudioSession; DWORD dwAudioStreamFlags; }; +struct adpcmcoef_tag{ short iCoef1; short iCoef2; }; +struct adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; WORD wNumCoef; ADPCMCOEFSET aCoef; }; +struct drmwaveformat_tag{ WAVEFORMATEX wfx; WORD wReserved; ULONG ulContentId; WAVEFORMATEX wfxSecure; }; +struct dvi_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct ima_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct mediaspace_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct sierra_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct g723_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD cbExtraSize; WORD nAuxBlockSize; }; +struct digistdwaveformat_tag{ WAVEFORMATEX wfx; }; +struct digifixwaveformat_tag{ WAVEFORMATEX wfx; }; +struct creative_fastspeechformat_tag{ WAVEFORMATEX ewf; }; +struct yamaha_adpmcwaveformat_tag{ WAVEFORMATEX wfx; }; +struct sonarcwaveformat_tag{ WAVEFORMATEX wfx; WORD wCompType; }; +struct truespeechwaveformat_tag{ WAVEFORMATEX wfx; WORD wRevision; WORD nSamplesPerBlock; BYTE abReserved[28]; }; +struct echosc1waveformat_tag{ WAVEFORMATEX wfx; }; +struct audiofile_af36waveformat_tag{ WAVEFORMATEX wfx; }; +struct aptxwaveformat_tag{ WAVEFORMATEX wfx; }; +struct audiofile_af10waveformat_tag{ WAVEFORMATEX wfx; }; +struct dolbyac2waveformat_tag{ WAVEFORMATEX wfx; WORD nAuxBitsCode; }; +struct gsm610waveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct adpcmewaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct contres_vqlpcwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct digirealwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct digiadpcmmwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct contres_cr10waveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct nms_vbxadpcmmwaveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; }; +struct g721_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD nAuxBlockSize; }; +struct mpeg1waveformat_tag{ WAVEFORMATEX wfx; WORD fwHeadLayer; DWORD dwHeadBitrate; WORD fwHeadMode; WORD fwHeadModeExt; WORD wHeadEmphasis; WORD fwHeadFlags; DWORD dwPTSLow; DWORD dwPTSHigh; }; +struct mpeglayer3waveformat_tag{ WAVEFORMATEX wfx; WORD wID; DWORD fdwFlags; WORD nBlockSize; WORD nFramesPerBlock; WORD nCodecDelay; }; +struct heaacwaveinfo_tag{ WAVEFORMATEX wfx; WORD wPayloadType; WORD wAudioProfileLevelIndication; WORD wStructType; WORD wReserved1; DWORD dwReserved2; }; +struct heaacwaveformat_tag{ HEAACWAVEINFO wfInfo; BYTE pbAudioSpecificConfig[1]; }; +struct msaudio1waveformat_tag{ WAVEFORMATEX wfx; WORD wSamplesPerBlock; WORD wEncodeOptions; }; +struct wmaudio2waveformat_tag{ WAVEFORMATEX wfx; DWORD dwSamplesPerBlock; WORD wEncodeOptions; DWORD dwSuperBlockAlign; }; +struct wmaudio3waveformat_tag{ WAVEFORMATEX wfx; WORD wValidBitsPerSample; DWORD dwChannelMask; DWORD dwReserved1; DWORD dwReserved2; WORD wEncodeOptions; WORD wReserved3; }; +struct creative_adpcmwaveformat_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct creative_fastspeech8format_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct creative_fastspeech10format_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct fmtowns_snd_waveformat_tag{ WAVEFORMATEX wfx; WORD wRevision; }; +struct oligsmwaveformat_tag{ WAVEFORMATEX wfx; }; +struct oliadpcmwaveformat_tag{ WAVEFORMATEX wfx; }; +struct olicelpwaveformat_tag{ WAVEFORMATEX wfx; }; +struct olisbcwaveformat_tag{ WAVEFORMATEX wfx; }; +struct olioprwaveformat_tag{ WAVEFORMATEX wfx; }; +struct csimaadpcmwaveformat_tag{ WAVEFORMATEX wfx; }; +struct wavefilter_tag{ DWORD cbStruct; DWORD dwFilterTag; DWORD fdwFilter; DWORD dwReserved[5]; }; +struct wavefilter_volume_tag{ WAVEFILTER wfltr; DWORD dwVolume; }; +struct wavefilter_echo_tag{ WAVEFILTER wfltr; DWORD dwVolume; DWORD dwDelay; }; +struct tag_s_RIFFWAVE_inst{ BYTE bUnshiftedNote; char chFineTune; char chGain; BYTE bLowNote; BYTE bHighNote; BYTE bLowVelocity; BYTE bHighVelocity; }; +struct tag_s_RIFFWAVE_INST{ }; +struct tagEXBMINFOHEADER{ BITMAPINFOHEADER bmi; DWORD biExtDataOffset; }; +struct tagJPEGINFOHEADER{ DWORD JPEGSize; DWORD JPEGProcess; DWORD JPEGColorSpaceID; DWORD JPEGBitsPerSample; DWORD JPEGHSubSampling; DWORD JPEGVSubSampling; }; +struct _tagKSTELEPHONY_CALLCONTROL{ TELEPHONY_CALLTYPE CallType; TELEPHONY_CALLCONTROLOP CallControlOp; }; +struct _tagKSTELEPHONY_PROVIDERCHANGE{ TELEPHONY_CALLTYPE CallType; TELEPHONY_PROVIDERCHANGEOP ProviderChangeOp; }; +struct _tagKSTELEPHONY_CALLINFO{ TELEPHONY_CALLTYPE CallType; TELEPHONY_CALLSTATE CallState; }; +struct _tagKSTOPOLOGY_ENDPOINTID{ WCHAR TopologyName[260]; ULONG PinId; }; +struct _tagKSTOPOLOGY_ENDPOINTIDPAIR{ KSTOPOLOGY_ENDPOINTID RenderEndpoint; KSTOPOLOGY_ENDPOINTID CaptureEndpoint; }; +struct tagKS_RGBQUAD{ BYTE rgbBlue; BYTE rgbGreen; BYTE rgbRed; BYTE rgbReserved; }; +struct tagKS_BITMAPINFOHEADER{ DWORD biSize; LONG biWidth; LONG biHeight; WORD biPlanes; WORD biBitCount; DWORD biCompression; DWORD biSizeImage; LONG biXPelsPerMeter; LONG biYPelsPerMeter; DWORD biClrUsed; DWORD biClrImportant; }; +struct tag_KS_TRUECOLORINFO{ DWORD dwBitMasks[3]; KS_RGBQUAD bmiColors[256]; }; +struct tagKS_VIDEOINFOHEADER{ RECT rcSource; RECT rcTarget; DWORD dwBitRate; DWORD dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; KS_BITMAPINFOHEADER bmiHeader; }; +struct tagKS_VIDEOINFO{ RECT rcSource; RECT rcTarget; DWORD dwBitRate; DWORD dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; KS_BITMAPINFOHEADER bmiHeader; }; +struct tagKS_VBIINFOHEADER{ ULONG StartLine; ULONG EndLine; ULONG SamplingFrequency; ULONG MinLineStartTime; ULONG MaxLineStartTime; ULONG ActualLineStartTime; ULONG ActualLineEndTime; ULONG VideoStandard; ULONG SamplesPerLine; ULONG StrideInBytes; ULONG BufferSize; }; +struct tagKS_AnalogVideoInfo{ RECT rcSource; RECT rcTarget; DWORD dwActiveWidth; DWORD dwActiveHeight; REFERENCE_TIME AvgTimePerFrame; }; +struct tagKS_TVTUNER_CHANGE_INFO{ DWORD dwFlags; DWORD dwCountryCode; DWORD dwAnalogVideoStandard; DWORD dwChannel; }; +struct tagKS_VIDEOINFOHEADER2{ RECT rcSource; RECT rcTarget; DWORD dwBitRate; DWORD dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; DWORD dwInterlaceFlags; DWORD dwCopyProtectFlags; DWORD dwPictAspectRatioX; DWORD dwPictAspectRatioY; DWORD dwReserved2; KS_BITMAPINFOHEADER bmiHeader; }; +struct tagKS_MPEG1VIDEOINFO{ KS_VIDEOINFOHEADER hdr; DWORD dwStartTimeCode; DWORD cbSequenceHeader; BYTE bSequenceHeader[1]; }; +struct tagKS_MPEGVIDEOINFO2{ KS_VIDEOINFOHEADER2 hdr; DWORD dwStartTimeCode; DWORD cbSequenceHeader; DWORD dwProfile; DWORD dwLevel; DWORD dwFlags; DWORD bSequenceHeader[1]; }; +struct tagKS_H264VIDEOINFO{ WORD wWidth; WORD wHeight; WORD wSARwidth; WORD wSARheight; WORD wProfile; BYTE bLevelIDC; WORD wConstrainedToolset; DWORD bmSupportedUsages; WORD bmCapabilities; DWORD bmSVCCapabilities; DWORD bmMVCCapabilities; DWORD dwFrameInterval; BYTE bMaxCodecConfigDelay; BYTE bmSupportedSliceModes; BYTE bmSupportedSyncFrameTypes; BYTE bResolutionScaling; BYTE bSimulcastSupport; BYTE bmSupportedRateControlModes; WORD wMaxMBperSecOneResolutionNoScalability; WORD wMaxMBperSecTwoResolutionsNoScalability; WORD wMaxMBperSecThreeResolutionsNoScalability; WORD wMaxMBperSecFourResolutionsNoScalability; WORD wMaxMBperSecOneResolutionTemporalScalability; WORD wMaxMBperSecTwoResolutionsTemporalScalablility; WORD wMaxMBperSecThreeResolutionsTemporalScalability; WORD wMaxMBperSecFourResolutionsTemporalScalability; WORD wMaxMBperSecOneResolutionTemporalQualityScalability; WORD wMaxMBperSecTwoResolutionsTemporalQualityScalability; WORD wMaxMBperSecThreeResolutionsTemporalQualityScalablity; WORD wMaxMBperSecFourResolutionsTemporalQualityScalability; WORD wMaxMBperSecOneResolutionTemporalSpatialScalability; WORD wMaxMBperSecTwoResolutionsTemporalSpatialScalability; WORD wMaxMBperSecThreeResolutionsTemporalSpatialScalablity; WORD wMaxMBperSecFourResolutionsTemporalSpatialScalability; WORD wMaxMBperSecOneResolutionFullScalability; WORD wMaxMBperSecTwoResolutionsFullScalability; WORD wMaxMBperSecThreeResolutionsFullScalability; WORD wMaxMBperSecFourResolutionsFullScalability; }; +struct tagKS_MPEAUDIOINFO{ DWORD dwFlags; DWORD dwReserved1; DWORD dwReserved2; DWORD dwReserved3; }; +struct tagKS_DATAFORMAT_VIDEOINFOHEADER{ KSDATAFORMAT DataFormat; KS_VIDEOINFOHEADER VideoInfoHeader; }; +struct tagKS_DATAFORMAT_VIDEOINFOHEADER2{ KSDATAFORMAT DataFormat; KS_VIDEOINFOHEADER2 VideoInfoHeader2; }; +struct tagKS_DATAFORMAT_MPEGVIDEOINFO2{ KSDATAFORMAT DataFormat; KS_MPEGVIDEOINFO2 MpegVideoInfoHeader2; }; +struct tagKS_DATAFORMAT_H264VIDEOINFO{ KSDATAFORMAT DataFormat; KS_H264VIDEOINFO H264VideoInfoHeader; }; +struct tagKS_DATAFORMAT_IMAGEINFO{ KSDATAFORMAT DataFormat; KS_BITMAPINFOHEADER ImageInfoHeader; }; +struct tagKS_DATAFORMAT_VIDEOINFO_PALETTE{ KSDATAFORMAT DataFormat; KS_VIDEOINFO VideoInfo; }; +struct tagKS_DATAFORMAT_VBIINFOHEADER{ KSDATAFORMAT DataFormat; KS_VBIINFOHEADER VBIInfoHeader; }; +struct tagKS_DATARANGE_VIDEO{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_VIDEOINFOHEADER VideoInfoHeader; }; +struct tagKS_DATARANGE_VIDEO2{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_VIDEOINFOHEADER2 VideoInfoHeader; }; +struct tagKS_DATARANGE_MPEG1_VIDEO{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_MPEG1VIDEOINFO VideoInfoHeader; }; +struct tagKS_DATARANGE_MPEG2_VIDEO{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_MPEGVIDEOINFO2 VideoInfoHeader; }; +struct tagKS_DATARANGE_H264_VIDEO{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_H264VIDEOINFO VideoInfoHeader; }; +struct tagKS_DATARANGE_IMAGE{ KSDATARANGE DataRange; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_BITMAPINFOHEADER ImageInfoHeader; }; +struct tagKS_DATARANGE_VIDEO_PALETTE{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_VIDEOINFO VideoInfo; }; +struct tagKS_DATARANGE_VIDEO_VBI{ KSDATARANGE DataRange; BOOL bFixedSizeSamples; BOOL bTemporalCompression; DWORD StreamDescriptionFlags; DWORD MemoryAllocationFlags; KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps; KS_VBIINFOHEADER VBIInfoHeader; }; +struct tagKS_DATARANGE_ANALOGVIDEO{ KSDATARANGE DataRange; KS_ANALOGVIDEOINFO AnalogVideoInfo; }; +struct tagKS_FRAME_INFO{ ULONG ExtendedHeaderSize; DWORD dwFrameFlags; LONGLONG PictureNumber; LONGLONG DropCount; HANDLE hDirectDraw; HANDLE hSurfaceHandle; RECT DirectDrawRect; DWORD Reserved2; }; +struct tagKS_VBI_FRAME_INFO{ ULONG ExtendedHeaderSize; DWORD dwFrameFlags; LONGLONG PictureNumber; LONGLONG DropCount; DWORD dwSamplingFrequency; KS_TVTUNER_CHANGE_INFO TvTunerChangeInfo; KS_VBIINFOHEADER VBIInfoHeader; }; +struct tagKSCAMERA_EXTENDEDPROP_HEADER{ ULONG Version; ULONG PinId; ULONG Size; ULONG Result; ULONGLONG Flags; ULONGLONG Capability; }; +struct tagKSCAMERA_EXTENDEDPROP_VALUE{ 68786F69706151465341683153387550713464754B4538536A38773D Value; }; +struct tagKSCAMERA_MAXVIDEOFPS_FORPHOTORES{ ULONG PhotoResWidth; ULONG PhotoResHeight; ULONG PreviewFPSNum; ULONG PreviewFPSDenom; ULONG CaptureFPSNum; ULONG CaptureFPSDenom; }; +struct tagKSCAMERA_EXTENDEDPROP_PHOTOMODE{ ULONG RequestedHistoryFrames; ULONG MaxHistoryFrames; ULONG SubMode; ULONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_VIDEOPROCSETTING{ ULONG Mode; LONG Min; LONG Max; LONG Step; KSCAMERA_EXTENDEDPROP_VALUE VideoProc; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_EVCOMPENSATION{ ULONG Mode; LONG Min; LONG Max; LONG Value; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_FIELDOFVIEW{ ULONG NormalizedFocalLengthX; ULONG NormalizedFocalLengthY; ULONG Flag; ULONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_CAMERAOFFSET{ LONG PitchAngle; LONG YawAngle; ULONG Flag; ULONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_METADATAINFO{ LONG BufferAlignment; ULONG MaxMetadataBufferSize; }; +struct tagKSCAMERA_METADATA_ITEMHEADER{ ULONG MetadataId; ULONG Size; }; +struct tagKSCAMERA_METADATA_PHOTOCONFIRMATION{ KSCAMERA_METADATA_ITEMHEADER Header; ULONG PhotoConfirmationIndex; ULONG Reserved; }; +struct tagKSCAMERA_METADATA_FRAMEILLUMINATION{ KSCAMERA_METADATA_ITEMHEADER Header; ULONG Flags; ULONG Reserved; }; +struct tagKSCAMERA_METADATA_CAPTURESTATS{ KSCAMERA_METADATA_ITEMHEADER Header; ULONG Flags; ULONG Reserved; ULONGLONG ExposureTime; ULONGLONG ExposureCompensationFlags; LONG ExposureCompensationValue; ULONG IsoSpeed; ULONG FocusState; ULONG LensPosition; ULONG WhiteBalance; ULONG Flash; ULONG FlashPower; ULONG ZoomFactor; ULONGLONG SceneMode; ULONGLONG SensorFramerate; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPSHEADER{ ULONG Size; ULONG ConfigCapCount; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_CONFIGCAPS{ ULONG ControlId; ULONG MaxNumberOfROIs; ULONGLONG Capability; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_ISPCONTROLHEADER{ ULONG Size; ULONG ControlCount; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_ISPCONTROL{ ULONG ControlId; ULONG ROICount; ULONG Result; ULONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_INFO{ RECT Region; ULONGLONG Flags; LONG Weight; LONG RegionOfInterestType; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_WHITEBALANCE{ KSCAMERA_EXTENDEDPROP_ROI_INFO ROIInfo; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_EXPOSURE{ KSCAMERA_EXTENDEDPROP_ROI_INFO ROIInfo; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_ROI_FOCUS{ KSCAMERA_EXTENDEDPROP_ROI_INFO ROIInfo; ULONGLONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_SETTING{ LONG OriginX; LONG OriginY; LONG WindowSize; ULONG Reserved; }; +struct tagKSCAMERA_METADATA_DIGITALWINDOW{ KSCAMERA_METADATA_ITEMHEADER Header; KSCAMERA_EXTENDEDPROP_DIGITALWINDOW_SETTING Window; }; +struct tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPSHEADER{ ULONG Size; ULONG Count; }; +struct tagKSCAMERA_EXTENDEDPROP_DIGITALWINDOW_CONFIGCAPS{ LONG ResolutionX; LONG ResolutionY; LONG PorchTop; LONG PorchLeft; LONG PorchBottom; LONG PorchRight; LONG NonUpscalingWindowSize; LONG MinWindowSize; LONG MaxWindowSize; LONG Reserved; }; +struct tagKSCAMERA_EXTENDEDPROP_BACKGROUNDSEGMENTATION_CONFIGCAPS{ SIZE Resolution; 48364E71344558395034755758627A6C5950453932674D62744F383D MaxFrameRate; SIZE MaskResolution; GUID SubType; }; +struct tagKSCAMERA_METADATA_BACKGROUNDSEGMENTATIONMASK{ KSCAMERA_METADATA_ITEMHEADER Header; RECT MaskCoverageBoundingBox; SIZE MaskResolution; RECT ForegroundBoundingBox; BYTE MaskData[1]; }; +struct tagDEVCAPS{ LONG CanRecord; LONG CanRecordStrobe; LONG HasAudio; LONG HasVideo; LONG UsesFiles; LONG CanSave; LONG DeviceType; LONG TCRead; LONG TCWrite; LONG CTLRead; LONG IndexRead; LONG Preroll; LONG Postroll; LONG SyncAcc; LONG NormRate; LONG CanPreview; LONG CanMonitorSrc; LONG CanTest; LONG VideoIn; LONG AudioIn; LONG Calibrate; LONG SeekType; LONG SimulatedHardware; }; +struct tagTRANSPORTSTATUS{ LONG Mode; LONG LastError; LONG RecordInhibit; LONG ServoLock; LONG MediaPresent; LONG MediaLength; LONG MediaSize; LONG MediaTrackCount; LONG MediaTrackLength; LONG MediaTrackSide; LONG MediaType; LONG LinkMode; LONG NotifyOn; }; +struct tagTRANSPORTBASICPARMS{ LONG TimeFormat; LONG TimeReference; LONG Superimpose; LONG EndStopAction; LONG RecordFormat; LONG StepFrames; LONG SetpField; LONG Preroll; LONG RecPreroll; LONG Postroll; LONG EditDelay; LONG PlayTCDelay; LONG RecTCDelay; LONG EditField; LONG FrameServo; LONG ColorFrameServo; LONG ServoRef; LONG WarnGenlock; LONG SetTracking; TCHAR VolumeName[40]; LONG Ballistic[20]; LONG Speed; LONG CounterFormat; LONG TunerChannel; LONG TunerNumber; LONG TimerEvent; LONG TimerStartDay; LONG TimerStartTime; LONG TimerStopDay; LONG TimerStopTime; }; +struct tagTRANSPORTVIDEOPARMS{ LONG OutputMode; LONG Input; }; +struct tagTRANSPORTAUDIOPARMS{ LONG EnableOutput; LONG EnableRecord; LONG EnableSelsync; LONG Input; LONG MonitorSource; }; +struct tagTIMECODE_SAMPLE{ LONGLONG qwTick; TIMECODE timecode; DWORD dwUser; DWORD dwFlags; }; +struct tagKS_AMVPDIMINFO{ DWORD dwFieldWidth; DWORD dwFieldHeight; DWORD dwVBIWidth; DWORD dwVBIHeight; RECT rcValidRegion; }; +struct tagKS_AMVPDATAINFO{ DWORD dwSize; DWORD dwMicrosecondsPerField; KS_AMVPDIMINFO amvpDimInfo; DWORD dwPictAspectRatioX; DWORD dwPictAspectRatioY; BOOL bEnableDoubleClock; BOOL bEnableVACT; BOOL bDataIsInterlaced; LONG lHalfLinesOdd; BOOL bFieldPolarityInverted; DWORD dwNumLinesInVREF; LONG lHalfLinesEven; DWORD dwReserved1; }; +struct tagKS_AMVPSIZE{ DWORD dwWidth; DWORD dwHeight; }; +struct _tagKSJACK_SINK_INFORMATION{ KSJACK_SINK_CONNECTIONTYPE ConnType; WORD ManufacturerId; WORD ProductId; WORD AudioLatency; BOOL HDCPCapable; BOOL AICapable; UCHAR SinkDescriptionLength; WCHAR SinkDescription[32]; LUID PortId; }; +struct _tagKSJACK_DESCRIPTION2{ DWORD DeviceStateInfo; DWORD JackCapabilities; }; +struct _tagKSJACK_DESCRIPTION3{ ULONG ConfigId; }; +struct _tagKSAUDIOENGINE_DESCRIPTOR{ UINT nHostPinId; UINT nOffloadPinId; UINT nLoopbackPinId; }; +struct _tagKSAUDIOENGINE_BUFFER_SIZE_RANGE{ ULONG MinBufferBytes; ULONG MaxBufferBytes; }; +struct _tagKSAUDIOENGINE_VOLUMELEVEL{ LONG TargetVolume; AUDIO_CURVE_TYPE CurveType; ULONGLONG CurveDuration; }; +struct _tagKSAUDIOENGINE_DEVICECONTROLS{ EDeviceControlUseType Volume; EDeviceControlUseType Mute; EDeviceControlUseType PeakMeter; }; +struct tagKSATTRIBUTE_AUDIOSIGNALPROCESSING_MODE{ KSATTRIBUTE AttributeHeader; GUID SignalProcessingMode; }; +enum _tagAvcCommandType{ AVC_CTYPE_CONTROL = 0, AVC_CTYPE_STATUS = 1, AVC_CTYPE_SPEC_INQ = 2, AVC_CTYPE_NOTIFY = 3, AVC_CTYPE_GEN_INQ = 4 }; +enum _tagAvcResponseCode{ AVC_RESPONSE_NOTIMPL = 8, AVC_RESPONSE_ACCEPTED = 9, AVC_RESPONSE_REJECTED = 10, AVC_RESPONSE_IN_TRANSITION = 11, AVC_RESPONSE_STABLE = 12, AVC_RESPONSE_IMPLEMENTED = 12, AVC_RESPONSE_CHANGED = 13, AVC_RESPONSE_INTERIM = 15 }; +enum _tagAvcSubunitType{ AVC_SUBUNITTYPE_VIDEO_MONITOR = 0, AVC_SUBUNITTYPE_AUDIO = 1, AVC_SUBUNITTYPE_PRINTER = 2, AVC_SUBUNITTYPE_DISC_PLAYER = 3, AVC_SUBUNITTYPE_TAPE_PLAYER = 4, AVC_SUBUNITTYPE_TUNER = 5, AVC_SUBUNITTYPE_CA = 6, AVC_SUBUNITTYPE_VIDEO_CAMERA = 7, AVC_SUBUNITTYPE_PANEL = 9, AVC_SUBUNITTYPE_BULLETINBOARD = 10, AVC_SUBUNITTYPE_CAMERASTORAGE = 11, AVC_SUBUNITTYPE_VENDOR_UNIQUE = 28, AVC_SUBUNITTYPE_EXTENDED = 30, AVC_SUBUNITTYPE_EXTENDED_FULL = 255, AVC_SUBUNITTYPE_UNIT = 31 }; +struct tagKS_DATARANGE_DVVIDEO{ KSDATARANGE DataRange; DVINFO DVVideoInfo; }; +union _tagCommandData{ KSSTATE StreamState; AVCSTRM_OPEN_STRUCT OpenStruct; AVCSTRM_BUFFER_STRUCT BufferStruct; }; +struct tagVIDEO_MONITOR_DESCRIPTOR{ ULONG DescriptorSize; UCHAR Descriptor[1]; }; +struct tagDRMRIGHTS{ BOOL CopyProtect; ULONG Reserved; BOOL DigitalOutputDisable; }; +struct tagWNODE_ALL_DATA{ _WNODE_HEADER WnodeHeader; ULONG DataBlockOffset; ULONG InstanceCount; ULONG OffsetInstanceNameOffsets; }; +struct tagWNODE_SINGLE_INSTANCE{ _WNODE_HEADER WnodeHeader; ULONG OffsetInstanceName; ULONG InstanceIndex; ULONG DataBlockOffset; ULONG SizeDataBlock; UCHAR VariableData; }; +struct tagWNODE_SINGLE_ITEM{ _WNODE_HEADER WnodeHeader; ULONG OffsetInstanceName; ULONG InstanceIndex; ULONG ItemId; ULONG DataBlockOffset; ULONG SizeDataItem; UCHAR VariableData; }; +struct tagWNODE_METHOD_ITEM{ _WNODE_HEADER WnodeHeader; ULONG OffsetInstanceName; ULONG InstanceIndex; ULONG MethodId; ULONG DataBlockOffset; ULONG SizeDataBlock; UCHAR VariableData; }; +struct tagWNODE_EVENT_ITEM{ _WNODE_HEADER WnodeHeader; }; +struct tagWNODE_EVENT_REFERENCE{ _WNODE_HEADER WnodeHeader; GUID TargetGuid; ULONG TargetDataBlockSize; }; +struct tagWNODE_TOO_SMALL{ _WNODE_HEADER WnodeHeader; ULONG SizeNeeded; }; +typedef SecPkgContext_DatagramSizes SecPkgContext_StreamSizes; +typedef PSecPkgContext_DatagramSizes PSecPkgContext_StreamSizes; +NTSTATUS FltUntagFile( PFLT_INSTANCE InitiatingInstance, PFILE_OBJECT FileObject, ULONG FileTag, GUID* Guid ); +struct _tagKSKSTELEPHONY_DESCRIPTOR{ UINT nRenderPinId; UINT nCapturePinId; }; +struct _tagKSKSTELEPHONY_INSTANCE_DATA{ TELEPHONY_PROVIDER_TYPE TelephonyProviderType; UINT TelephonyProviderId; }; +struct tag_video_open_parms{ ULONG dwSize; FOURCC fccType; FOURCC fccComp; ULONG dwVersion; ULONG dwFlags; ULONG dwError; LPVOID pV1Reserved; LPVOID pV2Reserved; ULONG dnDevNode; }; +struct tag_video_geterrortext_parms{ ULONG dwError; LPWSTR lpText; ULONG dwLength; }; +struct tag_video_stream_init_parms{ ULONG dwMicroSecPerFrame; ULONG dwCallback; ULONG dwCallbackInst; ULONG dwFlags; HANDLE hVideo; }; +struct tag_video_configure_parms{ LPDWORD lpdwReturn; LPVOID lpData1; ULONG dwSize1; LPVOID lpData2; ULONG dwSize2; }; +NTSTATUS RxCeSendDatagram( PRXCE_ADDRESS hAddress, PRXCE_CONNECTION_INFORMATION pConnectionInformation, ULONG SendOptions, PMDL pMdl, ULONG SendLength, PVOID pCompletionContext ); +struct tagMFASYNCRESULT{ IMFAsyncResult AsyncResult; OVERLAPPED overlapped; IMFAsyncCallback* pCallback; HRESULT hrStatusResult; ULONG dwBytesTransferred; HANDLE hEvent; }; +struct tagDigitalWindowSetting{ double OriginX; double OriginY; double WindowSize; }; +struct tagFaceRectInfoBlobHeader{ ULONG Size; ULONG Count; }; +struct tagFaceRectInfo{ RECT Region; LONG confidenceLevel; }; +struct tagFaceCharacterizationBlobHeader{ ULONG Size; ULONG Count; }; +struct tagFaceCharacterization{ ULONG BlinkScoreLeft; ULONG BlinkScoreRight; ULONG FacialExpression; ULONG FacialExpressionScore; }; +struct tagCapturedMetadataExposureCompensation{ UINT64 Flags; INT32 Value; }; +struct tagCapturedMetadataISOGains{ FLOAT AnalogGain; FLOAT DigitalGain; }; +struct tagCapturedMetadataWhiteBalanceGains{ FLOAT R; FLOAT G; FLOAT B; }; +struct tagMetadataTimeStamps{ ULONG Flags; LONGLONG Device; LONGLONG Presentation; }; +struct tagHistogramGrid{ ULONG Width; ULONG Height; RECT Region; }; +struct tagHistogramBlobHeader{ ULONG Size; ULONG Histograms; }; +struct tagHistogramHeader{ ULONG Size; ULONG Bins; ULONG FourCC; ULONG ChannelMasks; HistogramGrid Grid; }; +struct tagHistogramDataHeader{ ULONG Size; ULONG ChannelMask; ULONG Linear; }; +struct tagVIDEOINFOHEADER{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; BITMAPINFOHEADER bmiHeader; }; +struct tagVIDEOINFOHEADER2{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; ULONG dwInterlaceFlags; ULONG dwCopyProtectFlags; ULONG dwPictAspectRatioX; ULONG dwPictAspectRatioY; ULONG dwReserved2; BITMAPINFOHEADER bmiHeader; }; +struct tagMPEG1VIDEOINFO{ VIDEOINFOHEADER hdr; ULONG dwStartTimeCode; ULONG cbSequenceHeader; UCHAR bSequenceHeader[1]; }; +struct tagMPEG2VIDEOINFO{ VIDEOINFOHEADER2 hdr; ULONG dwStartTimeCode; ULONG cbSequenceHeader; ULONG dwProfile; ULONG dwLevel; ULONG dwFlags; ULONG dwSequenceHeader[1]; }; +NTSTATUS TdiDefaultRcvDatagramHandler( PVOID TdiEventContext, LONG SourceAddressLength, PVOID SourceAddress, LONG OptionsLength, PVOID Options, ULONG ReceiveDatagramFlags, ULONG BytesIndicated, ULONG BytesAvailable, ULONG* BytesTaken, PVOID Tsdu, PIRP* IoRequestPacket ); +NTSTATUS TdiDefaultChainedRcvDatagramHandler( PVOID TdiEventContext, LONG SourceAddressLength, PVOID SourceAddress, LONG OptionsLength, PVOID Options, ULONG ReceiveDatagramFlags, ULONG ReceiveDatagramLength, ULONG StartingOffset, PMDL Tsdu, PVOID TsduDescriptor ); +struct tagACT_AUTHZ_STATE{ UCHAR ACT; BOOLEAN fAuthorized; }; +struct tagACT_QUEUE_STATE{ BOOLEAN fFrozen; }; +struct tagSILO_COMMAND{ UCHAR SiloIndex; UCHAR Command; ULONG cbCommandBuffer; UCHAR rgbCommandBuffer[1]; }; +typedef __x_ABI_CWindows_CStorage_CFileProperties_CIGeotagHelperStatics __x_ABI_CWindows_CStorage_CFileProperties_CIGeotagHelperStatics; +typedef __x_ABI_CWindows_CStorage_CFileProperties_CIGeotagHelperStaticsVtbl __x_ABI_CWindows_CStorage_CFileProperties_CIGeotagHelperStaticsVtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket2 __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket2; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket3 __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket3; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl2 __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl2; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl3 __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl3; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketInformation __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketInformation; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketMessageReceivedEventArgs __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketMessageReceivedEventArgs; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketStatics __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketStatics; +typedef __FITypedEventHandler_2_Windows__CNetworking__CSockets__CDatagramSocket_Windows__CNetworking__CSock __FITypedEventHandler_2_Windows__CNetworking__CSockets__CDatagramSocket_Windows__CNetworking__CSock; +typedef __FITypedEventHandler_2_Windows__CNetworking__CSockets__CDatagramSocket_Windows__CNetworking__CSock __FITypedEventHandler_2_Windows__CNetworking__CSockets__CDatagramSocket_Windows__CNetworking__CSock; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketVtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketVtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket2Vtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket2Vtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket3Vtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocket3Vtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControlVtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControlVtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl2Vtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl2Vtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl3Vtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketControl3Vtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketInformationVtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketInformationVtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketMessageReceivedEventArgsVtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketMessageReceivedEventArgsVtbl; +typedef __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketStaticsVtbl __x_ABI_CWindows_CNetworking_CSockets_CIDatagramSocketStaticsVtbl; +typedef __x_ABI_CWindows_CWeb_CHttp_CHttpProgressStage __x_ABI_CWindows_CWeb_CHttp_CHttpProgressStage; +typedef __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReference __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReference; +typedef __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceStatics __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceStatics; +typedef __FIAsyncOperationCompletedHandler_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReference __FIAsyncOperationCompletedHandler_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReference; +typedef __FIAsyncOperation_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReference __FIAsyncOperation_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReference; +typedef __FIAsyncOperation_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReferenceVtbl __FIAsyncOperation_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReferenceVtbl; +typedef __FIAsyncOperationCompletedHandler_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReferenceV __FIAsyncOperationCompletedHandler_1_Windows__CPerception__CSpatial__CSpatialStageFrameOfReferenceV; +typedef __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceVtbl __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceVtbl; +typedef __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceStaticsVtbl __x_ABI_CWindows_CPerception_CSpatial_CISpatialStageFrameOfReferenceStaticsVtbl; +typedef __x_ABI_CWindows_CApplicationModel_CIPackageContentGroupStagingEventArgs __x_ABI_CWindows_CApplicationModel_CIPackageContentGroupStagingEventArgs; +typedef __x_ABI_CWindows_CApplicationModel_CIPackageStagingEventArgs __x_ABI_CWindows_CApplicationModel_CIPackageStagingEventArgs; +typedef __x_ABI_CWindows_CApplicationModel_CIPackageContentGroupStagingEventArgsVtbl __x_ABI_CWindows_CApplicationModel_CIPackageContentGroupStagingEventArgsVtbl; +typedef __x_ABI_CWindows_CApplicationModel_CIPackageStagingEventArgsVtbl __x_ABI_CWindows_CApplicationModel_CIPackageStagingEventArgsVtbl; +typedef __x_ABI_CWindows_CGlobalization_CILanguageExtensionSubtags __x_ABI_CWindows_CGlobalization_CILanguageExtensionSubtags; +typedef __x_ABI_CWindows_CGlobalization_CILanguageExtensionSubtagsVtbl __x_ABI_CWindows_CGlobalization_CILanguageExtensionSubtagsVtbl; +enum _tag_ARM64INTR_BARRIER_TYPE{ _ARM64_BARRIER_SY = 15, _ARM64_BARRIER_ST = 14, _ARM64_BARRIER_LD = 13, _ARM64_BARRIER_ISH = 11, _ARM64_BARRIER_ISHST = 10, _ARM64_BARRIER_ISHLD = 9, _ARM64_BARRIER_NSH = 7, _ARM64_BARRIER_NSHST = 6, _ARM64_BARRIER_NSHLD = 5, _ARM64_BARRIER_OSH = 3, _ARM64_BARRIER_OSHST = 2, _ARM64_BARRIER_OSHLD = 1 }; +enum _tag_ARMINTR_SHIFT_T{ _ARM_LSR = 0, _ARM_LSL = 1, _ARM_ASR = 2, _ARM_ROR = 3 }; +enum _tag_ARMINTR_CPS_OP{ _ARM_CPS_ENABLE_INTERRUPTS = 1, _ARM_CPS_DISABLE_INTERRUPTS = 2, _ARM_CPS_CHANGE_MODE = 4 }; +enum _tag_ARMINTR_CPS_FLAG{ _ARM_CPS_INTERRUPT_FLAG_F = 1, _ARM_CPS_INTERRUPT_FLAG_I = 2, _ARM_CPS_INTERRUPT_FLAG_A = 4 }; +enum _tag_ARMINTR_BARRIER_TYPE{ _ARM_BARRIER_SY = 15, _ARM_BARRIER_ST = 14, _ARM_BARRIER_ISH = 11, _ARM_BARRIER_ISHST = 10, _ARM_BARRIER_NSH = 7, _ARM_BARRIER_NSHST = 6, _ARM_BARRIER_OSH = 3, _ARM_BARRIER_OSHST = 2 }; +enum _tag_ARMINTR_BANKED_REG{ _ARM_BANKED_R8_USR = 0, _ARM_BANKED_R9_USR = 1, _ARM_BANKED_R10_USR = 2, _ARM_BANKED_R11_USR = 3, _ARM_BANKED_R12_USR = 4, _ARM_BANKED_R13_USR = 5, _ARM_BANKED_SP_USR = 5, _ARM_BANKED_R14_USR = 6, _ARM_BANKED_LR_USR = 6, _ARM_BANKED_R8_FIQ = 8, _ARM_BANKED_R9_FIQ = 9, _ARM_BANKED_R10_FIQ = 10, _ARM_BANKED_R11_FIQ = 11, _ARM_BANKED_R12_FIQ = 12, _ARM_BANKED_R13_FIQ = 13, _ARM_BANKED_SP_FIQ = 13, _ARM_BANKED_R14_FIQ = 14, _ARM_BANKED_LR_FIQ = 14, _ARM_BANKED_R14_IRQ = 16, _ARM_BANKED_LR_IRQ = 16, _ARM_BANKED_R13_IRQ = 17, _ARM_BANKED_SP_IRQ = 17, _ARM_BANKED_R14_SVC = 18, _ARM_BANKED_LR_SVC = 18, _ARM_BANKED_R13_SVC = 19, _ARM_BANKED_SP_SVC = 19, _ARM_BANKED_R14_ABT = 20, _ARM_BANKED_LR_ABT = 20, _ARM_BANKED_R13_ABT = 21, _ARM_BANKED_SP_ABT = 21, _ARM_BANKED_R14_UND = 22, _ARM_BANKED_LR_UND = 22, _ARM_BANKED_R13_UND = 23, _ARM_BANKED_SP_UND = 23, _ARM_BANKED_R14_MON = 28, _ARM_BANKED_LR_MON = 28, _ARM_BANKED_R13_MON = 29, _ARM_BANKED_SP_MON = 29, _ARM_BANKED_ELR_HYP = 30, _ARM_BANKED_R13_HYP = 31, _ARM_BANKED_SP_HYP = 31, _ARM_BANKED_SPSR_FIQ = 46, _ARM_BANKED_SPSR_IRQ = 48, _ARM_BANKED_SPSR_SVC = 50, _ARM_BANKED_SPSR_ABT = 52, _ARM_BANKED_SPSR_UND = 54, _ARM_BANKED_SPSR_MON = 60, _ARM_BANKED_SPSR_HYP = 62 }; +struct tagLC_ID{ unsigned short wLanguage; unsigned short wCountry; unsigned short wCodePage; }; +struct tagKS_DATARANGE_BDA_ANTENNA{ KSDATARANGE DataRange; }; +struct tagBDA_TRANSPORT_INFO{ ULONG ulcbPhyiscalPacket; ULONG ulcbPhyiscalFrame; ULONG ulcbPhyiscalFrameAlignment; REFERENCE_TIME AvgTimePerFrame; }; +struct tagKS_DATARANGE_BDA_TRANSPORT{ KSDATARANGE DataRange; BDA_TRANSPORT_INFO BdaTransportInfo; }; +struct tagKS_BDA_FRAME_INFO{ ULONG ExtendedHeaderSize; ULONG dwFrameFlags; ULONG ulEvent; ULONG ulChannelNumber; ULONG ulSubchannelNumber; ULONG ulReason; }; +enum tagScanModulationTypes{ BDA_SCAN_MOD_16QAM = 1, BDA_SCAN_MOD_32QAM = 2, BDA_SCAN_MOD_64QAM = 4, BDA_SCAN_MOD_80QAM = 8, BDA_SCAN_MOD_96QAM = 16, BDA_SCAN_MOD_112QAM = 32, BDA_SCAN_MOD_128QAM = 64, BDA_SCAN_MOD_160QAM = 128, BDA_SCAN_MOD_192QAM = 256, BDA_SCAN_MOD_224QAM = 512, BDA_SCAN_MOD_256QAM = 1024, BDA_SCAN_MOD_320QAM = 2048, BDA_SCAN_MOD_384QAM = 4096, BDA_SCAN_MOD_448QAM = 8192, BDA_SCAN_MOD_512QAM = 16384, BDA_SCAN_MOD_640QAM = 32768, BDA_SCAN_MOD_768QAM = 65536, BDA_SCAN_MOD_896QAM = 131072, BDA_SCAN_MOD_1024QAM = 262144, BDA_SCAN_MOD_QPSK = 524288, BDA_SCAN_MOD_BPSK = 1048576, BDA_SCAN_MOD_OQPSK = 2097152, BDA_SCAN_MOD_8VSB = 4194304, BDA_SCAN_MOD_16VSB = 8388608, BDA_SCAN_MOD_AM_RADIO = 16777216, BDA_SCAN_MOD_FM_RADIO = 33554432, BDA_SCAN_MOD_8PSK = 67108864, BDA_SCAN_MOD_RF = 134217728, ScanModulationTypesMask_MCE_DigitalCable = 11, ScanModulationTypesMask_MCE_TerrestrialATSC = 23, ScanModulationTypesMask_MCE_AnalogTv = 28, ScanModulationTypesMask_MCE_All_TV = 4294967295, ScanModulationTypesMask_DVBC = 75, BDA_SCAN_MOD_16APSK = 268435456, BDA_SCAN_MOD_32APSK = 536870912 }; +struct tagCOMPOSITION_FRAME_STATS{ UINT64 startTime; UINT64 targetTime; UINT64 framePeriod; }; +struct tagCOMPOSITION_TARGET_ID{ LUID displayAdapterLuid; LUID renderAdapterLuid; UINT vidPnSourceId; UINT vidPnTargetId; UINT uniqueId; }; +struct tagCOMPOSITION_STATS{ UINT presentCount; UINT refreshCount; UINT virtualRefreshCount; UINT64 time; }; +struct tagCOMPOSITION_TARGET_STATS{ UINT outstandingPresents; UINT64 presentTime; UINT64 vblankDuration; COMPOSITION_STATS presentedStats; COMPOSITION_STATS completedStats; }; +struct joypos_tag{ ULONG dwX; ULONG dwY; ULONG dwZ; ULONG dwR; ULONG dwU; ULONG dwV; }; +struct joyrange_tag{ JOYPOS jpMin; JOYPOS jpMax; JOYPOS jpCenter; }; +struct joyreguservalues_tag{ ULONG dwTimeOut; JOYRANGE jrvRanges; JOYPOS jpDeadZone; }; +struct joyreghwsettings_tag{ ULONG dwFlags; ULONG dwNumButtons; }; +struct joyreghwvalues_tag{ JOYRANGE jrvHardware; ULONG dwPOVValues[4]; ULONG dwCalFlags; }; +struct joyreghwconfig_tag{ JOYREGHWSETTINGS hws; ULONG dwUsageSettings; JOYREGHWVALUES hwv; ULONG dwType; ULONG dwReserved; }; +struct joycalibrate_tag{ UINT wXbase; UINT wXdelta; UINT wYbase; UINT wYdelta; UINT wZbase; UINT wZdelta; }; +struct tagKSP_PINMODE{ KSP_PIN PinProperty; GUID AudioProcessingMode; }; +enum tagSFBS_FLAGS{ SFBS_FLAGS_ROUND_TO_NEAREST_DISPLAYED_DIGIT = 1, SFBS_FLAGS_TRUNCATE_UNDISPLAYED_DECIMAL_DIGITS = 2 }; +struct tagPARSEDURLA{ ULONG cbSize; LPCSTR pszProtocol; UINT cchProtocol; LPCSTR pszSuffix; UINT cchSuffix; UINT nScheme; }; +struct tagPARSEDURLW{ ULONG cbSize; LPCWSTR pszProtocol; UINT cchProtocol; LPCWSTR pszSuffix; UINT cchSuffix; UINT nScheme; }; +enum tagPSTIME_FLAGS{ PSTF_UTC = 0, PSTF_LOCAL = 1 }; +enum tagPROPVAR_COMPARE_FLAGS{ PVCF_DEFAULT = 0, PVCF_TREATEMPTYASGREATERTHAN = 1, PVCF_USESTRCMP = 2, PVCF_USESTRCMPC = 4, PVCF_USESTRCMPI = 8, PVCF_USESTRCMPIC = 16, PVCF_DIGITSASNUMBERS_CASESENSITIVE = 32 }; +enum tagPROPVAR_CHANGE_FLAGS{ PVCHF_DEFAULT = 0, PVCHF_NOVALUEPROP = 1, PVCHF_ALPHABOOL = 2, PVCHF_NOUSEROVERRIDE = 4, PVCHF_LOCALBOOL = 8, PVCHF_NOHEXSTRING = 16 }; +struct tagINITCOMMONCONTROLSEX{ ULONG dwSize; ULONG dwICC; }; +struct tagCOLORSCHEME{ ULONG dwSize; COLORREF clrBtnHighlight; COLORREF clrBtnShadow; }; +struct tagNMTOOLTIPSCREATED{ NMHDR hdr; HWND hwndToolTips; }; +struct tagNMMOUSE{ NMHDR hdr; DWORD_PTR dwItemSpec; DWORD_PTR dwItemData; POINT pt; LPARAM dwHitInfo; }; +struct tagNMOBJECTNOTIFY{ NMHDR hdr; int iItem; IID* piid; void* pObject; HRESULT hResult; ULONG dwFlags; }; +struct tagNMKEY{ NMHDR hdr; UINT nVKey; UINT uFlags; }; +struct tagNMCHAR{ NMHDR hdr; UINT ch; ULONG dwItemPrev; ULONG dwItemNext; }; +struct tagNMCUSTOMTEXT{ NMHDR hdr; HDC hDC; LPCWSTR lpString; int nCount; LPRECT lpRect; UINT uFormat; BOOL fLink; }; +struct tagNMCUSTOMDRAWINFO{ NMHDR hdr; ULONG dwDrawStage; HDC hdc; RECT rc; DWORD_PTR dwItemSpec; UINT uItemState; LPARAM lItemlParam; }; +struct tagNMTTCUSTOMDRAW{ NMCUSTOMDRAW nmcd; UINT uDrawFlags; }; +struct tagNMCUSTOMSPLITRECTINFO{ NMHDR hdr; RECT rcClient; RECT rcButton; RECT rcSplit; }; +struct tagNMHEADERA{ NMHDR hdr; int iItem; int iButton; HDITEMA* pitem; }; +struct tagNMHEADERW{ NMHDR hdr; int iItem; int iButton; HDITEMW* pitem; }; +struct tagNMHDDISPINFOW{ NMHDR hdr; int iItem; UINT mask; LPWSTR pszText; int cchTextMax; int iImage; LPARAM lParam; }; +struct tagNMHDDISPINFOA{ NMHDR hdr; int iItem; UINT mask; LPSTR pszText; int cchTextMax; int iImage; LPARAM lParam; }; +struct tagNMHDFILTERBTNCLICK{ NMHDR hdr; INT iItem; RECT rc; }; +struct tagTBADDBITMAP{ HINSTANCE hInst; UINT_PTR nID; }; +struct tagTBSAVEPARAMSA{ HKEY hkr; LPCSTR pszSubKey; LPCSTR pszValueName; }; +struct tagTBSAVEPARAMSW{ HKEY hkr; LPCWSTR pszSubKey; LPCWSTR pszValueName; }; +struct tagNMTBHOTITEM{ NMHDR hdr; int idOld; int idNew; ULONG dwFlags; }; +struct tagNMTBSAVE{ NMHDR hdr; ULONG* pData; ULONG* pCurrent; UINT cbData; int iItem; int cButtons; TBBUTTON tbButton; }; +struct tagNMTBRESTORE{ NMHDR hdr; ULONG* pData; ULONG* pCurrent; UINT cbData; int iItem; int cButtons; int cbBytesPerRecord; TBBUTTON tbButton; }; +struct tagNMTBGETINFOTIPA{ NMHDR hdr; LPSTR pszText; int cchTextMax; int iItem; LPARAM lParam; }; +struct tagNMTBGETINFOTIPW{ NMHDR hdr; LPWSTR pszText; int cchTextMax; int iItem; LPARAM lParam; }; +struct tagNMTOOLBARA{ NMHDR hdr; int iItem; TBBUTTON tbButton; int cchText; LPSTR pszText; RECT rcButton; }; +struct tagNMTOOLBARW{ NMHDR hdr; int iItem; TBBUTTON tbButton; int cchText; LPWSTR pszText; RECT rcButton; }; +struct tagREBARINFO{ UINT cbSize; UINT fMask; HIMAGELIST himl; }; +struct tagREBARBANDINFOA{ UINT cbSize; UINT fMask; UINT fStyle; COLORREF clrFore; COLORREF clrBack; LPSTR lpText; UINT cch; int iImage; HWND hwndChild; UINT cxMinChild; UINT cyMinChild; UINT cx; HBITMAP hbmBack; UINT wID; UINT cyChild; UINT cyMaxChild; UINT cyIntegral; UINT cxIdeal; LPARAM lParam; UINT cxHeader; RECT rcChevronLocation; UINT uChevronState; }; +struct tagREBARBANDINFOW{ UINT cbSize; UINT fMask; UINT fStyle; COLORREF clrFore; COLORREF clrBack; LPWSTR lpText; UINT cch; int iImage; HWND hwndChild; UINT cxMinChild; UINT cyMinChild; UINT cx; HBITMAP hbmBack; UINT wID; UINT cyChild; UINT cyMaxChild; UINT cyIntegral; UINT cxIdeal; LPARAM lParam; UINT cxHeader; RECT rcChevronLocation; UINT uChevronState; }; +struct tagNMREBARCHILDSIZE{ NMHDR hdr; UINT uBand; UINT wID; RECT rcChild; RECT rcBand; }; +struct tagNMREBAR{ NMHDR hdr; ULONG dwMask; UINT uBand; UINT fStyle; UINT wID; LPARAM lParam; }; +struct tagNMRBAUTOSIZE{ NMHDR hdr; BOOL fChanged; RECT rcTarget; RECT rcActual; }; +struct tagNMREBARCHEVRON{ NMHDR hdr; UINT uBand; UINT wID; LPARAM lParam; RECT rc; LPARAM lParamNM; }; +struct tagNMREBARSPLITTER{ NMHDR hdr; RECT rcSizing; }; +struct tagNMREBARAUTOBREAK{ NMHDR hdr; UINT uBand; UINT wID; LPARAM lParam; UINT uMsg; UINT fStyleCurrent; BOOL fAutoBreak; }; +struct tagTOOLINFOA{ UINT cbSize; UINT uFlags; HWND hwnd; UINT_PTR uId; RECT rect; HINSTANCE hinst; LPSTR lpszText; LPARAM lParam; void* lpReserved; }; +struct tagTOOLINFOW{ UINT cbSize; UINT uFlags; HWND hwnd; UINT_PTR uId; RECT rect; HINSTANCE hinst; LPWSTR lpszText; LPARAM lParam; void* lpReserved; }; +struct tagNMTTDISPINFOA{ NMHDR hdr; LPSTR lpszText; char szText[80]; HINSTANCE hinst; UINT uFlags; LPARAM lParam; }; +struct tagNMTTDISPINFOW{ NMHDR hdr; LPWSTR lpszText; WCHAR szText[80]; HINSTANCE hinst; UINT uFlags; LPARAM lParam; }; +struct tagTRBTHUMBPOSCHANGING{ NMHDR hdr; ULONG dwPos; int nReason; }; +struct tagDRAGLISTINFO{ UINT uNotification; HWND hWnd; POINT ptCursor; }; +struct tagLITEM{ UINT mask; int iLink; UINT state; UINT stateMask; WCHAR szID[48]; WCHAR szUrl[2084]; }; +struct tagLHITTESTINFO{ POINT pt; LITEM item; }; +struct tagNMLINK{ NMHDR hdr; LITEM item; }; +struct tagLVITEMA{ UINT mask; int iItem; int iSubItem; UINT state; UINT stateMask; LPSTR pszText; int cchTextMax; int iImage; LPARAM lParam; int iIndent; int iGroupId; UINT cColumns; PUINT puColumns; int* piColFmt; int iGroup; }; +struct tagLVITEMW{ UINT mask; int iItem; int iSubItem; UINT state; UINT stateMask; LPWSTR pszText; int cchTextMax; int iImage; LPARAM lParam; int iIndent; int iGroupId; UINT cColumns; PUINT puColumns; int* piColFmt; int iGroup; }; +struct tagLVFINDINFOA{ UINT flags; LPCSTR psz; LPARAM lParam; POINT pt; UINT vkDirection; }; +struct tagLVFINDINFOW{ UINT flags; LPCWSTR psz; LPARAM lParam; POINT pt; UINT vkDirection; }; +struct tagLVHITTESTINFO{ POINT pt; UINT flags; int iItem; int iSubItem; int iGroup; }; +struct tagLVCOLUMNA{ UINT mask; int fmt; int cx; LPSTR pszText; int cchTextMax; int iSubItem; int iImage; int iOrder; int cxMin; int cxDefault; int cxIdeal; }; +struct tagLVCOLUMNW{ UINT mask; int fmt; int cx; LPWSTR pszText; int cchTextMax; int iSubItem; int iImage; int iOrder; int cxMin; int cxDefault; int cxIdeal; }; +struct tagLVBKIMAGEA{ ULONG ulFlags; HBITMAP hbm; LPSTR pszImage; UINT cchImageMax; int xOffsetPercent; int yOffsetPercent; }; +struct tagLVBKIMAGEW{ ULONG ulFlags; HBITMAP hbm; LPWSTR pszImage; UINT cchImageMax; int xOffsetPercent; int yOffsetPercent; }; +struct tagLVGROUP{ UINT cbSize; UINT mask; LPWSTR pszHeader; int cchHeader; LPWSTR pszFooter; int cchFooter; int iGroupId; UINT stateMask; UINT state; UINT uAlign; LPWSTR pszSubtitle; UINT cchSubtitle; LPWSTR pszTask; UINT cchTask; LPWSTR pszDescriptionTop; UINT cchDescriptionTop; LPWSTR pszDescriptionBottom; UINT cchDescriptionBottom; int iTitleImage; int iExtendedImage; int iFirstItem; UINT cItems; LPWSTR pszSubsetTitle; UINT cchSubsetTitle; }; +struct tagLVGROUPMETRICS{ UINT cbSize; UINT mask; UINT Left; UINT Top; UINT Right; UINT Bottom; COLORREF crLeft; COLORREF crTop; COLORREF crRight; COLORREF crBottom; COLORREF crHeader; COLORREF crFooter; }; +struct tagLVINSERTGROUPSORTED{ PFNLVGROUPCOMPARE pfnGroupCompare; void* pvData; LVGROUP lvGroup; }; +struct tagLVTILEVIEWINFO{ UINT cbSize; ULONG dwMask; ULONG dwFlags; SIZE sizeTile; int cLines; RECT rcLabelMargin; }; +struct tagLVTILEINFO{ UINT cbSize; int iItem; UINT cColumns; PUINT puColumns; int* piColFmt; }; +struct tagLVSETINFOTIP{ UINT cbSize; ULONG dwFlags; LPWSTR pszText; int iItem; int iSubItem; }; +struct tagLVFOOTERINFO{ UINT mask; LPWSTR pszText; int cchTextMax; UINT cItems; }; +struct tagLVFOOTERITEM{ UINT mask; int iItem; LPWSTR pszText; int cchTextMax; UINT state; UINT stateMask; }; +struct tagLVITEMINDEX{ int iItem; int iGroup; }; +struct tagNMLISTVIEW{ NMHDR hdr; int iItem; int iSubItem; UINT uNewState; UINT uOldState; UINT uChanged; POINT ptAction; LPARAM lParam; }; +struct tagNMITEMACTIVATE{ NMHDR hdr; int iItem; int iSubItem; UINT uNewState; UINT uOldState; UINT uChanged; POINT ptAction; LPARAM lParam; UINT uKeyFlags; }; +struct tagNMLVCUSTOMDRAW{ NMCUSTOMDRAW nmcd; COLORREF clrText; COLORREF clrTextBk; int iSubItem; ULONG dwItemType; COLORREF clrFace; int iIconEffect; int iIconPhase; int iPartId; int iStateId; RECT rcText; UINT uAlign; }; +struct tagNMLVCACHEHINT{ NMHDR hdr; int iFrom; int iTo; }; +struct tagNMLVFINDITEMA{ NMHDR hdr; int iStart; LVFINDINFOA lvfi; }; +struct tagNMLVFINDITEMW{ NMHDR hdr; int iStart; LVFINDINFOW lvfi; }; +struct tagNMLVODSTATECHANGE{ NMHDR hdr; int iFrom; int iTo; UINT uNewState; UINT uOldState; }; +struct tagLVDISPINFO{ NMHDR hdr; LVITEMA item; }; +struct tagLVDISPINFOW{ NMHDR hdr; LVITEMW item; }; +struct tagLVKEYDOWN{ NMHDR hdr; WORD wVKey; UINT flags; }; +struct tagNMLVLINK{ NMHDR hdr; LITEM link; int iItem; int iSubItem; }; +struct tagNMLVGETINFOTIPA{ NMHDR hdr; ULONG dwFlags; LPSTR pszText; int cchTextMax; int iItem; int iSubItem; LPARAM lParam; }; +struct tagNMLVGETINFOTIPW{ NMHDR hdr; ULONG dwFlags; LPWSTR pszText; int cchTextMax; int iItem; int iSubItem; LPARAM lParam; }; +struct tagNMLVSCROLL{ NMHDR hdr; int dx; int dy; }; +struct tagNMLVEMPTYMARKUP{ NMHDR hdr; ULONG dwFlags; WCHAR szMarkup[2084]; }; +struct tagNMTVSTATEIMAGECHANGING{ NMHDR hdr; HTREEITEM hti; int iOldStateImageIndex; int iNewStateImageIndex; }; +struct tagTVITEMA{ UINT mask; HTREEITEM hItem; UINT state; UINT stateMask; LPSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int cChildren; LPARAM lParam; }; +struct tagTVITEMW{ UINT mask; HTREEITEM hItem; UINT state; UINT stateMask; LPWSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int cChildren; LPARAM lParam; }; +struct tagTVITEMEXA{ UINT mask; HTREEITEM hItem; UINT state; UINT stateMask; LPSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int cChildren; LPARAM lParam; int iIntegral; UINT uStateEx; HWND hwnd; int iExpandedImage; int iReserved; }; +struct tagTVITEMEXW{ UINT mask; HTREEITEM hItem; UINT state; UINT stateMask; LPWSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int cChildren; LPARAM lParam; int iIntegral; UINT uStateEx; HWND hwnd; int iExpandedImage; int iReserved; }; +struct tagTVINSERTSTRUCTA{ HTREEITEM hParent; HTREEITEM hInsertAfter; }; +struct tagTVINSERTSTRUCTW{ HTREEITEM hParent; HTREEITEM hInsertAfter; }; +struct tagTVHITTESTINFO{ POINT pt; UINT flags; HTREEITEM hItem; }; +struct tagTVGETITEMPARTRECTINFO{ HTREEITEM hti; RECT* prc; TVITEMPART partID; }; +struct tagTVSORTCB{ HTREEITEM hParent; PFNTVCOMPARE lpfnCompare; LPARAM lParam; }; +struct tagNMTREEVIEWA{ NMHDR hdr; UINT action; TVITEMA itemOld; TVITEMA itemNew; POINT ptDrag; }; +struct tagNMTREEVIEWW{ NMHDR hdr; UINT action; TVITEMW itemOld; TVITEMW itemNew; POINT ptDrag; }; +struct tagTVDISPINFOA{ NMHDR hdr; TVITEMA item; }; +struct tagTVDISPINFOW{ NMHDR hdr; TVITEMW item; }; +struct tagTVDISPINFOEXA{ NMHDR hdr; TVITEMEXA item; }; +struct tagTVDISPINFOEXW{ NMHDR hdr; TVITEMEXW item; }; +struct tagTVKEYDOWN{ NMHDR hdr; WORD wVKey; UINT flags; }; +struct tagNMTVCUSTOMDRAW{ NMCUSTOMDRAW nmcd; COLORREF clrText; COLORREF clrTextBk; int iLevel; }; +struct tagNMTVGETINFOTIPA{ NMHDR hdr; LPSTR pszText; int cchTextMax; HTREEITEM hItem; LPARAM lParam; }; +struct tagNMTVGETINFOTIPW{ NMHDR hdr; LPWSTR pszText; int cchTextMax; HTREEITEM hItem; LPARAM lParam; }; +struct tagTVITEMCHANGE{ NMHDR hdr; UINT uChanged; HTREEITEM hItem; UINT uStateNew; UINT uStateOld; LPARAM lParam; }; +struct tagNMTVASYNCDRAW{ NMHDR hdr; IMAGELISTDRAWPARAMS* pimldp; HRESULT hr; HTREEITEM hItem; LPARAM lParam; ULONG dwRetFlags; int iRetImageIndex; }; +struct tagCOMBOBOXEXITEMA{ UINT mask; INT_PTR iItem; LPSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int iOverlay; int iIndent; LPARAM lParam; }; +struct tagCOMBOBOXEXITEMW{ UINT mask; INT_PTR iItem; LPWSTR pszText; int cchTextMax; int iImage; int iSelectedImage; int iOverlay; int iIndent; LPARAM lParam; }; +struct tagTCITEMHEADERA{ UINT mask; UINT lpReserved1; UINT lpReserved2; LPSTR pszText; int cchTextMax; int iImage; }; +struct tagTCITEMHEADERW{ UINT mask; UINT lpReserved1; UINT lpReserved2; LPWSTR pszText; int cchTextMax; int iImage; }; +struct tagTCITEMA{ UINT mask; ULONG dwState; ULONG dwStateMask; LPSTR pszText; int cchTextMax; int iImage; LPARAM lParam; }; +struct tagTCITEMW{ UINT mask; ULONG dwState; ULONG dwStateMask; LPWSTR pszText; int cchTextMax; int iImage; LPARAM lParam; }; +struct tagTCHITTESTINFO{ POINT pt; UINT flags; }; +struct tagTCKEYDOWN{ NMHDR hdr; WORD wVKey; UINT flags; }; +struct tagMCGRIDINFO{ UINT cbSize; ULONG dwPart; ULONG dwFlags; int iCalendar; int iRow; int iCol; BOOL bSelected; SYSTEMTIME stStart; SYSTEMTIME stEnd; RECT rc; PWSTR pszName; size_t cchName; }; +struct tagNMSELCHANGE{ NMHDR nmhdr; SYSTEMTIME stSelStart; SYSTEMTIME stSelEnd; }; +struct tagNMDAYSTATE{ NMHDR nmhdr; SYSTEMTIME stStart; int cDayState; LPMONTHDAYSTATE prgDayState; }; +struct tagNMVIEWCHANGE{ NMHDR nmhdr; ULONG dwOldView; ULONG dwNewView; }; +struct tagDATETIMEPICKERINFO{ ULONG cbSize; RECT rcCheck; ULONG stateCheck; RECT rcButton; ULONG stateButton; HWND hwndEdit; HWND hwndUD; HWND hwndDropDown; }; +struct tagNMDATETIMECHANGE{ NMHDR nmhdr; ULONG dwFlags; SYSTEMTIME st; }; +struct tagNMDATETIMESTRINGA{ NMHDR nmhdr; LPCSTR pszUserString; SYSTEMTIME st; ULONG dwFlags; }; +struct tagNMDATETIMESTRINGW{ NMHDR nmhdr; LPCWSTR pszUserString; SYSTEMTIME st; ULONG dwFlags; }; +struct tagNMDATETIMEWMKEYDOWNA{ NMHDR nmhdr; int nVirtKey; LPCSTR pszFormat; SYSTEMTIME st; }; +struct tagNMDATETIMEWMKEYDOWNW{ NMHDR nmhdr; int nVirtKey; LPCWSTR pszFormat; SYSTEMTIME st; }; +struct tagNMDATETIMEFORMATA{ NMHDR nmhdr; LPCSTR pszFormat; SYSTEMTIME st; LPCSTR pszDisplay; CHAR szDisplay[64]; }; +struct tagNMDATETIMEFORMATW{ NMHDR nmhdr; LPCWSTR pszFormat; SYSTEMTIME st; LPCWSTR pszDisplay; WCHAR szDisplay[64]; }; +struct tagNMDATETIMEFORMATQUERYA{ NMHDR nmhdr; LPCSTR pszFormat; SIZE szMax; }; +struct tagNMDATETIMEFORMATQUERYW{ NMHDR nmhdr; LPCWSTR pszFormat; SIZE szMax; }; +struct tagNMIPADDRESS{ NMHDR hdr; int iField; int iValue; }; +struct tagNMPGHOTITEM{ NMHDR hdr; int idOld; int idNew; ULONG dwFlags; }; +struct tagNMBCHOTITEM{ NMHDR hdr; ULONG dwFlags; }; +struct tagBUTTON_SPLITINFO{ UINT mask; HIMAGELIST himlGlyph; UINT uSplitStyle; SIZE size; }; +struct tagNMBCDROPDOWN{ NMHDR hdr; RECT rcButton; }; +struct _tagEDITBALLOONTIP{ ULONG cbStruct; LPCWSTR pszTitle; LPCWSTR pszText; INT ttiIcon; }; +enum tagSCRIPTLANGUAGEVERSION{ SCRIPTLANGUAGEVERSION_DEFAULT = 0, SCRIPTLANGUAGEVERSION_5_7 = 1, SCRIPTLANGUAGEVERSION_5_8 = 2, SCRIPTLANGUAGEVERSION_MAX = 255 }; +enum tagSCRIPTSTATE{ SCRIPTSTATE_UNINITIALIZED = 0, SCRIPTSTATE_INITIALIZED = 5, SCRIPTSTATE_STARTED = 1, SCRIPTSTATE_CONNECTED = 2, SCRIPTSTATE_DISCONNECTED = 3, SCRIPTSTATE_CLOSED = 4 }; +enum tagSCRIPTTRACEINFO{ SCRIPTTRACEINFO_SCRIPTSTART = 0, SCRIPTTRACEINFO_SCRIPTEND = 1, SCRIPTTRACEINFO_COMCALLSTART = 2, SCRIPTTRACEINFO_COMCALLEND = 3, SCRIPTTRACEINFO_CREATEOBJSTART = 4, SCRIPTTRACEINFO_CREATEOBJEND = 5, SCRIPTTRACEINFO_GETOBJSTART = 6, SCRIPTTRACEINFO_GETOBJEND = 7 }; +enum tagSCRIPTTHREADSTATE{ SCRIPTTHREADSTATE_NOTINSCRIPT = 0, SCRIPTTHREADSTATE_RUNNING = 1 }; +enum tagSCRIPTGCTYPE{ SCRIPTGCTYPE_NORMAL = 0, SCRIPTGCTYPE_EXHAUSTIVE = 1 }; +enum tagSCRIPTUICITEM{ SCRIPTUICITEM_INPUTBOX = 1, SCRIPTUICITEM_MSGBOX = 2 }; +enum tagSCRIPTUICHANDLING{ SCRIPTUICHANDLING_ALLOW = 0, SCRIPTUICHANDLING_NOUIERROR = 1, SCRIPTUICHANDLING_NOUIDEFAULT = 2 }; +enum tagOBJECT_ATTRIB_FLAG{ OBJECT_ATTRIB_NO_ATTRIB = 0, OBJECT_ATTRIB_NO_NAME = 1, OBJECT_ATTRIB_NO_TYPE = 2, OBJECT_ATTRIB_NO_VALUE = 4, OBJECT_ATTRIB_VALUE_IS_INVALID = 8, OBJECT_ATTRIB_VALUE_IS_OBJECT = 16, OBJECT_ATTRIB_VALUE_IS_ENUM = 32, OBJECT_ATTRIB_VALUE_IS_CUSTOM = 64, OBJECT_ATTRIB_OBJECT_IS_EXPANDABLE = 112, OBJECT_ATTRIB_VALUE_HAS_CODE = 128, OBJECT_ATTRIB_TYPE_IS_OBJECT = 256, OBJECT_ATTRIB_TYPE_HAS_CODE = 512, OBJECT_ATTRIB_TYPE_IS_EXPANDABLE = 256, OBJECT_ATTRIB_SLOT_IS_CATEGORY = 1024, OBJECT_ATTRIB_VALUE_READONLY = 2048, OBJECT_ATTRIB_ACCESS_PUBLIC = 4096, OBJECT_ATTRIB_ACCESS_PRIVATE = 8192, OBJECT_ATTRIB_ACCESS_PROTECTED = 16384, OBJECT_ATTRIB_ACCESS_FINAL = 32768, OBJECT_ATTRIB_STORAGE_GLOBAL = 65536, OBJECT_ATTRIB_STORAGE_STATIC = 131072, OBJECT_ATTRIB_STORAGE_FIELD = 262144, OBJECT_ATTRIB_STORAGE_VIRTUAL = 524288, OBJECT_ATTRIB_TYPE_IS_CONSTANT = 1048576, OBJECT_ATTRIB_TYPE_IS_SYNCHRONIZED = 2097152, OBJECT_ATTRIB_TYPE_IS_VOLATILE = 4194304, OBJECT_ATTRIB_HAS_EXTENDED_ATTRIBS = 8388608, OBJECT_ATTRIB_IS_CLASS = 16777216, OBJECT_ATTRIB_IS_FUNCTION = 33554432, OBJECT_ATTRIB_IS_VARIABLE = 67108864, OBJECT_ATTRIB_IS_PROPERTY = 134217728, OBJECT_ATTRIB_IS_MACRO = 268435456, OBJECT_ATTRIB_IS_TYPE = 536870912, OBJECT_ATTRIB_IS_INHERITED = 1073741824, OBJECT_ATTRIB_IS_INTERFACE = 2147483648 }; +enum tagPROP_INFO_FLAGS{ PROP_INFO_NAME = 1, PROP_INFO_TYPE = 2, PROP_INFO_VALUE = 4, PROP_INFO_FULLNAME = 32, PROP_INFO_ATTRIBUTES = 8, PROP_INFO_DEBUGPROP = 16, PROP_INFO_AUTOEXPAND = 134217728 }; +struct tagDebugPropertyInfo{ ULONG m_dwValidFields; BSTR m_bstrName; BSTR m_bstrType; BSTR m_bstrValue; BSTR m_bstrFullName; ULONG m_dwAttrib; IDebugProperty* m_pDebugProp; }; +enum tagEX_PROP_INFO_FLAGS{ EX_PROP_INFO_ID = 256, EX_PROP_INFO_NTYPE = 512, EX_PROP_INFO_NVALUE = 1024, EX_PROP_INFO_LOCKBYTES = 2048, EX_PROP_INFO_DEBUGEXTPROP = 4096 }; +struct tagExtendedDebugPropertyInfo{ ULONG dwValidFields; LPOLESTR pszName; LPOLESTR pszType; LPOLESTR pszValue; LPOLESTR pszFullName; ULONG dwAttrib; IDebugProperty* pDebugProp; ULONG nDISPID; ULONG nType; VARIANT varValue; ILockBytes* plbValue; IDebugExtendedProperty* pDebugExtProp; }; +enum tagBREAKPOINT_STATE{ BREAKPOINT_DELETED = 0, BREAKPOINT_DISABLED = 1, BREAKPOINT_ENABLED = 2 }; +enum tagBREAKREASON{ BREAKREASON_STEP = 0, BREAKREASON_BREAKPOINT = 1, BREAKREASON_DEBUGGER_BLOCK = 2, BREAKREASON_HOST_INITIATED = 3, BREAKREASON_LANGUAGE_INITIATED = 4, BREAKREASON_DEBUGGER_HALT = 5, BREAKREASON_ERROR = 6, BREAKREASON_JIT = 7, BREAKREASON_MUTATION_BREAKPOINT = 8 }; +enum tagBREAKRESUME_ACTION{ BREAKRESUMEACTION_ABORT = 0, BREAKRESUMEACTION_CONTINUE = 1, BREAKRESUMEACTION_STEP_INTO = 2, BREAKRESUMEACTION_STEP_OVER = 3, BREAKRESUMEACTION_STEP_OUT = 4, BREAKRESUMEACTION_IGNORE = 5, BREAKRESUMEACTION_STEP_DOCUMENT = 6 }; +enum tagERRORRESUMEACTION{ ERRORRESUMEACTION_ReexecuteErrorStatement = 0, ERRORRESUMEACTION_AbortCallAndReturnErrorToCaller = 1, ERRORRESUMEACTION_SkipErrorStatement = 2 }; +enum tagDOCUMENTNAMETYPE{ DOCUMENTNAMETYPE_APPNODE = 0, DOCUMENTNAMETYPE_TITLE = 1, DOCUMENTNAMETYPE_FILE_TAIL = 2, DOCUMENTNAMETYPE_URL = 3, DOCUMENTNAMETYPE_UNIQUE_TITLE = 4, DOCUMENTNAMETYPE_SOURCE_MAP_URL = 5 }; +struct tagDebugStackFrameDescriptor{ IDebugStackFrame* pdsf; ULONG dwMin; ULONG dwLim; BOOL fFinal; IUnknown* punkFinal; }; +struct tagDebugStackFrameDescriptor64{ IDebugStackFrame* pdsf; DWORDLONG dwMin; DWORDLONG dwLim; BOOL fFinal; IUnknown* punkFinal; }; +enum tagAPPLICATION_NODE_EVENT_FILTER{ FILTER_EXCLUDE_NOTHING = 0, FILTER_EXCLUDE_ANONYMOUS_CODE = 1, FILTER_EXCLUDE_EVAL_CODE = 2 }; +struct tagTEXT_DOCUMENT_ARRAY{ ULONG dwCount; IDebugDocumentText** Members; }; +enum tagSCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND{ ETK_FIRST_CHANCE = 0, ETK_USER_UNHANDLED = 1, ETK_UNHANDLED = 2 }; +enum tagSCRIPT_INVOCATION_CONTEXT_TYPE{ SICT_Event = 0, SICT_SetTimeout = 1, SICT_SetInterval = 2, SICT_SetImmediate = 3, SICT_RequestAnimationFrame = 4, SICT_ToString = 5, SICT_MutationObserverCheckpoint = 6, SICT_WWAExecUnsafeLocalFunction = 7, SICT_WWAExecAtPriority = 8 }; +enum tagDEBUG_STACKFRAME_TYPE{ DST_SCRIPT_FRAME = 0, DST_INTERNAL_FRAME = 1, DST_INVOCATION_FRAME = 2 }; +enum tagDEBUG_EVENT_INFO_TYPE{ DEIT_GENERAL = 0, DEIT_ASMJS_IN_DEBUGGING = 1, DEIT_ASMJS_SUCCEEDED = 2, DEIT_ASMJS_FAILED = 3 }; +struct tagVFW_FILTERLIST{ UINT cFilters; CLSID aClsId[1]; }; +enum tagDOT11_ADHOC_CIPHER_ALGORITHM{ DOT11_ADHOC_CIPHER_ALGO_INVALID = 4294967295, DOT11_ADHOC_CIPHER_ALGO_NONE = 0, DOT11_ADHOC_CIPHER_ALGO_CCMP = 4, DOT11_ADHOC_CIPHER_ALGO_WEP = 257 }; +enum tagDOT11_ADHOC_AUTH_ALGORITHM{ DOT11_ADHOC_AUTH_ALGO_INVALID = 4294967295, DOT11_ADHOC_AUTH_ALGO_80211_OPEN = 1, DOT11_ADHOC_AUTH_ALGO_RSNA_PSK = 7 }; +enum tagDOT11_ADHOC_NETWORK_CONNECTION_STATUS{ DOT11_ADHOC_NETWORK_CONNECTION_STATUS_INVALID = 0, DOT11_ADHOC_NETWORK_CONNECTION_STATUS_DISCONNECTED = 11, DOT11_ADHOC_NETWORK_CONNECTION_STATUS_CONNECTING = 12, DOT11_ADHOC_NETWORK_CONNECTION_STATUS_CONNECTED = 13, DOT11_ADHOC_NETWORK_CONNECTION_STATUS_FORMED = 14 }; +enum tagDOT11_ADHOC_CONNECT_FAIL_REASON{ DOT11_ADHOC_CONNECT_FAIL_DOMAIN_MISMATCH = 0, DOT11_ADHOC_CONNECT_FAIL_PASSPHRASE_MISMATCH = 1, DOT11_ADHOC_CONNECT_FAIL_OTHER = 2 }; +enum tagAM_SAMPLE_PROPERTY_FLAGS{ AM_SAMPLE_SPLICEPOINT = 1, AM_SAMPLE_PREROLL = 2, AM_SAMPLE_DATADISCONTINUITY = 4, AM_SAMPLE_TYPECHANGED = 8, AM_SAMPLE_TIMEVALID = 16, AM_SAMPLE_TIMEDISCONTINUITY = 64, AM_SAMPLE_FLUSH_ON_PAUSE = 128, AM_SAMPLE_STOPVALID = 256, AM_SAMPLE_ENDOFSTREAM = 512, AM_STREAM_MEDIA = 0, AM_STREAM_CONTROL = 1 }; +struct tagAM_SAMPLE2_PROPERTIES{ ULONG cbData; ULONG dwTypeSpecificFlags; ULONG dwSampleFlags; LONG lActual; REFERENCE_TIME tStart; REFERENCE_TIME tStop; ULONG dwStreamId; AM_MEDIA_TYPE* pMediaType; UCHAR* pbBuffer; LONG cbBuffer; }; +enum tagAM_MEDIAEVENT_FLAGS{ AM_MEDIAEVENT_NONOTIFY = 1 }; +enum tagQualityMessageType{ Famine = 0, Flood = 1 }; +struct tagQuality{ QualityMessageType Type; long Proportion; REFERENCE_TIME Late; REFERENCE_TIME TimeStamp; }; +struct tagCOLORKEY{ ULONG KeyType; ULONG PaletteIndex; COLORREF LowColorValue; COLORREF HighColorValue; }; +enum tagAnalogVideoStandard{ AnalogVideo_None = 0, AnalogVideo_NTSC_M = 1, AnalogVideo_NTSC_M_J = 2, AnalogVideo_NTSC_433 = 4, AnalogVideo_PAL_B = 16, AnalogVideo_PAL_D = 32, AnalogVideo_PAL_G = 64, AnalogVideo_PAL_H = 128, AnalogVideo_PAL_I = 256, AnalogVideo_PAL_M = 512, AnalogVideo_PAL_N = 1024, AnalogVideo_PAL_60 = 2048, AnalogVideo_SECAM_B = 4096, AnalogVideo_SECAM_D = 8192, AnalogVideo_SECAM_G = 16384, AnalogVideo_SECAM_H = 32768, AnalogVideo_SECAM_K = 65536, AnalogVideo_SECAM_K1 = 131072, AnalogVideo_SECAM_L = 262144, AnalogVideo_SECAM_L1 = 524288, AnalogVideo_PAL_N_COMBO = 1048576, AnalogVideoMask_MCE_NTSC = 1052167, AnalogVideoMask_MCE_PAL = 496, AnalogVideoMask_MCE_SECAM = 1044480 }; +enum tagTunerInputType{ TunerInputCable = 0, TunerInputAntenna = 1 }; +enum tagPhysicalConnectorType{ PhysConn_Video_Tuner = 1, PhysConn_Video_Composite = 2, PhysConn_Video_SVideo = 3, PhysConn_Video_RGB = 4, PhysConn_Video_YRYBY = 5, PhysConn_Video_SerialDigital = 6, PhysConn_Video_ParallelDigital = 7, PhysConn_Video_SCSI = 8, PhysConn_Video_AUX = 9, PhysConn_Video_1394 = 10, PhysConn_Video_USB = 11, PhysConn_Video_VideoDecoder = 12, PhysConn_Video_VideoEncoder = 13, PhysConn_Video_SCART = 14, PhysConn_Video_Black = 15, PhysConn_Audio_Tuner = 4096, PhysConn_Audio_Line = 4097, PhysConn_Audio_Mic = 4098, PhysConn_Audio_AESDigital = 4099, PhysConn_Audio_SPDIFDigital = 4100, PhysConn_Audio_SCSI = 4101, PhysConn_Audio_AUX = 4102, PhysConn_Audio_1394 = 4103, PhysConn_Audio_USB = 4104, PhysConn_Audio_AudioDecoder = 4105 }; +enum tagVideoProcAmpProperty{ VideoProcAmp_Brightness = 0, VideoProcAmp_Contrast = 1, VideoProcAmp_Hue = 2, VideoProcAmp_Saturation = 3, VideoProcAmp_Sharpness = 4, VideoProcAmp_Gamma = 5, VideoProcAmp_ColorEnable = 6, VideoProcAmp_WhiteBalance = 7, VideoProcAmp_BacklightCompensation = 8, VideoProcAmp_Gain = 9 }; +enum tagVideoProcAmpFlags{ VideoProcAmp_Flags_Auto = 1, VideoProcAmp_Flags_Manual = 2 }; +enum tagCameraControlProperty{ CameraControl_Pan = 0, CameraControl_Tilt = 1, CameraControl_Roll = 2, CameraControl_Zoom = 3, CameraControl_Exposure = 4, CameraControl_Iris = 5, CameraControl_Focus = 6 }; +enum tagCameraControlFlags{ CameraControl_Flags_Auto = 1, CameraControl_Flags_Manual = 2 }; +enum tagVideoControlFlags{ VideoControlFlag_FlipHorizontal = 1, VideoControlFlag_FlipVertical = 2, VideoControlFlag_ExternalTriggerEnable = 4, VideoControlFlag_Trigger = 8 }; +enum tagAMTunerSubChannel{ AMTUNER_SUBCHAN_NO_TUNE = 4294967294, AMTUNER_SUBCHAN_DEFAULT = 4294967295 }; +enum tagAMTunerSignalStrength{ AMTUNER_HASNOSIGNALSTRENGTH = 4294967295, AMTUNER_NOSIGNAL = 0, AMTUNER_SIGNALPRESENT = 1 }; +enum tagAMTunerModeType{ AMTUNER_MODE_DEFAULT = 0, AMTUNER_MODE_TV = 1, AMTUNER_MODE_FM_RADIO = 2, AMTUNER_MODE_AM_RADIO = 4, AMTUNER_MODE_DSS = 8 }; +enum tagAMTunerEventType{ AMTUNER_EVENT_CHANGED = 1 }; +enum tagTVAudioMode{ AMTVAUDIO_MODE_MONO = 1, AMTVAUDIO_MODE_STEREO = 2, AMTVAUDIO_MODE_LANG_A = 16, AMTVAUDIO_MODE_LANG_B = 32, AMTVAUDIO_MODE_LANG_C = 64, AMTVAUDIO_PRESET_STEREO = 512, AMTVAUDIO_PRESET_LANG_A = 4096, AMTVAUDIO_PRESET_LANG_B = 8192, AMTVAUDIO_PRESET_LANG_C = 16384 }; +enum tagAMTVAudioEventType{ AMTVAUDIO_EVENT_CHANGED = 1 }; +struct tagDDDEVICEIDENTIFIER{ char szDriver[512]; char szDescription[512]; LARGE_INTEGER liDriverVersion; ULONG dwVendorId; ULONG dwDeviceId; ULONG dwSubSysId; ULONG dwRevision; GUID guidDeviceIdentifier; }; +struct tagDDDEVICEIDENTIFIER2{ char szDriver[512]; char szDescription[512]; LARGE_INTEGER liDriverVersion; ULONG dwVendorId; ULONG dwDeviceId; ULONG dwSubSysId; ULONG dwRevision; GUID guidDeviceIdentifier; ULONG dwWHQLLevel; }; +struct tagVMRPRESENTATIONINFO{ ULONG dwFlags; LPDIRECTDRAWSURFACE7 lpSurf; REFERENCE_TIME rtStart; REFERENCE_TIME rtEnd; SIZE szAspectRatio; RECT rcSrc; RECT rcDst; ULONG dwTypeSpecificFlags; ULONG dwInterlaceFlags; }; +struct tagVMRALLOCATIONINFO{ ULONG dwFlags; LPBITMAPINFOHEADER lpHdr; LPDDPIXELFORMAT lpPixFmt; SIZE szAspectRatio; ULONG dwMinBuffers; ULONG dwMaxBuffers; ULONG dwInterlaceFlags; SIZE szNativeSize; }; +struct tagVMRGUID{ GUID* pGUID; GUID GUID; }; +struct tagVMRMONITORINFO{ VMRGUID guid; RECT rcMonitor; HMONITOR hMon; ULONG dwFlags; wchar_t szDevice[32]; wchar_t szDescription[256]; LARGE_INTEGER liDriverVersion; ULONG dwVendorId; ULONG dwDeviceId; ULONG dwSubSysId; ULONG dwRevision; }; +enum tagDVD_DOMAIN{ DVD_DOMAIN_FirstPlay = 1, DVD_DOMAIN_VideoManagerMenu = 2, DVD_DOMAIN_VideoTitleSetMenu = 3, DVD_DOMAIN_Title = 4, DVD_DOMAIN_Stop = 5 }; +enum tagDVD_MENU_ID{ DVD_MENU_Title = 2, DVD_MENU_Root = 3, DVD_MENU_Subpicture = 4, DVD_MENU_Audio = 5, DVD_MENU_Angle = 6, DVD_MENU_Chapter = 7 }; +enum tagDVD_DISC_SIDE{ DVD_SIDE_A = 1, DVD_SIDE_B = 2 }; +enum tagDVD_PREFERRED_DISPLAY_MODE{ DISPLAY_CONTENT_DEFAULT = 0, DISPLAY_16x9 = 1, DISPLAY_4x3_PANSCAN_PREFERRED = 2, DISPLAY_4x3_LETTERBOX_PREFERRED = 3 }; +struct tagDVD_ATR{ ULONG ulCAT; UCHAR pbATRI[768]; }; +enum tagDVD_FRAMERATE{ DVD_FPS_25 = 1, DVD_FPS_30NonDrop = 3 }; +struct tagDVD_TIMECODE{ ULONG Hours1 : 4; ULONG Hours10 : 4; ULONG Minutes1 : 4; ULONG Minutes10 : 4; ULONG Seconds1 : 4; ULONG Seconds10 : 4; ULONG Frames1 : 4; ULONG Frames10 : 2; ULONG FrameRateCode : 2; }; +enum tagDVD_NavCmdType{ DVD_NavCmdType_Pre = 1, DVD_NavCmdType_Post = 2, DVD_NavCmdType_Cell = 3, DVD_NavCmdType_Button = 4 }; +enum tagDVD_TIMECODE_FLAGS{ DVD_TC_FLAG_25fps = 1, DVD_TC_FLAG_30fps = 2, DVD_TC_FLAG_DropFrame = 4, DVD_TC_FLAG_Interpolated = 8 }; +struct tagDVD_HMSF_TIMECODE{ UCHAR bHours; UCHAR bMinutes; UCHAR bSeconds; UCHAR bFrames; }; +struct tagDVD_PLAYBACK_LOCATION2{ ULONG TitleNum; ULONG ChapterNum; DVD_HMSF_TIMECODE TimeCode; ULONG TimeCodeFlags; }; +struct tagDVD_PLAYBACK_LOCATION{ ULONG TitleNum; ULONG ChapterNum; ULONG TimeCode; }; +enum tagDVD_PARENTAL_LEVEL{ DVD_PARENTAL_LEVEL_8 = 32768, DVD_PARENTAL_LEVEL_7 = 16384, DVD_PARENTAL_LEVEL_6 = 8192, DVD_PARENTAL_LEVEL_5 = 4096, DVD_PARENTAL_LEVEL_4 = 2048, DVD_PARENTAL_LEVEL_3 = 1024, DVD_PARENTAL_LEVEL_2 = 512, DVD_PARENTAL_LEVEL_1 = 256 }; +enum tagDVD_AUDIO_LANG_EXT{ DVD_AUD_EXT_NotSpecified = 0, DVD_AUD_EXT_Captions = 1, DVD_AUD_EXT_VisuallyImpaired = 2, DVD_AUD_EXT_DirectorComments1 = 3, DVD_AUD_EXT_DirectorComments2 = 4 }; +enum tagDVD_SUBPICTURE_LANG_EXT{ DVD_SP_EXT_NotSpecified = 0, DVD_SP_EXT_Caption_Normal = 1, DVD_SP_EXT_Caption_Big = 2, DVD_SP_EXT_Caption_Children = 3, DVD_SP_EXT_CC_Normal = 5, DVD_SP_EXT_CC_Big = 6, DVD_SP_EXT_CC_Children = 7, DVD_SP_EXT_Forced = 9, DVD_SP_EXT_DirectorComments_Normal = 13, DVD_SP_EXT_DirectorComments_Big = 14, DVD_SP_EXT_DirectorComments_Children = 15 }; +enum tagDVD_AUDIO_APPMODE{ DVD_AudioMode_None = 0, DVD_AudioMode_Karaoke = 1, DVD_AudioMode_Surround = 2, DVD_AudioMode_Other = 3 }; +enum tagDVD_AUDIO_FORMAT{ DVD_AudioFormat_AC3 = 0, DVD_AudioFormat_MPEG1 = 1, DVD_AudioFormat_MPEG1_DRC = 2, DVD_AudioFormat_MPEG2 = 3, DVD_AudioFormat_MPEG2_DRC = 4, DVD_AudioFormat_LPCM = 5, DVD_AudioFormat_DTS = 6, DVD_AudioFormat_SDDS = 7, DVD_AudioFormat_Other = 8 }; +enum tagDVD_KARAOKE_DOWNMIX{ DVD_Mix_0to0 = 1, DVD_Mix_1to0 = 2, DVD_Mix_2to0 = 4, DVD_Mix_3to0 = 8, DVD_Mix_4to0 = 16, DVD_Mix_Lto0 = 32, DVD_Mix_Rto0 = 64, DVD_Mix_0to1 = 256, DVD_Mix_1to1 = 512, DVD_Mix_2to1 = 1024, DVD_Mix_3to1 = 2048, DVD_Mix_4to1 = 4096, DVD_Mix_Lto1 = 8192, DVD_Mix_Rto1 = 16384 }; +struct tagDVD_AudioAttributes{ DVD_AUDIO_APPMODE AppMode; UCHAR AppModeData; DVD_AUDIO_FORMAT AudioFormat; LCID Language; DVD_AUDIO_LANG_EXT LanguageExtension; BOOL fHasMultichannelInfo; ULONG dwFrequency; UCHAR bQuantization; UCHAR bNumberOfChannels; ULONG dwReserved[2]; }; +struct tagDVD_MUA_MixingInfo{ BOOL fMixTo0; BOOL fMixTo1; BOOL fMix0InPhase; BOOL fMix1InPhase; ULONG dwSpeakerPosition; }; +struct tagDVD_MUA_Coeff{ double log2_alpha; double log2_beta; }; +struct tagDVD_MultichannelAudioAttributes{ DVD_MUA_MixingInfo Info[8]; DVD_MUA_Coeff Coeff[8]; }; +enum tagDVD_KARAOKE_CONTENTS{ DVD_Karaoke_GuideVocal1 = 1, DVD_Karaoke_GuideVocal2 = 2, DVD_Karaoke_GuideMelody1 = 4, DVD_Karaoke_GuideMelody2 = 8, DVD_Karaoke_GuideMelodyA = 16, DVD_Karaoke_GuideMelodyB = 32, DVD_Karaoke_SoundEffectA = 64, DVD_Karaoke_SoundEffectB = 128 }; +enum tagDVD_KARAOKE_ASSIGNMENT{ DVD_Assignment_reserved0 = 0, DVD_Assignment_reserved1 = 1, DVD_Assignment_LR = 2, DVD_Assignment_LRM = 3, DVD_Assignment_LR1 = 4, DVD_Assignment_LRM1 = 5, DVD_Assignment_LR12 = 6, DVD_Assignment_LRM12 = 7 }; +struct tagDVD_KaraokeAttributes{ UCHAR bVersion; BOOL fMasterOfCeremoniesInGuideVocal1; BOOL fDuet; DVD_KARAOKE_ASSIGNMENT ChannelAssignment; WORD wChannelContents[8]; }; +enum tagDVD_VIDEO_COMPRESSION{ DVD_VideoCompression_Other = 0, DVD_VideoCompression_MPEG1 = 1, DVD_VideoCompression_MPEG2 = 2 }; +struct tagDVD_VideoAttributes{ BOOL fPanscanPermitted; BOOL fLetterboxPermitted; ULONG ulAspectX; ULONG ulAspectY; ULONG ulFrameRate; ULONG ulFrameHeight; DVD_VIDEO_COMPRESSION Compression; BOOL fLine21Field1InGOP; BOOL fLine21Field2InGOP; ULONG ulSourceResolutionX; ULONG ulSourceResolutionY; BOOL fIsSourceLetterboxed; BOOL fIsFilmMode; }; +enum tagDVD_SUBPICTURE_TYPE{ DVD_SPType_NotSpecified = 0, DVD_SPType_Language = 1, DVD_SPType_Other = 2 }; +enum tagDVD_SUBPICTURE_CODING{ DVD_SPCoding_RunLength = 0, DVD_SPCoding_Extended = 1, DVD_SPCoding_Other = 2 }; +struct tagDVD_SubpictureAttributes{ DVD_SUBPICTURE_TYPE Type; DVD_SUBPICTURE_CODING CodingMode; LCID Language; DVD_SUBPICTURE_LANG_EXT LanguageExtension; }; +enum tagDVD_TITLE_APPMODE{ DVD_AppMode_Not_Specified = 0, DVD_AppMode_Karaoke = 1, DVD_AppMode_Other = 3 }; +struct tagDVD_TitleMainAttributes{ DVD_VideoAttributes VideoAttributes; ULONG ulNumberOfAudioStreams; DVD_AudioAttributes AudioAttributes[8]; DVD_MultichannelAudioAttributes MultichannelAudioAttributes[8]; ULONG ulNumberOfSubpictureStreams; DVD_SubpictureAttributes SubpictureAttributes[32]; }; +struct tagDVD_MenuAttributes{ BOOL fCompatibleRegion[8]; DVD_VideoAttributes VideoAttributes; BOOL fAudioPresent; DVD_AudioAttributes AudioAttributes; BOOL fSubpicturePresent; DVD_SubpictureAttributes SubpictureAttributes; }; +struct tagDVD_DECODER_CAPS{ ULONG dwSize; ULONG dwAudioCaps; double dFwdMaxRateVideo; double dFwdMaxRateAudio; double dFwdMaxRateSP; double dBwdMaxRateVideo; double dBwdMaxRateAudio; double dBwdMaxRateSP; ULONG dwRes1; ULONG dwRes2; ULONG dwRes3; ULONG dwRes4; }; +struct _tag_AMVAUncompBufferInfo{ ULONG dwMinNumSurfaces; ULONG dwMaxNumSurfaces; DDPIXELFORMAT ddUncompPixelFormat; }; +struct _tag_AMVAUncompDataInfo{ ULONG dwUncompWidth; ULONG dwUncompHeight; DDPIXELFORMAT ddUncompPixelFormat; }; +struct _tag_AMVAInternalMemInfo{ ULONG dwScratchMemAlloc; }; +struct _tag_AMVACompBufferInfo{ ULONG dwNumCompBuffers; ULONG dwWidthToCreate; ULONG dwHeightToCreate; ULONG dwBytesToAllocate; DDSCAPS2 ddCompCaps; DDPIXELFORMAT ddPixelFormat; }; +struct _tag_AMVABeginFrameInfo{ ULONG dwDestSurfaceIndex; LPVOID pInputData; ULONG dwSizeInputData; LPVOID pOutputData; ULONG dwSizeOutputData; }; +struct _tag_AMVAEndFrameInfo{ ULONG dwSizeMiscData; LPVOID pMiscData; }; +struct _tag_AMVABUFFERINFO{ ULONG dwTypeIndex; ULONG dwBufferIndex; ULONG dwDataOffset; ULONG dwDataSize; }; +struct tag_TRUECOLORINFO{ ULONG dwBitMasks[3]; RGBQUAD bmiColors[256]; }; +struct tagVIDEOINFO{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; REFERENCE_TIME AvgTimePerFrame; BITMAPINFOHEADER bmiHeader; }; +struct tagAnalogVideoInfo{ RECT rcSource; RECT rcTarget; ULONG dwActiveWidth; ULONG dwActiveHeight; REFERENCE_TIME AvgTimePerFrame; }; +LONG GetStagedPackagePathByFullName( PCWSTR packageFullName, UINT32* pathLength, PWSTR path ); +LONG GetStagedPackagePathByFullName2( PCWSTR packageFullName, PackagePathType packagePathType, UINT32* pathLength, PWSTR path ); +LONG GetStagedPackageOrigin( PCWSTR packageFullName, PackageOrigin* origin ); +enum _tagSND_DEVICE_ERROR{ SNDDEV_ERROR_Open = 1, SNDDEV_ERROR_Close = 2, SNDDEV_ERROR_GetCaps = 3, SNDDEV_ERROR_PrepareHeader = 4, SNDDEV_ERROR_UnprepareHeader = 5, SNDDEV_ERROR_Reset = 6, SNDDEV_ERROR_Restart = 7, SNDDEV_ERROR_GetPosition = 8, SNDDEV_ERROR_Write = 9, SNDDEV_ERROR_Pause = 10, SNDDEV_ERROR_Stop = 11, SNDDEV_ERROR_Start = 12, SNDDEV_ERROR_AddBuffer = 13, SNDDEV_ERROR_Query = 14 }; +enum tagAZ_PROP_CONSTANTS{ AZ_PROP_NAME = 1, AZ_PROP_DESCRIPTION = 2, AZ_PROP_WRITABLE = 3, AZ_PROP_APPLICATION_DATA = 4, AZ_PROP_CHILD_CREATE = 5, AZ_MAX_APPLICATION_NAME_LENGTH = 512, AZ_MAX_OPERATION_NAME_LENGTH = 64, AZ_MAX_TASK_NAME_LENGTH = 64, AZ_MAX_SCOPE_NAME_LENGTH = 65536, AZ_MAX_GROUP_NAME_LENGTH = 64, AZ_MAX_ROLE_NAME_LENGTH = 64, AZ_MAX_NAME_LENGTH = 65536, AZ_MAX_DESCRIPTION_LENGTH = 1024, AZ_MAX_APPLICATION_DATA_LENGTH = 4096, AZ_SUBMIT_FLAG_ABORT = 1, AZ_SUBMIT_FLAG_FLUSH = 2, AZ_MAX_POLICY_URL_LENGTH = 65536, AZ_AZSTORE_FLAG_CREATE = 1, AZ_AZSTORE_FLAG_MANAGE_STORE_ONLY = 2, AZ_AZSTORE_FLAG_BATCH_UPDATE = 4, AZ_AZSTORE_FLAG_AUDIT_IS_CRITICAL = 8, AZ_AZSTORE_FORCE_APPLICATION_CLOSE = 16, AZ_AZSTORE_NT6_FUNCTION_LEVEL = 32, AZ_AZSTORE_FLAG_MANAGE_ONLY_PASSIVE_SUBMIT = 32768, AZ_PROP_AZSTORE_DOMAIN_TIMEOUT = 100, AZ_AZSTORE_DEFAULT_DOMAIN_TIMEOUT = 15000, AZ_PROP_AZSTORE_SCRIPT_ENGINE_TIMEOUT = 101, AZ_AZSTORE_MIN_DOMAIN_TIMEOUT = 500, AZ_AZSTORE_MIN_SCRIPT_ENGINE_TIMEOUT = 5000, AZ_AZSTORE_DEFAULT_SCRIPT_ENGINE_TIMEOUT = 45000, AZ_PROP_AZSTORE_MAX_SCRIPT_ENGINES = 102, AZ_AZSTORE_DEFAULT_MAX_SCRIPT_ENGINES = 120, AZ_PROP_AZSTORE_MAJOR_VERSION = 103, AZ_PROP_AZSTORE_MINOR_VERSION = 104, AZ_PROP_AZSTORE_TARGET_MACHINE = 105, AZ_PROP_AZTORE_IS_ADAM_INSTANCE = 106, AZ_PROP_OPERATION_ID = 200, AZ_PROP_TASK_OPERATIONS = 300, AZ_PROP_TASK_BIZRULE = 301, AZ_PROP_TASK_BIZRULE_LANGUAGE = 302, AZ_PROP_TASK_TASKS = 303, AZ_PROP_TASK_BIZRULE_IMPORTED_PATH = 304, AZ_PROP_TASK_IS_ROLE_DEFINITION = 305, AZ_MAX_TASK_BIZRULE_LENGTH = 65536, AZ_MAX_TASK_BIZRULE_LANGUAGE_LENGTH = 64, AZ_MAX_TASK_BIZRULE_IMPORTED_PATH_LENGTH = 512, AZ_MAX_BIZRULE_STRING = 65536, AZ_PROP_GROUP_TYPE = 400, AZ_GROUPTYPE_LDAP_QUERY = 1, AZ_GROUPTYPE_BASIC = 2, AZ_GROUPTYPE_BIZRULE = 3, AZ_PROP_GROUP_APP_MEMBERS = 401, AZ_PROP_GROUP_APP_NON_MEMBERS = 402, AZ_PROP_GROUP_LDAP_QUERY = 403, AZ_MAX_GROUP_LDAP_QUERY_LENGTH = 4096, AZ_PROP_GROUP_MEMBERS = 404, AZ_PROP_GROUP_NON_MEMBERS = 405, AZ_PROP_GROUP_MEMBERS_NAME = 406, AZ_PROP_GROUP_NON_MEMBERS_NAME = 407, AZ_PROP_GROUP_BIZRULE = 408, AZ_PROP_GROUP_BIZRULE_LANGUAGE = 409, AZ_PROP_GROUP_BIZRULE_IMPORTED_PATH = 410, AZ_MAX_GROUP_BIZRULE_LENGTH = 65536, AZ_MAX_GROUP_BIZRULE_LANGUAGE_LENGTH = 64 }; +struct tagCATEGORYINFO{ CATID catid; LCID lcid; OLECHAR szDescription[128]; }; +struct tagCHANNEL_DEF{ char name[8]; ULONG options; }; +struct tagCHANNEL_PDU_HEADER{ UINT32 length; UINT32 flags; }; +struct tagCHANNEL_ENTRY_POINTS{ ULONG cbSize; ULONG protocolVersion; PVIRTUALCHANNELINIT pVirtualChannelInit; PVIRTUALCHANNELOPEN pVirtualChannelOpen; PVIRTUALCHANNELCLOSE pVirtualChannelClose; PVIRTUALCHANNELWRITE pVirtualChannelWrite; }; +struct tagCSEDB_RSTMAPW{ WCHAR* pwszDatabaseName; WCHAR* pwszNewDatabaseName; }; +struct tagSources{ ULONG sourceId; int numTargets; ULONG aTargets[1]; }; +struct tagAdapter{ WCHAR AdapterName[128]; int numSources; Sources sources[1]; }; +struct tagAdapters{ int numAdapters; Adapter adapter[1]; }; +struct tagDisplayMode{ WCHAR DeviceName[32]; DEVMODEW devMode; }; +struct tagDisplayModes{ int numDisplayModes; DisplayMode displayMode[1]; }; +struct tagDBID{ 776A64716F6E687975735A6864555A564A4F7443714A3164354E413D uGuid; DBKIND eKind; 6C6C50714B5055307062736663384B386D566F73552F48636571413D uName; }; +struct tagDB_NUMERIC{ UCHAR precision; UCHAR scale; UCHAR sign; UCHAR val[16]; }; +struct tagDBVECTOR{ DBLENGTH size; void* ptr; }; +struct tagDBDATE{ SHORT year; USHORT month; USHORT day; }; +struct tagDBTIME{ USHORT hour; USHORT minute; USHORT second; }; +struct tagDBTIMESTAMP{ SHORT year; USHORT month; USHORT day; USHORT hour; USHORT minute; USHORT second; ULONG fraction; }; +struct tagDB_VARNUMERIC{ UCHAR precision; SBYTE scale; UCHAR sign; UCHAR val[1]; }; +struct tagDBIMPLICITSESSION{ IUnknown* pUnkOuter; IID* piid; IUnknown* pSession; }; +struct tagDBOBJECT{ ULONG dwFlags; IID iid; }; +struct tagDBBINDEXT{ UCHAR* pExtension; DBCOUNTITEM ulExtension; }; +struct tagDBBINDING{ DBORDINAL iOrdinal; DBBYTEOFFSET obValue; DBBYTEOFFSET obLength; DBBYTEOFFSET obStatus; ITypeInfo* pTypeInfo; DBOBJECT* pObject; DBBINDEXT* pBindExt; DBPART dwPart; DBMEMOWNER dwMemOwner; DBPARAMIO eParamIO; DBLENGTH cbMaxLen; ULONG dwFlags; DBTYPE wType; UCHAR bPrecision; UCHAR bScale; }; +struct tagDBFAILUREINFO{ HROW hRow; DBORDINAL iColumn; HRESULT failure; }; +struct tagDBCOLUMNINFO{ LPOLESTR pwszName; ITypeInfo* pTypeInfo; DBORDINAL iOrdinal; DBCOLUMNFLAGS dwFlags; DBLENGTH ulColumnSize; DBTYPE wType; UCHAR bPrecision; UCHAR bScale; DBID columnid; }; +enum tagDBBOOKMARK{ DBBMK_INVALID = 0, DBBMK_FIRST = 1, DBBMK_LAST = 2 }; +struct tagDBPARAMS{ void* pData; DB_UPARAMS cParamSets; HACCESSOR hAccessor; }; +struct tagDBPARAMINFO{ DBPARAMFLAGS dwFlags; DBORDINAL iOrdinal; LPOLESTR pwszName; ITypeInfo* pTypeInfo; DBLENGTH ulParamSize; DBTYPE wType; UCHAR bPrecision; UCHAR bScale; }; +struct tagDBPROPIDSET{ DBPROPID* rgPropertyIDs; ULONG cPropertyIDs; GUID guidPropertySet; }; +struct tagDBPROPINFO{ LPOLESTR pwszDescription; DBPROPID dwPropertyID; DBPROPFLAGS dwFlags; VARTYPE vtType; VARIANT vValues; }; +struct tagDBPROPINFOSET{ PDBPROPINFO rgPropertyInfos; ULONG cPropertyInfos; GUID guidPropertySet; }; +struct tagDBPROP{ DBPROPID dwPropertyID; DBPROPOPTIONS dwOptions; DBPROPSTATUS dwStatus; DBID colid; VARIANT vValue; }; +struct tagDBPROPSET{ DBPROP* rgProperties; ULONG cProperties; GUID guidPropertySet; }; +struct tagDBINDEXCOLUMNDESC{ DBID* pColumnID; DBINDEX_COL_ORDER eIndexColOrder; }; +struct tagDBCOLUMNDESC{ LPOLESTR pwszTypeName; ITypeInfo* pTypeInfo; DBPROPSET* rgPropertySets; CLSID* pclsid; ULONG cPropertySets; DBLENGTH ulColumnSize; DBID dbcid; DBTYPE wType; UCHAR bPrecision; UCHAR bScale; }; +struct tagDBCOLUMNACCESS{ void* pData; DBID columnid; DBLENGTH cbDataLen; DBSTATUS dwStatus; DBLENGTH cbMaxLen; DB_DWRESERVE dwReserved; DBTYPE wType; UCHAR bPrecision; UCHAR bScale; }; +struct tagDBCONSTRAINTDESC{ DBID* pConstraintID; DBCONSTRAINTTYPE ConstraintType; DBORDINAL cColumns; DBID* rgColumnList; DBID* pReferencedTableID; DBORDINAL cForeignKeyColumns; DBID* rgForeignKeyColumnList; OLECHAR* pwszConstraintText; DBUPDELRULE UpdateRule; DBUPDELRULE DeleteRule; DBMATCHTYPE MatchType; DBDEFERRABILITY Deferrability; DB_URESERVE cReserved; DBPROPSET* rgReserved; }; +struct tagMDAXISINFO{ DBLENGTH cbSize; DBCOUNTITEM iAxis; DBCOUNTITEM cDimensions; DBCOUNTITEM cCoordinates; DBORDINAL* rgcColumns; LPOLESTR* rgpwszDimensionNames; }; +struct tagRMTPACK{ ISequentialStream* pISeqStream; ULONG cbData; ULONG cBSTR; BSTR* rgBSTR; ULONG cVARIANT; VARIANT* rgVARIANT; ULONG cIDISPATCH; IDispatch** rgIDISPATCH; ULONG cIUNKNOWN; IUnknown** rgIUNKNOWN; ULONG cPROPVARIANT; PROPVARIANT* rgPROPVARIANT; ULONG cArray; VARIANT* rgArray; }; +struct tagDBPARAMBINDINFO{ LPOLESTR pwszDataSourceType; LPOLESTR pwszName; DBLENGTH ulParamSize; DBPARAMFLAGS dwFlags; UCHAR bPrecision; UCHAR bScale; }; +struct tagDBLITERALINFO{ LPOLESTR pwszLiteralValue; LPOLESTR pwszInvalidChars; LPOLESTR pwszInvalidStartingChars; DBLITERAL lt; BOOL fSupported; ULONG cchMaxLen; }; +struct tagERRORINFO{ HRESULT hrError; ULONG dwMinor; CLSID clsid; IID iid; DISPID dispid; }; +struct tagDBBYGUID{ UCHAR* pbInfo; DBLENGTH cbInfo; GUID guid; }; +struct tagDBCONTENT{ LPOLESTR pwszPhrase; ULONG dwGenerateMethod; LONG lWeight; LCID lcid; }; +struct tagDBCONTENTSCOPE{ ULONG dwFlags; LPOLESTR* rgpwszTagName; LPOLESTR pwszElementValue; }; +struct tagDBCONTENTTABLE{ LPOLESTR pwszMachine; LPOLESTR pwszCatalog; }; +struct tagDBCONTENTVECTOR{ LONG lWeight; ULONG dwRankingMethod; }; +struct tagDBGROUPINFO{ LCID lcid; }; +struct tagDBPARAMETER{ LPOLESTR pwszName; ITypeInfo* pTypeInfo; DB_NUMERIC* pNum; DBLENGTH cbMaxLength; DBPARAMFLAGS dwFlags; DBTYPE wType; }; +struct tagDBSETFUNC{ ULONG dwSetQuantifier; }; +struct tagDBSORTINFO{ BOOL fDesc; LCID lcid; }; +struct tagDBTEXT{ LPOLESTR pwszText; ULONG ulErrorLocator; ULONG ulTokenLength; GUID guidDialect; }; +struct tagDBLIKE{ LONG lWeight; GUID guidDialect; }; +struct tagDBCONTENTPROXIMITY{ ULONG dwProximityUnit; ULONG ulProximityDistance; LONG lWeight; }; +struct tagDBPROBABILISTIC{ LONG lWeight; float flK1; float flK2; float flK3; float flB; }; +struct tagDBRELEVANTDOCUMENT{ LONG lWeight; VARIANT vDocument; }; +struct tagDBCOMMANDTREE{ DBCOMMANDOP op; WORD wKind; tagDBCOMMANDTREE* pctFirstChild; tagDBCOMMANDTREE* pctNextSibling; 556B6635596946574D65324F3568745643442F625847567842444D3D value; HRESULT hrError; }; +struct tagIMAGELISTSTATS{ ULONG cbSize; int cAlloc; int cUsed; int cStandby; }; +enum tagHCN_PORT_PROTOCOL{ HCN_PORT_PROTOCOL_TCP = 1, HCN_PORT_PROTOCOL_UDP = 2, HCN_PORT_PROTOCOL_BOTH = 3 }; +enum tagHCN_PORT_ACCESS{ HCN_PORT_ACCESS_EXCLUSIVE = 1, HCN_PORT_ACCESS_SHARED = 2 }; +struct tagHCN_PORT_RANGE_RESERVATION{ USHORT startingPort; USHORT endingPort; }; +struct tagHCN_PORT_RANGE_ENTRY{ GUID OwningPartitionId; GUID TargetPartitionId; HCN_PORT_PROTOCOL Protocol; UINT64 Priority; UINT32 ReservationType; UINT32 SharingFlags; UINT32 DeliveryMode; UINT16 StartingPort; UINT16 EndingPort; }; +enum tagDUMPTYPE{ DUMPTYPE_FULL = 0, DUMPTYPE_MINI = 1, DUMPTYPE_NONE = 2 }; +enum tagCOMPLUS_APPTYPE{ APPTYPE_UNKNOWN = 4294967295, APPTYPE_SERVER = 1, APPTYPE_LIBRARY = 0, APPTYPE_SWC = 2 }; +enum tagTransactionVote{ TxCommit = 0, TxAbort = 1 }; +struct tagCrmLogRecordRead{ ULONG dwCrmFlags; ULONG dwSequenceNumber; BLOB blobUserData; }; +enum tagCrmTransactionState{ TxState_Active = 0, TxState_Committed = 1, TxState_Aborted = 2, TxState_Indoubt = 3 }; +enum tagCSC_InheritanceConfig{ CSC_Inherit = 0, CSC_Ignore = 1 }; +enum tagCSC_ThreadPool{ CSC_ThreadPoolNone = 0, CSC_ThreadPoolInherit = 1, CSC_STAThreadPool = 2, CSC_MTAThreadPool = 3 }; +enum tagCSC_Binding{ CSC_NoBinding = 0, CSC_BindToPoolThread = 1 }; +enum tagCSC_TransactionConfig{ CSC_NoTransaction = 0, CSC_IfContainerIsTransactional = 1, CSC_CreateTransactionIfNecessary = 2, CSC_NewTransaction = 3 }; +enum tagCSC_SynchronizationConfig{ CSC_NoSynchronization = 0, CSC_IfContainerIsSynchronized = 1, CSC_NewSynchronizationIfNecessary = 2, CSC_NewSynchronization = 3 }; +enum tagCSC_TrackerConfig{ CSC_DontUseTracker = 0, CSC_UseTracker = 1 }; +enum tagCSC_PartitionConfig{ CSC_NoPartition = 0, CSC_InheritPartition = 1, CSC_NewPartition = 2 }; +enum tagCSC_IISIntrinsicsConfig{ CSC_NoIISIntrinsics = 0, CSC_InheritIISIntrinsics = 1 }; +enum tagCSC_COMTIIntrinsicsConfig{ CSC_NoCOMTIIntrinsics = 0, CSC_InheritCOMTIIntrinsics = 1 }; +enum tagCSC_SxsConfig{ CSC_NoSxs = 0, CSC_InheritSxs = 1, CSC_NewSxs = 2 }; +enum tagCRMFLAGS{ CRMFLAG_FORGETTARGET = 1, CRMFLAG_WRITTENDURINGPREPARE = 2, CRMFLAG_WRITTENDURINGCOMMIT = 4, CRMFLAG_WRITTENDURINGABORT = 8, CRMFLAG_WRITTENDURINGRECOVERY = 16, CRMFLAG_WRITTENDURINGREPLAY = 32, CRMFLAG_REPLAYINPROGRESS = 64 }; +enum tagCRMREGFLAGS{ CRMREGFLAG_PREPAREPHASE = 1, CRMREGFLAG_COMMITPHASE = 2, CRMREGFLAG_ABORTPHASE = 4, CRMREGFLAG_ALLPHASES = 7, CRMREGFLAG_FAILIFINDOUBTSREMAIN = 16 }; +enum tagCOINITCOR{ COINITCOR_DEFAULT = 0 }; +enum tagCOINITEE{ COINITEE_DEFAULT = 0, COINITEE_DLL = 1, COINITEE_MAIN = 2 }; +enum tagCOUNINITEE{ COUNINITEE_DEFAULT = 0, COUNINITEE_DLL = 1 }; +struct tagCOR_ILMETHOD_SECT_SMALL{ }; +struct tagCOR_ILMETHOD_SECT_FAT{ }; +struct tagCOR_ILMETHOD_SECT_EH_CLAUSE_FAT{ }; +struct tagCOR_ILMETHOD_SECT_EH_CLAUSE_SMALL{ }; +struct tagCOR_ILMETHOD_TINY{ }; +struct tagCOR_ILMETHOD_FAT{ }; +struct tagCPLINFO{ int idIcon; int idName; int idInfo; LONG_PTR lData; }; +struct tagNEWCPLINFOA{ ULONG dwSize; ULONG dwFlags; ULONG dwHelpContext; LONG_PTR lData; HICON hIcon; CHAR szName[32]; CHAR szInfo[64]; CHAR szHelpFile[128]; }; +struct tagNEWCPLINFOW{ ULONG dwSize; ULONG dwFlags; ULONG dwHelpContext; LONG_PTR lData; HICON hIcon; WCHAR szName[32]; WCHAR szInfo[64]; WCHAR szHelpFile[128]; }; +enum tagSORTDIRECTION{ SORT_DESCENDING = 4294967295, SORT_ASCENDING = 1 }; +enum tagDESKBANDCID{ DBID_BANDINFOCHANGED = 0, DBID_SHOWONLY = 1, DBID_MAXIMIZEBAND = 2, DBID_PUSHCHEVRON = 3, DBID_DELAYINIT = 4, DBID_FINISHINIT = 5, DBID_SETWINDOWTHEME = 6, DBID_PERMITAUTOHIDE = 7 }; +struct tagBANDSITEINFO{ ULONG dwMask; ULONG dwState; ULONG dwStyle; }; +enum tagBANDSITECID{ BSID_BANDADDED = 0, BSID_BANDREMOVED = 1 }; +enum tagMENUBANDHANDLERCID{ MBHANDCID_PIDLSELECT = 0 }; +enum tagMENUPOPUPSELECT{ MPOS_EXECUTE = 0, MPOS_FULLCANCEL = 1, MPOS_CANCELLEVEL = 2, MPOS_SELECTLEFT = 3, MPOS_SELECTRIGHT = 4, MPOS_CHILDTRACKING = 5 }; +enum tagMENUPOPUPPOPUPFLAGS{ MPPF_SETFOCUS = 1, MPPF_INITIALSELECT = 2, MPPF_NOANIMATE = 4, MPPF_KEYBOARD = 16, MPPF_REPOSITION = 32, MPPF_FORCEZORDER = 64, MPPF_FINALSELECT = 128, MPPF_TOP = 536870912, MPPF_LEFT = 1073741824, MPPF_RIGHT = 1610612736, MPPF_BOTTOM = 2147483648, MPPF_POS_MASK = 3758096384, MPPF_ALIGN_LEFT = 33554432, MPPF_ALIGN_RIGHT = 67108864 }; +struct tagSMDATA{ ULONG dwMask; ULONG dwFlags; HMENU hmenu; HWND hwnd; UINT uId; UINT uIdParent; UINT uIdAncestor; IUnknown* punk; LPITEMIDLIST pidlFolder; LPITEMIDLIST pidlItem; IShellFolder* psf; void* pvUserData; }; +struct tagSMINFO{ ULONG dwMask; ULONG dwType; ULONG dwFlags; int iIcon; }; +enum tagSMINFOMASK{ SMIM_TYPE = 1, SMIM_FLAGS = 2, SMIM_ICON = 4 }; +enum tagSMINFOTYPE{ SMIT_SEPARATOR = 1, SMIT_STRING = 2 }; +enum tagSMINFOFLAGS{ SMIF_ICON = 1, SMIF_ACCELERATOR = 2, SMIF_DROPTARGET = 4, SMIF_SUBMENU = 8, SMIF_CHECKED = 32, SMIF_DROPCASCADE = 64, SMIF_HIDDEN = 128, SMIF_DISABLED = 256, SMIF_TRACKPOPUP = 512, SMIF_DEMOTED = 1024, SMIF_ALTSTATE = 2048, SMIF_DRAGNDROP = 4096, SMIF_NEW = 8192 }; +struct tagCSSA{ ULONG dwSize; HWND hwndParent; HINSTANCE hInstance; LPCSTR pTemplateName; ULONG dwFlags; LPCSTR szTitle; ULONG cCertStore; HCERTSTORE* arrayCertStore; LPCSTR szPurposeOid; ULONG cCertContext; PCCERT_CONTEXT* arrayCertContext; LPARAM lCustData; PFNCMHOOKPROC pfnHook; PFNCMFILTERPROC pfnFilter; LPCSTR szHelpFileName; ULONG dwHelpId; HCRYPTPROV hprov; }; +struct tagCSSW{ ULONG dwSize; HWND hwndParent; HINSTANCE hInstance; LPCWSTR pTemplateName; ULONG dwFlags; LPCWSTR szTitle; ULONG cCertStore; HCERTSTORE* arrayCertStore; LPCSTR szPurposeOid; ULONG cCertContext; PCCERT_CONTEXT* arrayCertContext; LPARAM lCustData; PFNCMHOOKPROC pfnHook; PFNCMFILTERPROC pfnFilter; LPCWSTR szHelpFileName; ULONG dwHelpId; HCRYPTPROV hprov; }; +struct tagCERT_VIEWPROPERTIES_STRUCT_A{ ULONG dwSize; HWND hwndParent; HINSTANCE hInstance; ULONG dwFlags; LPCSTR szTitle; PCCERT_CONTEXT pCertContext; LPSTR* arrayPurposes; ULONG cArrayPurposes; ULONG cRootStores; HCERTSTORE* rghstoreRoots; ULONG cStores; HCERTSTORE* rghstoreCAs; ULONG cTrustStores; HCERTSTORE* rghstoreTrust; HCRYPTPROV hprov; LPARAM lCustData; ULONG dwPad; LPCSTR szHelpFileName; ULONG dwHelpId; ULONG nStartPage; ULONG cArrayPropSheetPages; PROPSHEETPAGEA* arrayPropSheetPages; }; +struct tagCERT_VIEWPROPERTIES_STRUCT_W{ ULONG dwSize; HWND hwndParent; HINSTANCE hInstance; ULONG dwFlags; LPCWSTR szTitle; PCCERT_CONTEXT pCertContext; LPSTR* arrayPurposes; ULONG cArrayPurposes; ULONG cRootStores; HCERTSTORE* rghstoreRoots; ULONG cStores; HCERTSTORE* rghstoreCAs; ULONG cTrustStores; HCERTSTORE* rghstoreTrust; HCRYPTPROV hprov; LPARAM lCustData; ULONG dwPad; LPCWSTR szHelpFileName; ULONG dwHelpId; ULONG nStartPage; ULONG cArrayPropSheetPages; PROPSHEETPAGEA* arrayPropSheetPages; }; +struct tagCMOID{ LPCSTR szExtensionOID; ULONG dwTestOperation; LPBYTE pbTestData; ULONG cbTestData; }; +struct tagCMFLTR{ ULONG dwSize; ULONG cExtensionChecks; CERT_FILTER_EXTENSION_MATCH* arrayExtensionChecks; ULONG dwCheckingFlags; }; +struct tagCRYPTUI_INITDIALOG_STRUCT{ LPARAM lParam; PCCERT_CONTEXT pCertContext; }; +struct tagCRYPTUI_VIEWCERTIFICATE_STRUCTW{ ULONG dwSize; HWND hwndParent; ULONG dwFlags; LPCWSTR szTitle; PCCERT_CONTEXT pCertContext; LPCSTR* rgszPurposes; ULONG cPurposes; BOOL fpCryptProviderDataTrustedUsage; ULONG idxSigner; ULONG idxCert; BOOL fCounterSigner; ULONG idxCounterSigner; ULONG cStores; HCERTSTORE* rghStores; ULONG cPropSheetPages; LPCPROPSHEETPAGEW rgPropSheetPages; ULONG nStartPage; }; +struct tagCRYPTUI_VIEWCERTIFICATE_STRUCTA{ ULONG dwSize; HWND hwndParent; ULONG dwFlags; LPCSTR szTitle; PCCERT_CONTEXT pCertContext; LPCSTR* rgszPurposes; ULONG cPurposes; BOOL fpCryptProviderDataTrustedUsage; ULONG idxSigner; ULONG idxCert; BOOL fCounterSigner; ULONG idxCounterSigner; ULONG cStores; HCERTSTORE* rghStores; ULONG cPropSheetPages; LPCPROPSHEETPAGEA rgPropSheetPages; ULONG nStartPage; }; +enum tagOFFLINEFILES_ITEM_TYPE{ OFFLINEFILES_ITEM_TYPE_FILE = 0, OFFLINEFILES_ITEM_TYPE_DIRECTORY = 1, OFFLINEFILES_ITEM_TYPE_SHARE = 2, OFFLINEFILES_ITEM_TYPE_SERVER = 3 }; +enum tagOFFLINEFILES_ITEM_COPY{ OFFLINEFILES_ITEM_COPY_LOCAL = 0, OFFLINEFILES_ITEM_COPY_REMOTE = 1, OFFLINEFILES_ITEM_COPY_ORIGINAL = 2 }; +enum tagOFFLINEFILES_CONNECT_STATE{ OFFLINEFILES_CONNECT_STATE_UNKNOWN = 0, OFFLINEFILES_CONNECT_STATE_OFFLINE = 1, OFFLINEFILES_CONNECT_STATE_ONLINE = 2, OFFLINEFILES_CONNECT_STATE_TRANSPARENTLY_CACHED = 3, OFFLINEFILES_CONNECT_STATE_PARTLY_TRANSPARENTLY_CACHED = 4 }; +enum tagOFFLINEFILES_OFFLINE_REASON{ OFFLINEFILES_OFFLINE_REASON_UNKNOWN = 0, OFFLINEFILES_OFFLINE_REASON_NOT_APPLICABLE = 1, OFFLINEFILES_OFFLINE_REASON_CONNECTION_FORCED = 2, OFFLINEFILES_OFFLINE_REASON_CONNECTION_SLOW = 3, OFFLINEFILES_OFFLINE_REASON_CONNECTION_ERROR = 4, OFFLINEFILES_OFFLINE_REASON_ITEM_VERSION_CONFLICT = 5, OFFLINEFILES_OFFLINE_REASON_ITEM_SUSPENDED = 6 }; +enum tagOFFLINEFILES_CACHING_MODE{ OFFLINEFILES_CACHING_MODE_NONE = 0, OFFLINEFILES_CACHING_MODE_NOCACHING = 1, OFFLINEFILES_CACHING_MODE_MANUAL = 2, OFFLINEFILES_CACHING_MODE_AUTO_DOC = 3, OFFLINEFILES_CACHING_MODE_AUTO_PROGANDDOC = 4 }; +enum tagOFFLINEFILES_OP_RESPONSE{ OFFLINEFILES_OP_CONTINUE = 0, OFFLINEFILES_OP_RETRY = 1, OFFLINEFILES_OP_ABORT = 2 }; +enum tagOFFLINEFILES_EVENTS{ OFFLINEFILES_EVENT_CACHEMOVED = 0, OFFLINEFILES_EVENT_CACHEISFULL = 1, OFFLINEFILES_EVENT_CACHEISCORRUPTED = 2, OFFLINEFILES_EVENT_ENABLED = 3, OFFLINEFILES_EVENT_ENCRYPTIONCHANGED = 4, OFFLINEFILES_EVENT_SYNCBEGIN = 5, OFFLINEFILES_EVENT_SYNCFILERESULT = 6, OFFLINEFILES_EVENT_SYNCCONFLICTRECADDED = 7, OFFLINEFILES_EVENT_SYNCCONFLICTRECUPDATED = 8, OFFLINEFILES_EVENT_SYNCCONFLICTRECREMOVED = 9, OFFLINEFILES_EVENT_SYNCEND = 10, OFFLINEFILES_EVENT_BACKGROUNDSYNCBEGIN = 11, OFFLINEFILES_EVENT_BACKGROUNDSYNCEND = 12, OFFLINEFILES_EVENT_NETTRANSPORTARRIVED = 13, OFFLINEFILES_EVENT_NONETTRANSPORTS = 14, OFFLINEFILES_EVENT_ITEMDISCONNECTED = 15, OFFLINEFILES_EVENT_ITEMRECONNECTED = 16, OFFLINEFILES_EVENT_ITEMAVAILABLEOFFLINE = 17, OFFLINEFILES_EVENT_ITEMNOTAVAILABLEOFFLINE = 18, OFFLINEFILES_EVENT_ITEMPINNED = 19, OFFLINEFILES_EVENT_ITEMNOTPINNED = 20, OFFLINEFILES_EVENT_ITEMMODIFIED = 21, OFFLINEFILES_EVENT_ITEMADDEDTOCACHE = 22, OFFLINEFILES_EVENT_ITEMDELETEDFROMCACHE = 23, OFFLINEFILES_EVENT_ITEMRENAMED = 24, OFFLINEFILES_EVENT_DATALOST = 25, OFFLINEFILES_EVENT_PING = 26, OFFLINEFILES_EVENT_ITEMRECONNECTBEGIN = 27, OFFLINEFILES_EVENT_ITEMRECONNECTEND = 28, OFFLINEFILES_EVENT_CACHEEVICTBEGIN = 29, OFFLINEFILES_EVENT_CACHEEVICTEND = 30, OFFLINEFILES_EVENT_POLICYCHANGEDETECTED = 31, OFFLINEFILES_EVENT_PREFERENCECHANGEDETECTED = 32, OFFLINEFILES_EVENT_SETTINGSCHANGESAPPLIED = 33, OFFLINEFILES_EVENT_TRANSPARENTCACHEITEMNOTIFY = 34, OFFLINEFILES_EVENT_PREFETCHFILEBEGIN = 35, OFFLINEFILES_EVENT_PREFETCHFILEEND = 36, OFFLINEFILES_EVENT_PREFETCHCLOSEHANDLEBEGIN = 37, OFFLINEFILES_EVENT_PREFETCHCLOSEHANDLEEND = 38, OFFLINEFILES_NUM_EVENTS = 39 }; +enum tagOFFLINEFILES_PATHFILTER_MATCH{ OFFLINEFILES_PATHFILTER_SELF = 0, OFFLINEFILES_PATHFILTER_CHILD = 1, OFFLINEFILES_PATHFILTER_DESCENDENT = 2, OFFLINEFILES_PATHFILTER_SELFORCHILD = 3, OFFLINEFILES_PATHFILTER_SELFORDESCENDENT = 4 }; +enum tagOFFLINEFILES_SYNC_CONFLICT_RESOLVE{ OFFLINEFILES_SYNC_CONFLICT_RESOLVE_NONE = 0, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_KEEPLOCAL = 1, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_KEEPREMOTE = 2, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_KEEPALLCHANGES = 3, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_KEEPLATEST = 4, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_LOG = 5, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_SKIP = 6, OFFLINEFILES_SYNC_CONFLICT_ABORT = 7, OFFLINEFILES_SYNC_CONFLICT_RESOLVE_NUMCODES = 8 }; +enum tagOFFLINEFILES_ITEM_TIME{ OFFLINEFILES_ITEM_TIME_CREATION = 0, OFFLINEFILES_ITEM_TIME_LASTACCESS = 1, OFFLINEFILES_ITEM_TIME_LASTWRITE = 2 }; +enum tagOFFLINEFILES_COMPARE{ OFFLINEFILES_COMPARE_EQ = 0, OFFLINEFILES_COMPARE_NEQ = 1, OFFLINEFILES_COMPARE_LT = 2, OFFLINEFILES_COMPARE_GT = 3, OFFLINEFILES_COMPARE_LTE = 4, OFFLINEFILES_COMPARE_GTE = 5 }; +enum tagOFFLINEFILES_SETTING_VALUE_TYPE{ OFFLINEFILES_SETTING_VALUE_UI4 = 0, OFFLINEFILES_SETTING_VALUE_BSTR = 1, OFFLINEFILES_SETTING_VALUE_BSTR_DBLNULTERM = 2, OFFLINEFILES_SETTING_VALUE_2DIM_ARRAY_BSTR_UI4 = 3, OFFLINEFILES_SETTING_VALUE_2DIM_ARRAY_BSTR_BSTR = 4 }; +enum tagOFFLINEFILES_SYNC_OPERATION{ OFFLINEFILES_SYNC_OPERATION_CREATE_COPY_ON_SERVER = 0, OFFLINEFILES_SYNC_OPERATION_CREATE_COPY_ON_CLIENT = 1, OFFLINEFILES_SYNC_OPERATION_SYNC_TO_SERVER = 2, OFFLINEFILES_SYNC_OPERATION_SYNC_TO_CLIENT = 3, OFFLINEFILES_SYNC_OPERATION_DELETE_SERVER_COPY = 4, OFFLINEFILES_SYNC_OPERATION_DELETE_CLIENT_COPY = 5, OFFLINEFILES_SYNC_OPERATION_PIN = 6, OFFLINEFILES_SYNC_OPERATION_PREPARE = 7 }; +enum tagOFFLINEFILES_SYNC_STATE{ OFFLINEFILES_SYNC_STATE_Stable = 0, OFFLINEFILES_SYNC_STATE_FileOnClient_DirOnServer = 1, OFFLINEFILES_SYNC_STATE_FileOnClient_NoServerCopy = 2, OFFLINEFILES_SYNC_STATE_DirOnClient_FileOnServer = 3, OFFLINEFILES_SYNC_STATE_DirOnClient_FileChangedOnServer = 4, OFFLINEFILES_SYNC_STATE_DirOnClient_NoServerCopy = 5, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_NoServerCopy = 6, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_FileChangedOnServer = 7, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_DirChangedOnServer = 8, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_FileOnServer = 9, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_DirOnServer = 10, OFFLINEFILES_SYNC_STATE_FileCreatedOnClient_DeletedOnServer = 11, OFFLINEFILES_SYNC_STATE_FileChangedOnClient_ChangedOnServer = 12, OFFLINEFILES_SYNC_STATE_FileChangedOnClient_DirOnServer = 13, OFFLINEFILES_SYNC_STATE_FileChangedOnClient_DirChangedOnServer = 14, OFFLINEFILES_SYNC_STATE_FileChangedOnClient_DeletedOnServer = 15, OFFLINEFILES_SYNC_STATE_FileSparseOnClient_ChangedOnServer = 16, OFFLINEFILES_SYNC_STATE_FileSparseOnClient_DeletedOnServer = 17, OFFLINEFILES_SYNC_STATE_FileSparseOnClient_DirOnServer = 18, OFFLINEFILES_SYNC_STATE_FileSparseOnClient_DirChangedOnServer = 19, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_NoServerCopy = 20, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_DirOnServer = 21, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_FileOnServer = 22, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_FileChangedOnServer = 23, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_DirChangedOnServer = 24, OFFLINEFILES_SYNC_STATE_DirCreatedOnClient_DeletedOnServer = 25, OFFLINEFILES_SYNC_STATE_DirChangedOnClient_FileOnServer = 26, OFFLINEFILES_SYNC_STATE_DirChangedOnClient_FileChangedOnServer = 27, OFFLINEFILES_SYNC_STATE_DirChangedOnClient_ChangedOnServer = 28, OFFLINEFILES_SYNC_STATE_DirChangedOnClient_DeletedOnServer = 29, OFFLINEFILES_SYNC_STATE_NoClientCopy_FileOnServer = 30, OFFLINEFILES_SYNC_STATE_NoClientCopy_DirOnServer = 31, OFFLINEFILES_SYNC_STATE_NoClientCopy_FileChangedOnServer = 32, OFFLINEFILES_SYNC_STATE_NoClientCopy_DirChangedOnServer = 33, OFFLINEFILES_SYNC_STATE_DeletedOnClient_FileOnServer = 34, OFFLINEFILES_SYNC_STATE_DeletedOnClient_DirOnServer = 35, OFFLINEFILES_SYNC_STATE_DeletedOnClient_FileChangedOnServer = 36, OFFLINEFILES_SYNC_STATE_DeletedOnClient_DirChangedOnServer = 37, OFFLINEFILES_SYNC_STATE_FileSparseOnClient = 38, OFFLINEFILES_SYNC_STATE_FileChangedOnClient = 39, OFFLINEFILES_SYNC_STATE_FileRenamedOnClient = 40, OFFLINEFILES_SYNC_STATE_DirSparseOnClient = 41, OFFLINEFILES_SYNC_STATE_DirChangedOnClient = 42, OFFLINEFILES_SYNC_STATE_DirRenamedOnClient = 43, OFFLINEFILES_SYNC_STATE_FileChangedOnServer = 44, OFFLINEFILES_SYNC_STATE_FileRenamedOnServer = 45, OFFLINEFILES_SYNC_STATE_FileDeletedOnServer = 46, OFFLINEFILES_SYNC_STATE_DirChangedOnServer = 47, OFFLINEFILES_SYNC_STATE_DirRenamedOnServer = 48, OFFLINEFILES_SYNC_STATE_DirDeletedOnServer = 49, OFFLINEFILES_SYNC_STATE_FileReplacedAndDeletedOnClient_FileOnServer = 50, OFFLINEFILES_SYNC_STATE_FileReplacedAndDeletedOnClient_FileChangedOnServer = 51, OFFLINEFILES_SYNC_STATE_FileReplacedAndDeletedOnClient_DirOnServer = 52, OFFLINEFILES_SYNC_STATE_FileReplacedAndDeletedOnClient_DirChangedOnServer = 53, OFFLINEFILES_SYNC_STATE_NUMSTATES = 54 }; +struct tagComCallData{ ULONG dwDispid; ULONG dwReserved; void* pUserDefined; }; +struct tagCCSTYLEA{ ULONG flStyle; ULONG flExtStyle; CHAR szText[256]; LANGID lgid; WORD wReserved1; }; +struct tagCCSTYLEW{ ULONG flStyle; ULONG flExtStyle; WCHAR szText[256]; LANGID lgid; WORD wReserved1; }; +struct tagCCSTYLEFLAGA{ ULONG flStyle; ULONG flStyleMask; LPSTR pszStyle; }; +struct tagCCSTYLEFLAGW{ ULONG flStyle; ULONG flStyleMask; LPWSTR pszStyle; }; +struct tagCCINFOA{ CHAR szClass[32]; ULONG flOptions; CHAR szDesc[32]; UINT cxDefault; UINT cyDefault; ULONG flStyleDefault; ULONG flExtStyleDefault; ULONG flCtrlTypeMask; CHAR szTextDefault[256]; INT cStyleFlags; LPCCSTYLEFLAGA aStyleFlags; LPFNCCSTYLEA lpfnStyle; LPFNCCSIZETOTEXTA lpfnSizeToText; ULONG dwReserved1; ULONG dwReserved2; }; +struct tagCCINFOW{ WCHAR szClass[32]; ULONG flOptions; WCHAR szDesc[32]; UINT cxDefault; UINT cyDefault; ULONG flStyleDefault; ULONG flExtStyleDefault; ULONG flCtrlTypeMask; INT cStyleFlags; LPCCSTYLEFLAGW aStyleFlags; WCHAR szTextDefault[256]; LPFNCCSTYLEW lpfnStyle; LPFNCCSIZETOTEXTW lpfnSizeToText; ULONG dwReserved1; ULONG dwReserved2; }; +struct tagNTExtendedHeapRestrictions{ DDSCAPSEX ddsCapsEx; DDSCAPSEX ddsCapsExAlt; }; +struct _tagADDRESS64{ DWORD64 Offset; WORD Segment; ADDRESS_MODE Mode; }; +struct _tagSTACKFRAME64{ ADDRESS64 AddrPC; ADDRESS64 AddrReturn; ADDRESS64 AddrFrame; ADDRESS64 AddrStack; ADDRESS64 AddrBStore; PVOID FuncTableEntry; DWORD64 Params[4]; BOOL Far; BOOL Virtual; DWORD64 Reserved[3]; KDHELP64 KdHelp; }; +struct _tagSTACKFRAME_EX{ ADDRESS64 AddrPC; ADDRESS64 AddrReturn; ADDRESS64 AddrFrame; ADDRESS64 AddrStack; ADDRESS64 AddrBStore; PVOID FuncTableEntry; DWORD64 Params[4]; BOOL Far; BOOL Virtual; DWORD64 Reserved[3]; KDHELP64 KdHelp; ULONG StackFrameSize; ULONG InlineFrameContext; }; +struct tagExtendedHeapRestrictions{ DDSCAPSEX ddsCapsEx; DDSCAPSEX ddsCapsExAlt; }; +enum tagDdqAccessLevel{ NoData = 0, CurrentUserData = 1, AllUserData = 2 }; +struct tagDIAGNOSTIC_DATA_RECORD{ INT64 rowId; UINT64 timestamp; UINT64 eventKeywords; LPWSTR fullEventName; LPWSTR providerGroupGuid; LPWSTR producerName; INT32* privacyTags; UINT32 privacyTagCount; INT32* categoryIds; UINT32 categoryIdCount; BOOL isCoreData; LPWSTR extra1; LPWSTR extra2; LPWSTR extra3; }; +struct tagDIAGNOSTIC_DATA_SEARCH_CRITERIA{ LPCWSTR* producerNames; UINT32 producerNameCount; LPCWSTR textToMatch; INT32* categoryIds; UINT32 categoryIdCount; INT32* privacyTags; UINT32 privacyTagCount; BOOL coreDataOnly; }; +struct tagDIAGNOSTIC_DATA_EVENT_TAG_DESCRIPTION{ INT32 privacyTag; LPWSTR name; LPWSTR description; }; +struct tagDIAGNOSTIC_DATA_EVENT_PRODUCER_DESCRIPTION{ LPWSTR name; }; +struct tagDIAGNOSTIC_DATA_EVENT_CATEGORY_DESCRIPTION{ INT32 id; LPWSTR name; }; +struct tagDIAGNOSTIC_DATA_EVENT_TAG_STATS{ INT32 privacyTag; UINT32 eventCount; }; +struct tagDIAGNOSTIC_DATA_EVENT_BINARY_STATS{ LPWSTR moduleName; LPWSTR friendlyModuleName; UINT32 eventCount; UINT64 uploadSizeBytes; }; +struct tagDIAGNOSTIC_DATA_GENERAL_STATS{ UINT32 optInLevel; UINT64 transcriptSizeBytes; UINT64 oldestEventTimestamp; UINT32 totalEventCountLast24Hours; FLOAT averageDailyEvents; }; +struct tagDIAGNOSTIC_DATA_EVENT_TRANSCRIPT_CONFIGURATION{ UINT32 hoursOfHistoryToKeep; UINT32 maxStoreMegabytes; UINT32 requestedMaxStoreMegabytes; }; +struct tagDIAGNOSTIC_REPORT_PARAMETER{ WCHAR name[129]; WCHAR value[260]; }; +struct tagDIAGNOSTIC_REPORT_SIGNATURE{ WCHAR eventName[65]; DIAGNOSTIC_REPORT_PARAMETER parameters[10]; }; +struct tagDIAGNOSTIC_REPORT_DATA{ DIAGNOSTIC_REPORT_SIGNATURE signature; GUID bucketId; GUID reportId; FILETIME creationTime; ULONGLONG sizeInBytes; LPWSTR cabId; ULONG reportStatus; GUID reportIntegratorId; LPWSTR* fileNames; ULONG fileCount; LPWSTR friendlyEventName; LPWSTR applicationName; LPWSTR applicationPath; LPWSTR description; LPWSTR bucketIdString; UINT64 legacyBucketId; LPWSTR reportKey; }; +struct tagPAGERANGE{ LONG nFromPage; LONG nToPage; }; +struct tagPAGESET{ ULONG cbStruct; BOOL fOddPages; BOOL fEvenPages; ULONG cPageRange; PAGERANGE rgPages[1]; }; +struct _tagOLECMD{ ULONG cmdID; ULONG cmdf; }; +struct _tagOLECMDTEXT{ ULONG cmdtextf; ULONG cwActual; ULONG cwBuf; wchar_t rgwz[1]; }; +struct tagOCPFIPARAMS{ ULONG cbStructSize; HWND hWndOwner; int x; int y; LPCOLESTR lpszCaption; ULONG cObjects; LPUNKNOWN* lplpUnk; ULONG cPages; CLSID* lpPages; LCID lcid; DISPID dispidInitialProperty; }; +struct tagFONTDESC{ UINT cbSizeofstruct; LPOLESTR lpstrName; CY cySize; SHORT sWeight; SHORT sCharset; BOOL fItalic; BOOL fUnderline; BOOL fStrikethrough; }; +struct tagPICTDESC{ UINT cbSizeofstruct; UINT picType; }; +enum tagDPX_FILE_PROVIDER_QUERY_DISPOSITION{ DPX_FILE_PROVIDER_QUERY_DISPOSITION_INVALID = 0, DPX_FILE_PROVIDER_QUERY_DISPOSITION_SUCCESS = 1, DPX_FILE_PROVIDER_QUERY_DISPOSITION_COMPRESSED = 2 }; +struct tagDpxContainerDecryptionData{ ULONG cbDecryptionData; UCHAR* pDecryptionData; }; +enum tagDPX_CONTAINER_ENCRYPTION_ENUM{ DPX_CONTAINER_ENCRYPTION_NONE = 0, DPX_CONTAINER_ENCRYPTION_ITERATIVE = 1, DPX_CONTAINER_ENCRYPTION_MAX_ENUM = 1 }; +struct tagDpxPredecessorFilePathInfo{ LPCWSTR PredecessorInstallPath; LPCWSTR PredecessorCabPath; LPCWSTR CabPath; }; +enum drt_scope_tag{ DRT_GLOBAL_SCOPE = 1, DRT_SITE_LOCAL_SCOPE = 2, DRT_LINK_LOCAL_SCOPE = 3 }; +enum drt_status_tag{ DRT_ACTIVE = 0, DRT_ALONE = 1, DRT_NO_NETWORK = 10, DRT_FAULTED = 20 }; +enum drt_match_type_tag{ DRT_MATCH_EXACT = 0, DRT_MATCH_NEAR = 1, DRT_MATCH_INTERMEDIATE = 2 }; +enum drt_leafset_key_change_type_tag{ DRT_LEAFSET_KEY_ADDED = 0, DRT_LEAFSET_KEY_DELETED = 1 }; +enum drt_event_type_tag{ DRT_EVENT_STATUS_CHANGED = 0, DRT_EVENT_LEAFSET_KEY_CHANGED = 1, DRT_EVENT_REGISTRATION_STATE_CHANGED = 2 }; +enum drt_security_mode_tag{ DRT_SECURE_RESOLVE = 0, DRT_SECURE_MEMBERSHIP = 1, DRT_SECURE_CONFIDENTIALPAYLOAD = 2 }; +struct drt_data_tag{ ULONG cb; UCHAR* pb; }; +struct drt_registration_tag{ DRT_DATA key; DRT_DATA appData; }; +struct drt_security_provider_tag{ PVOID pvContext; }; +struct drt_bootstrap_provider_tag{ PVOID pvContext; }; +struct drt_settings_tag{ ULONG dwSize; ULONG cbKey; UCHAR bProtocolMajorVersion; UCHAR bProtocolMinorVersion; ULONG ulMaxRoutingAddresses; PWSTR pwzDrtInstancePrefix; HDRT_TRANSPORT hTransport; DRT_SECURITY_PROVIDER* pSecurityProvider; DRT_BOOTSTRAP_PROVIDER* pBootstrapProvider; DRT_SECURITY_MODE eSecurityMode; }; +struct drt_search_info_tag{ ULONG dwSize; BOOL fIterative; BOOL fAllowCurrentInstanceMatch; BOOL fAnyMatchInRange; ULONG cMaxEndpoints; DRT_DATA* pMaximumKey; DRT_DATA* pMinimumKey; }; +struct drt_search_result_tag{ ULONG dwSize; DRT_MATCH_TYPE type; PVOID pvContext; DRT_REGISTRATION registration; }; +struct drt_event_data_tag{ DRT_EVENT_TYPE type; HRESULT hr; PVOID pvContext; }; +enum _tagDVD_ERROR{ DVD_ERROR_Unexpected = 1, DVD_ERROR_CopyProtectFail = 2, DVD_ERROR_InvalidDVD1_0Disc = 3, DVD_ERROR_InvalidDiscRegion = 4, DVD_ERROR_LowParentalLevel = 5, DVD_ERROR_MacrovisionFail = 6, DVD_ERROR_IncompatibleSystemAndDecoderRegions = 7, DVD_ERROR_IncompatibleDiscAndDecoderRegions = 8, DVD_ERROR_CopyProtectOutputFail = 9, DVD_ERROR_CopyProtectOutputNotSupported = 10 }; +enum _tagDVD_WARNING{ DVD_WARNING_InvalidDVD1_0Disc = 1, DVD_WARNING_FormatNotSupported = 2, DVD_WARNING_IllegalNavCommand = 3, DVD_WARNING_Open = 4, DVD_WARNING_Seek = 5, DVD_WARNING_Read = 6 }; +enum _tagDVD_PB_STOPPED{ DVD_PB_STOPPED_Other = 0, DVD_PB_STOPPED_NoBranch = 1, DVD_PB_STOPPED_NoFirstPlayDomain = 2, DVD_PB_STOPPED_StopCommand = 3, DVD_PB_STOPPED_Reset = 4, DVD_PB_STOPPED_DiscEjected = 5, DVD_PB_STOPPED_IllegalNavCommand = 6, DVD_PB_STOPPED_PlayPeriodAutoStop = 7, DVD_PB_STOPPED_PlayChapterAutoStop = 8, DVD_PB_STOPPED_ParentalFailure = 9, DVD_PB_STOPPED_RegionFailure = 10, DVD_PB_STOPPED_MacrovisionFailure = 11, DVD_PB_STOPPED_DiscReadError = 12, DVD_PB_STOPPED_CopyProtectFailure = 13, DVD_PB_STOPPED_CopyProtectOutputFailure = 14, DVD_PB_STOPPED_CopyProtectOutputNotSupported = 15 }; +enum tagWMT_STORAGE_FORMAT{ WMT_Storage_Format_MP3 = 0, WMT_Storage_Format_V1 = 1 }; +enum tagWMT_DRMLA_TRUST{ WMT_DRMLA_UNTRUSTED = 0, WMT_DRMLA_TRUSTED = 1, WMT_DRMLA_TAMPERED = 2 }; +enum tagWMT_TRANSPORT_TYPE{ WMT_Transport_Type_Unreliable = 0, WMT_Transport_Type_Reliable = 1 }; +enum tagWMT_OFFSET_FORMAT{ WMT_OFFSET_FORMAT_100NS = 0, WMT_OFFSET_FORMAT_FRAME_NUMBERS = 1, WMT_OFFSET_FORMAT_PLAYLIST_OFFSET = 2, WMT_OFFSET_FORMAT_TIMECODE = 3, WMT_OFFSET_FORMAT_100NS_APPROXIMATE = 4 }; +enum tagWMT_INDEXER_TYPE{ WMT_IT_PRESENTATION_TIME = 0, WMT_IT_FRAME_NUMBERS = 1, WMT_IT_TIMECODE = 2 }; +enum tagWMT_INDEX_TYPE{ WMT_IT_NEAREST_DATA_UNIT = 1, WMT_IT_NEAREST_OBJECT = 2, WMT_IT_NEAREST_CLEAN_POINT = 3 }; +enum tagWMT_FILESINK_MODE{ WMT_FM_SINGLE_BUFFERS = 1, WMT_FM_FILESINK_DATA_UNITS = 2, WMT_FM_FILESINK_UNBUFFERED = 4 }; +enum tagWMT_MUSICSPEECH_CLASS_MODE{ WMT_MS_CLASS_MUSIC = 0, WMT_MS_CLASS_SPEECH = 1, WMT_MS_CLASS_MIXED = 2 }; +enum tagWMT_WATERMARK_ENTRY_TYPE{ WMT_WMETYPE_AUDIO = 1, WMT_WMETYPE_VIDEO = 2 }; +struct tagWMVIDEOINFOHEADER{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; LONGLONG AvgTimePerFrame; BITMAPINFOHEADER bmiHeader; }; +struct tagWMVIDEOINFOHEADER2{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; LONGLONG AvgTimePerFrame; ULONG dwInterlaceFlags; ULONG dwCopyProtectFlags; ULONG dwPictAspectRatioX; ULONG dwPictAspectRatioY; ULONG dwReserved1; ULONG dwReserved2; BITMAPINFOHEADER bmiHeader; }; +struct tagWMMPEG2VIDEOINFO{ WMVIDEOINFOHEADER2 hdr; ULONG dwStartTimeCode; ULONG cbSequenceHeader; ULONG dwProfile; ULONG dwLevel; ULONG dwFlags; ULONG dwSequenceHeader[1]; }; +struct tagWMSCRIPTFORMAT{ GUID scriptType; }; +struct __tagDRM_MINIMUM_OUTPUT_PROTECTION_LEVELS{ WORD wCompressedDigitalVideo; WORD wUncompressedDigitalVideo; WORD wAnalogVideo; WORD wCompressedDigitalAudio; WORD wUncompressedDigitalAudio; }; +struct __tagDRM_OPL_OUTPUT_IDS{ WORD cIds; GUID* rgIds; }; +struct __tagDRM_OUTPUT_PROTECTION{ GUID guidId; UCHAR bConfigData; }; +struct __tagDRM_VIDEO_OUTPUT_PROTECTION_IDS{ WORD cEntries; DRM_VIDEO_OUTPUT_PROTECTION* rgVop; }; +struct __tagDRM_PLAY_OPL{ DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS minOPL; DRM_OPL_OUTPUT_IDS oplIdReserved; DRM_VIDEO_OUTPUT_PROTECTION_IDS vopi; }; +struct __tagDRM_COPY_OPL{ WORD wMinimumCopyLevel; DRM_OPL_OUTPUT_IDS oplIdIncludes; DRM_OPL_OUTPUT_IDS oplIdExcludes; }; +struct tagAM_DvdKaraokeData{ ULONG dwDownmix; ULONG dwSpeakerAssignment; }; +enum tagEapPeerMethodResponseAction{ EapPeerMethodResponseActionDiscard = 0, EapPeerMethodResponseActionSend = 1, EapPeerMethodResponseActionResult = 2, EapPeerMethodResponseActionInvokeUI = 3, EapPeerMethodResponseActionRespond = 4, EapPeerMethodResponseActionNone = 5 }; +struct tagEapPeerMethodOuput{ EapPeerMethodResponseAction action; BOOL fAllowNotifications; }; +enum tagEapPeerMethodResultReason{ EapPeerMethodResultUnknown = 1, EapPeerMethodResultSuccess = 2, EapPeerMethodResultFailure = 3 }; +struct tagXHR_COOKIE{ WCHAR* pwszUrl; WCHAR* pwszName; WCHAR* pwszValue; WCHAR* pwszP3PPolicy; FILETIME ftExpires; ULONG dwFlags; }; +struct tagXHR_CERT{ ULONG cbCert; UCHAR* pbCert; }; +enum tagEapHostPeerMethodResultReason{ EapHostPeerMethodResultAltSuccessReceived = 1, EapHostPeerMethodResultTimeout = 2, EapHostPeerMethodResultFromMethod = 3 }; +enum tagEapHostPeerResponseAction{ EapHostPeerResponseDiscard = 0, EapHostPeerResponseSend = 1, EapHostPeerResponseResult = 2, EapHostPeerResponseInvokeUi = 3, EapHostPeerResponseRespond = 4, EapHostPeerResponseStartAuthentication = 5, EapHostPeerResponseNone = 6 }; +enum tagEapHostPeerAuthParams{ EapHostPeerAuthStatus = 1, EapHostPeerIdentity = 2, EapHostPeerIdentityExtendedInfo = 3, EapHostNapInfo = 4 }; +struct tagEapHostPeerMethodResult{ BOOL fIsSuccess; UINT32 dwFailureReasonCode; BOOL fSaveConnectionData; UINT32 dwSizeofConnectionData; UCHAR* pConnectionData; BOOL fSaveUserData; UINT32 dwSizeofUserData; UCHAR* pUserData; EAP_ATTRIBUTES* pAttribArray; ISOLATION_STATE isolationState; EAP_METHOD_INFO* pEapMethodInfo; EAP_ERROR* pEapError; }; +struct tagEapPacket{ UCHAR Code; UCHAR Id; UCHAR Length[2]; UCHAR Data[1]; }; +enum tagEapCode{ EapCodeMinimum = 1, EapCodeRequest = 1, EapCodeResponse = 2, EapCodeSuccess = 3, EapCodeFailure = 4, EapCodeMaximum = 4 }; +struct tagEapPeerMethodResult{ BOOL fIsSuccess; ULONG dwFailureReasonCode; BOOL fSaveConnectionData; ULONG dwSizeofConnectionData; UCHAR* pConnectionData; BOOL fSaveUserData; ULONG dwSizeofUserData; UCHAR* pUserData; EAP_ATTRIBUTES* pAttribArray; EAP_ERROR* pEapError; NgcTicketContext* pNgcKerbTicket; BOOL fSaveToCredMan; }; +struct tagTimedLevel{ unsigned char frequency[2]; unsigned char waveform[2]; int state; long long timeStamp; }; +enum tagWPD_STREAM_UNITS{ WPD_STREAM_UNITS_BYTES = 0, WPD_STREAM_UNITS_FRAMES = 1, WPD_STREAM_UNITS_ROWS = 2, WPD_STREAM_UNITS_MILLISECONDS = 4, WPD_STREAM_UNITS_MICROSECONDS = 8 }; +enum tagEFaultRepRetVal{ frrvOk = 0, frrvOkManifest = 1, frrvOkQueued = 2, frrvErr = 3, frrvErrNoDW = 4, frrvErrTimeout = 5, frrvLaunchDebugger = 6, frrvOkHeadless = 7, frrvErrAnotherInstance = 8, frrvErrNoMemory = 9, frrvErrDoubleFault = 10 }; +struct tagJET_INDEXID{ unsigned long cbStruct; unsigned char rgbIndexId[16]; }; +struct tagCONVERT_A{ char* szOldDll; }; +struct tagCONVERT_W{ WCHAR* szOldDll; }; +struct tag_JET_COLUMNCREATE_A{ unsigned long cbStruct; char* szColumnName; JET_COLTYP coltyp; unsigned long cbMax; JET_GRBIT grbit; void* pvDefault; unsigned long cbDefault; unsigned long cp; JET_COLUMNID columnid; JET_ERR err; }; +struct tag_JET_COLUMNCREATE_W{ unsigned long cbStruct; WCHAR* szColumnName; JET_COLTYP coltyp; unsigned long cbMax; JET_GRBIT grbit; void* pvDefault; unsigned long cbDefault; unsigned long cp; JET_COLUMNID columnid; JET_ERR err; }; +struct tag_JET_USERDEFINEDDEFAULT_A{ char* szCallback; unsigned char* pbUserData; unsigned long cbUserData; char* szDependantColumns; }; +struct tag_JET_USERDEFINEDDEFAULT_W{ WCHAR* szCallback; unsigned char* pbUserData; unsigned long cbUserData; WCHAR* szDependantColumns; }; +struct tagJET_CONDITIONALCOLUMN_A{ unsigned long cbStruct; char* szColumnName; JET_GRBIT grbit; }; +struct tagJET_CONDITIONALCOLUMN_W{ unsigned long cbStruct; WCHAR* szColumnName; JET_GRBIT grbit; }; +struct tagJET_UNICODEINDEX{ unsigned long lcid; unsigned long dwMapFlags; }; +struct tagJET_UNICODEINDEX2{ WCHAR* szLocaleName; unsigned long dwMapFlags; }; +struct tagJET_TUPLELIMITS{ unsigned long chLengthMin; unsigned long chLengthMax; unsigned long chToIndexMax; unsigned long cchIncrement; unsigned long ichStart; }; +struct tagJET_SPACEHINTS{ unsigned long cbStruct; unsigned long ulInitialDensity; unsigned long cbInitial; JET_GRBIT grbit; unsigned long ulMaintDensity; unsigned long ulGrowth; unsigned long cbMinExtent; unsigned long cbMaxExtent; }; +struct tagJET_INDEXCREATE_A{ unsigned long cbStruct; char* szIndexName; char* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_CONDITIONALCOLUMN_A* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; }; +struct tagJET_INDEXCREATE_W{ unsigned long cbStruct; WCHAR* szIndexName; WCHAR* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_CONDITIONALCOLUMN_W* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; }; +struct tagJET_INDEXCREATE2_A{ unsigned long cbStruct; char* szIndexName; char* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_CONDITIONALCOLUMN_A* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; JET_SPACEHINTS* pSpacehints; }; +struct tagJET_INDEXCREATE2_W{ unsigned long cbStruct; WCHAR* szIndexName; WCHAR* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_CONDITIONALCOLUMN_W* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; JET_SPACEHINTS* pSpacehints; }; +struct tagJET_INDEXCREATE3_A{ unsigned long cbStruct; char* szIndexName; char* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_UNICODEINDEX2* pidxunicode; JET_CONDITIONALCOLUMN_A* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; JET_SPACEHINTS* pSpacehints; }; +struct tagJET_INDEXCREATE3_W{ unsigned long cbStruct; WCHAR* szIndexName; WCHAR* szKey; unsigned long cbKey; JET_GRBIT grbit; unsigned long ulDensity; JET_UNICODEINDEX2* pidxunicode; JET_CONDITIONALCOLUMN_W* rgconditionalcolumn; unsigned long cConditionalColumn; JET_ERR err; unsigned long cbKeyMost; JET_SPACEHINTS* pSpacehints; }; +struct tagJET_TABLECREATE_A{ unsigned long cbStruct; char* szTableName; char* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_A* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE_A* rgindexcreate; unsigned long cIndexes; JET_GRBIT grbit; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE_W{ unsigned long cbStruct; WCHAR* szTableName; WCHAR* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_W* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE_W* rgindexcreate; unsigned long cIndexes; JET_GRBIT grbit; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE2_A{ unsigned long cbStruct; char* szTableName; char* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_A* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE_A* rgindexcreate; unsigned long cIndexes; char* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE2_W{ unsigned long cbStruct; WCHAR* szTableName; WCHAR* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_W* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE_W* rgindexcreate; unsigned long cIndexes; WCHAR* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE3_A{ unsigned long cbStruct; char* szTableName; char* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_A* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE2_A* rgindexcreate; unsigned long cIndexes; char* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_SPACEHINTS* pSeqSpacehints; JET_SPACEHINTS* pLVSpacehints; unsigned long cbSeparateLV; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE3_W{ unsigned long cbStruct; WCHAR* szTableName; WCHAR* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_W* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE2_W* rgindexcreate; unsigned long cIndexes; WCHAR* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_SPACEHINTS* pSeqSpacehints; JET_SPACEHINTS* pLVSpacehints; unsigned long cbSeparateLV; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE4_A{ unsigned long cbStruct; char* szTableName; char* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_A* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE3_A* rgindexcreate; unsigned long cIndexes; char* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_SPACEHINTS* pSeqSpacehints; JET_SPACEHINTS* pLVSpacehints; unsigned long cbSeparateLV; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_TABLECREATE4_W{ unsigned long cbStruct; WCHAR* szTableName; WCHAR* szTemplateTableName; unsigned long ulPages; unsigned long ulDensity; JET_COLUMNCREATE_W* rgcolumncreate; unsigned long cColumns; JET_INDEXCREATE3_W* rgindexcreate; unsigned long cIndexes; WCHAR* szCallback; JET_CBTYP cbtyp; JET_GRBIT grbit; JET_SPACEHINTS* pSeqSpacehints; JET_SPACEHINTS* pLVSpacehints; unsigned long cbSeparateLV; JET_TABLEID tableid; unsigned long cCreated; }; +struct tagJET_OPENTEMPORARYTABLE{ unsigned long cbStruct; JET_COLUMNDEF* prgcolumndef; unsigned long ccolumn; JET_UNICODEINDEX* pidxunicode; JET_GRBIT grbit; JET_COLUMNID* prgcolumnid; unsigned long cbKeyMost; unsigned long cbVarSegMac; JET_TABLEID tableid; }; +struct tagJET_OPENTEMPORARYTABLE2{ unsigned long cbStruct; JET_COLUMNDEF* prgcolumndef; unsigned long ccolumn; JET_UNICODEINDEX2* pidxunicode; JET_GRBIT grbit; JET_COLUMNID* prgcolumnid; unsigned long cbKeyMost; unsigned long cbVarSegMac; JET_TABLEID tableid; }; +struct tagFULLPROPSPEC{ GUID guidPropSet; PROPSPEC psProperty; }; +enum tagIFILTER_INIT{ IFILTER_INIT_CANON_PARAGRAPHS = 1, IFILTER_INIT_HARD_LINE_BREAKS = 2, IFILTER_INIT_CANON_HYPHENS = 4, IFILTER_INIT_CANON_SPACES = 8, IFILTER_INIT_APPLY_INDEX_ATTRIBUTES = 16, IFILTER_INIT_APPLY_OTHER_ATTRIBUTES = 32, IFILTER_INIT_APPLY_CRAWL_ATTRIBUTES = 256, IFILTER_INIT_INDEXING_ONLY = 64, IFILTER_INIT_SEARCH_LINKS = 128, IFILTER_INIT_FILTER_OWNED_VALUE_OK = 512, IFILTER_INIT_FILTER_AGGRESSIVE_BREAK = 1024, IFILTER_INIT_DISABLE_EMBEDDED = 2048, IFILTER_INIT_EMIT_FORMATTING = 4096 }; +enum tagIFILTER_FLAGS{ IFILTER_FLAGS_OLE_PROPERTIES = 1 }; +enum tagCHUNKSTATE{ CHUNK_TEXT = 1, CHUNK_VALUE = 2, CHUNK_FILTER_OWNED_VALUE = 4 }; +enum tagCHUNK_BREAKTYPE{ CHUNK_NO_BREAK = 0, CHUNK_EOW = 1, CHUNK_EOS = 2, CHUNK_EOP = 3, CHUNK_EOC = 4 }; +struct tagFILTERREGION{ ULONG idChunk; ULONG cwcStart; ULONG cwcExtent; }; +struct tagSTAT_CHUNK{ ULONG idChunk; CHUNK_BREAKTYPE breakType; CHUNKSTATE flags; LCID locale; FULLPROPSPEC attribute; ULONG idChunkSource; ULONG cwcStartSource; ULONG cwcLenSource; }; +enum tagPropertyConstraint{ QC_EQUALS = 0, QC_NOTEQUAL = 1, QC_LESSTHAN = 2, QC_LESSTHANOREQUAL = 3, QC_GREATERTHAN = 4, QC_GREATERTHANOREQUAL = 5, QC_STARTSWITH = 6, QC_EXISTS = 7, QC_DOESNOTEXIST = 8, QC_CONTAINS = 9 }; +enum tagSystemVisibilityFlags{ SVF_SYSTEM = 0, SVF_USER = 1 }; +enum tagQueryUpdateAction{ QUA_ADD = 0, QUA_REMOVE = 1, QUA_CHANGE = 2 }; +enum tagQueryCategoryType{ QCT_PROVIDER = 0, QCT_LAYERED = 1 }; +enum _tagPEKIND{ peNone = 0, peMSIL = 1, peI386 = 2, peIA64 = 3, peAMD64 = 4, peARM = 5, peARM64 = 6, peInvalid = 4294967295 }; +enum _tagAssemblyContentType{ AssemblyContentType_Default = 0, AssemblyContentType_WindowsRuntime = 1, AssemblyContentType_Invalid = 4294967295 }; +enum _tagAssemblyComparisonResult{ ACR_Unknown = 0, ACR_EquivalentFullMatch = 1, ACR_EquivalentWeakNamed = 2, ACR_EquivalentFXUnified = 3, ACR_EquivalentUnified = 4, ACR_NonEquivalentVersion = 5, ACR_NonEquivalent = 6, ACR_EquivalentPartialMatch = 7, ACR_EquivalentPartialWeakNamed = 8, ACR_EquivalentPartialUnified = 9, ACR_EquivalentPartialFXUnified = 10, ACR_NonEquivalentPartialVersion = 11 }; +enum tag_WBEM_GENUS_TYPE{ WBEM_GENUS_CLASS = 1, WBEM_GENUS_INSTANCE = 2 }; +enum tag_WBEM_CHANGE_FLAG_TYPE{ WBEM_FLAG_CREATE_OR_UPDATE = 0, WBEM_FLAG_UPDATE_ONLY = 1, WBEM_FLAG_CREATE_ONLY = 2, WBEM_FLAG_UPDATE_COMPATIBLE = 0, WBEM_FLAG_UPDATE_SAFE_MODE = 32, WBEM_FLAG_UPDATE_FORCE_MODE = 64, WBEM_MASK_UPDATE_MODE = 96, WBEM_FLAG_ADVISORY = 65536 }; +enum tag_WBEM_GENERIC_FLAG_TYPE{ WBEM_FLAG_RETURN_IMMEDIATELY = 16, WBEM_FLAG_RETURN_WBEM_COMPLETE = 0, WBEM_FLAG_BIDIRECTIONAL = 0, WBEM_FLAG_FORWARD_ONLY = 32, WBEM_FLAG_NO_ERROR_OBJECT = 64, WBEM_FLAG_RETURN_ERROR_OBJECT = 0, WBEM_FLAG_SEND_STATUS = 128, WBEM_FLAG_DONT_SEND_STATUS = 0, WBEM_FLAG_ENSURE_LOCATABLE = 256, WBEM_FLAG_DIRECT_READ = 512, WBEM_FLAG_SEND_ONLY_SELECTED = 0, WBEM_RETURN_WHEN_COMPLETE = 0, WBEM_RETURN_IMMEDIATELY = 16, WBEM_MASK_RESERVED_FLAGS = 126976, WBEM_FLAG_USE_AMENDED_QUALIFIERS = 131072, WBEM_FLAG_STRONG_VALIDATION = 1048576 }; +enum tag_WBEM_STATUS_TYPE{ WBEM_STATUS_COMPLETE = 0, WBEM_STATUS_REQUIREMENTS = 1, WBEM_STATUS_PROGRESS = 2, WBEM_STATUS_LOGGING_INFORMATION = 256, WBEM_STATUS_LOGGING_INFORMATION_PROVIDER = 512, WBEM_STATUS_LOGGING_INFORMATION_HOST = 1024, WBEM_STATUS_LOGGING_INFORMATION_REPOSITORY = 2048, WBEM_STATUS_LOGGING_INFORMATION_ESS = 4096 }; +enum tag_WBEM_TIMEOUT_TYPE{ WBEM_NO_WAIT = 0, WBEM_INFINITE = 4294967295 }; +enum tag_WBEM_CONDITION_FLAG_TYPE{ WBEM_FLAG_ALWAYS = 0, WBEM_FLAG_ONLY_IF_TRUE = 1, WBEM_FLAG_ONLY_IF_FALSE = 2, WBEM_FLAG_ONLY_IF_IDENTICAL = 3, WBEM_MASK_PRIMARY_CONDITION = 3, WBEM_FLAG_KEYS_ONLY = 4, WBEM_FLAG_REFS_ONLY = 8, WBEM_FLAG_LOCAL_ONLY = 16, WBEM_FLAG_PROPAGATED_ONLY = 32, WBEM_FLAG_SYSTEM_ONLY = 48, WBEM_FLAG_NONSYSTEM_ONLY = 64, WBEM_MASK_CONDITION_ORIGIN = 112, WBEM_FLAG_CLASS_OVERRIDES_ONLY = 256, WBEM_FLAG_CLASS_LOCAL_AND_OVERRIDES = 512, WBEM_MASK_CLASS_CONDITION = 768 }; +enum tag_WBEM_FLAVOR_TYPE{ WBEM_FLAVOR_DONT_PROPAGATE = 0, WBEM_FLAVOR_FLAG_PROPAGATE_TO_INSTANCE = 1, WBEM_FLAVOR_FLAG_PROPAGATE_TO_DERIVED_CLASS = 2, WBEM_FLAVOR_MASK_PROPAGATION = 15, WBEM_FLAVOR_OVERRIDABLE = 0, WBEM_FLAVOR_NOT_OVERRIDABLE = 16, WBEM_FLAVOR_MASK_PERMISSIONS = 16, WBEM_FLAVOR_ORIGIN_LOCAL = 0, WBEM_FLAVOR_ORIGIN_PROPAGATED = 32, WBEM_FLAVOR_ORIGIN_SYSTEM = 64, WBEM_FLAVOR_MASK_ORIGIN = 96, WBEM_FLAVOR_NOT_AMENDED = 0, WBEM_FLAVOR_AMENDED = 128, WBEM_FLAVOR_MASK_AMENDED = 128 }; +enum tag_WBEM_QUERY_FLAG_TYPE{ WBEM_FLAG_DEEP = 0, WBEM_FLAG_SHALLOW = 1, WBEM_FLAG_PROTOTYPE = 2 }; +enum tag_WBEM_SECURITY_FLAGS{ WBEM_ENABLE = 1, WBEM_METHOD_EXECUTE = 2, WBEM_FULL_WRITE_REP = 4, WBEM_PARTIAL_WRITE_REP = 8, WBEM_WRITE_PROVIDER = 16, WBEM_REMOTE_ACCESS = 32, WBEM_RIGHT_SUBSCRIBE = 64, WBEM_RIGHT_PUBLISH = 128 }; +enum tag_WBEM_LIMITATION_FLAG_TYPE{ WBEM_FLAG_EXCLUDE_OBJECT_QUALIFIERS = 16, WBEM_FLAG_EXCLUDE_PROPERTY_QUALIFIERS = 32 }; +enum tag_WBEM_TEXT_FLAG_TYPE{ WBEM_FLAG_NO_FLAVORS = 1 }; +enum tag_WBEM_COMPARISON_FLAG{ WBEM_COMPARISON_INCLUDE_ALL = 0, WBEM_FLAG_IGNORE_QUALIFIERS = 1, WBEM_FLAG_IGNORE_OBJECT_SOURCE = 2, WBEM_FLAG_IGNORE_DEFAULT_VALUES = 4, WBEM_FLAG_IGNORE_CLASS = 8, WBEM_FLAG_IGNORE_CASE = 16, WBEM_FLAG_IGNORE_FLAVOR = 32 }; +enum tag_WBEM_LOCKING{ WBEM_FLAG_ALLOW_READ = 1 }; +enum tag_CIMTYPE_ENUMERATION{ CIM_ILLEGAL = 4095, CIM_EMPTY = 0, CIM_SINT8 = 16, CIM_UINT8 = 17, CIM_SINT16 = 2, CIM_UINT16 = 18, CIM_SINT32 = 3, CIM_UINT32 = 19, CIM_SINT64 = 20, CIM_UINT64 = 21, CIM_REAL32 = 4, CIM_REAL64 = 5, CIM_BOOLEAN = 11, CIM_STRING = 8, CIM_DATETIME = 101, CIM_REFERENCE = 102, CIM_CHAR16 = 103, CIM_OBJECT = 13, CIM_FLAG_ARRAY = 8192 }; +enum tag_WBEM_BACKUP_RESTORE_FLAGS{ WBEM_FLAG_BACKUP_RESTORE_DEFAULT = 0, WBEM_FLAG_BACKUP_RESTORE_FORCE_SHUTDOWN = 1 }; +enum tag_WBEM_REFRESHER_FLAGS{ WBEM_FLAG_REFRESH_AUTO_RECONNECT = 0, WBEM_FLAG_REFRESH_NO_AUTO_RECONNECT = 1 }; +enum tag_WBEM_SHUTDOWN_FLAGS{ WBEM_SHUTDOWN_UNLOAD_COMPONENT = 1, WBEM_SHUTDOWN_WMI = 2, WBEM_SHUTDOWN_OS = 3 }; +enum tag_WBEMSTATUS_FORMAT{ WBEMSTATUS_FORMAT_NEWLINE = 0, WBEMSTATUS_FORMAT_NO_NEWLINE = 1 }; +enum tag_WBEM_LIMITS{ WBEM_MAX_IDENTIFIER = 4096, WBEM_MAX_QUERY = 16384, WBEM_MAX_PATH = 8192, WBEM_MAX_OBJECT_NESTING = 64, WBEM_MAX_USER_PROPERTIES = 1024 }; +enum tag_WBEMSTATUS{ WBEM_NO_ERROR = 0, WBEM_S_NO_ERROR = 0, WBEM_S_SAME = 0, WBEM_S_FALSE = 1, WBEM_S_ALREADY_EXISTS = 262145, WBEM_S_RESET_TO_DEFAULT = 262146, WBEM_S_DIFFERENT = 262147, WBEM_S_TIMEDOUT = 262148, WBEM_S_NO_MORE_DATA = 262149, WBEM_S_OPERATION_CANCELLED = 262150, WBEM_S_PENDING = 262151, WBEM_S_DUPLICATE_OBJECTS = 262152, WBEM_S_ACCESS_DENIED = 262153, WBEM_S_PARTIAL_RESULTS = 262160, WBEM_S_SOURCE_NOT_AVAILABLE = 262167, WBEM_E_FAILED = 2147749889, WBEM_E_NOT_FOUND = 2147749890, WBEM_E_ACCESS_DENIED = 2147749891, WBEM_E_PROVIDER_FAILURE = 2147749892, WBEM_E_TYPE_MISMATCH = 2147749893, WBEM_E_OUT_OF_MEMORY = 2147749894, WBEM_E_INVALID_CONTEXT = 2147749895, WBEM_E_INVALID_PARAMETER = 2147749896, WBEM_E_NOT_AVAILABLE = 2147749897, WBEM_E_CRITICAL_ERROR = 2147749898, WBEM_E_INVALID_STREAM = 2147749899, WBEM_E_NOT_SUPPORTED = 2147749900, WBEM_E_INVALID_SUPERCLASS = 2147749901, WBEM_E_INVALID_NAMESPACE = 2147749902, WBEM_E_INVALID_OBJECT = 2147749903, WBEM_E_INVALID_CLASS = 2147749904, WBEM_E_PROVIDER_NOT_FOUND = 2147749905, WBEM_E_INVALID_PROVIDER_REGISTRATION = 2147749906, WBEM_E_PROVIDER_LOAD_FAILURE = 2147749907, WBEM_E_INITIALIZATION_FAILURE = 2147749908, WBEM_E_TRANSPORT_FAILURE = 2147749909, WBEM_E_INVALID_OPERATION = 2147749910, WBEM_E_INVALID_QUERY = 2147749911, WBEM_E_INVALID_QUERY_TYPE = 2147749912, WBEM_E_ALREADY_EXISTS = 2147749913, WBEM_E_OVERRIDE_NOT_ALLOWED = 2147749914, WBEM_E_PROPAGATED_QUALIFIER = 2147749915, WBEM_E_PROPAGATED_PROPERTY = 2147749916, WBEM_E_UNEXPECTED = 2147749917, WBEM_E_ILLEGAL_OPERATION = 2147749918, WBEM_E_CANNOT_BE_KEY = 2147749919, WBEM_E_INCOMPLETE_CLASS = 2147749920, WBEM_E_INVALID_SYNTAX = 2147749921, WBEM_E_NONDECORATED_OBJECT = 2147749922, WBEM_E_READ_ONLY = 2147749923, WBEM_E_PROVIDER_NOT_CAPABLE = 2147749924, WBEM_E_CLASS_HAS_CHILDREN = 2147749925, WBEM_E_CLASS_HAS_INSTANCES = 2147749926, WBEM_E_QUERY_NOT_IMPLEMENTED = 2147749927, WBEM_E_ILLEGAL_NULL = 2147749928, WBEM_E_INVALID_QUALIFIER_TYPE = 2147749929, WBEM_E_INVALID_PROPERTY_TYPE = 2147749930, WBEM_E_VALUE_OUT_OF_RANGE = 2147749931, WBEM_E_CANNOT_BE_SINGLETON = 2147749932, WBEM_E_INVALID_CIM_TYPE = 2147749933, WBEM_E_INVALID_METHOD = 2147749934, WBEM_E_INVALID_METHOD_PARAMETERS = 2147749935, WBEM_E_SYSTEM_PROPERTY = 2147749936, WBEM_E_INVALID_PROPERTY = 2147749937 }; +enum tag_WMI_OBJ_TEXT{ WMI_OBJ_TEXT_CIM_DTD_2_0 = 1, WMI_OBJ_TEXT_WMI_DTD_2_0 = 2, WMI_OBJ_TEXT_WMI_EXT1 = 3, WMI_OBJ_TEXT_WMI_EXT2 = 4, WMI_OBJ_TEXT_WMI_EXT3 = 5, WMI_OBJ_TEXT_WMI_EXT4 = 6, WMI_OBJ_TEXT_WMI_EXT5 = 7, WMI_OBJ_TEXT_WMI_EXT6 = 8, WMI_OBJ_TEXT_WMI_EXT7 = 9, WMI_OBJ_TEXT_WMI_EXT8 = 10, WMI_OBJ_TEXT_WMI_EXT9 = 11, WMI_OBJ_TEXT_WMI_EXT10 = 12, WMI_OBJ_TEXT_LAST = 13 }; +struct tag_CompileStatusInfo{ long lPhaseError; HRESULT hRes; long ObjectNum; long FirstLine; long LastLine; ULONG dwOutFlags; }; +enum tag_WBEM_COMPILER_OPTIONS{ WBEM_FLAG_CHECK_ONLY = 1, WBEM_FLAG_AUTORECOVER = 2, WBEM_FLAG_WMI_CHECK = 4, WBEM_FLAG_CONSOLE_PRINT = 8, WBEM_FLAG_DONT_ADD_TO_LIST = 16, WBEM_FLAG_SPLIT_FILES = 32, WBEM_FLAG_STORE_FILE = 256 }; +enum tag_WBEM_CONNECT_OPTIONS{ WBEM_FLAG_CONNECT_REPOSITORY_ONLY = 64, WBEM_FLAG_CONNECT_USE_MAX_WAIT = 128, WBEM_FLAG_CONNECT_PROVIDERS = 256 }; +enum tag_WBEM_UNSECAPP_FLAG_TYPE{ WBEM_FLAG_UNSECAPP_DEFAULT_CHECK_ACCESS = 0, WBEM_FLAG_UNSECAPP_CHECK_ACCESS = 1, WBEM_FLAG_UNSECAPP_DONT_CHECK_ACCESS = 2 }; +enum tag_WBEM_INFORMATION_FLAG_TYPE{ WBEM_FLAG_SHORT_NAME = 1, WBEM_FLAG_LONG_NAME = 2 }; +enum tag_WBEM_PROVIDER_REQUIREMENTS_TYPE{ WBEM_REQUIREMENTS_START_POSTFILTER = 0, WBEM_REQUIREMENTS_STOP_POSTFILTER = 1, WBEM_REQUIREMENTS_RECHECK_SUBSCRIPTIONS = 2 }; +enum tag_WBEM_EXTRA_RETURN_CODES{ WBEM_S_INITIALIZED = 0, WBEM_S_LIMITED_SERVICE = 274433, WBEM_S_INDIRECTLY_UPDATED = 274434, WBEM_S_SUBJECT_TO_SDS = 274435, WBEM_E_RETRY_LATER = 2147758081, WBEM_E_RESOURCE_CONTENTION = 2147758082 }; +enum tag_WBEM_PROVIDER_FLAGS{ WBEM_FLAG_OWNER_UPDATE = 65536 }; +enum tag_WBEM_BATCH_TYPE{ WBEM_FLAG_BATCH_IF_NEEDED = 0, WBEM_FLAG_MUST_BATCH = 1, WBEM_FLAG_MUST_NOT_BATCH = 2 }; +enum tag_WBEM_LOGIN_TYPE{ WBEM_FLAG_INPROC_LOGIN = 0, WBEM_FLAG_LOCAL_LOGIN = 1, WBEM_FLAG_REMOTE_LOGIN = 2, WBEM_AUTHENTICATION_METHOD_MASK = 15, WBEM_FLAG_USE_MULTIPLE_CHALLENGES = 16 }; +typedef tag_WBEM_PATH_STATUS_FLAG tag_WBEM_PATH_STATUS_FLAG; +typedef tag_WBEM_PATH_CREATE_FLAG tag_WBEM_PATH_CREATE_FLAG; +typedef tag_WBEM_GET_TEXT_FLAGS tag_WBEM_GET_TEXT_FLAGS; +typedef tag_WBEM_GET_KEY_FLAGS tag_WBEM_GET_KEY_FLAGS; +struct tag_SWbemQueryQualifiedName{ ULONG m_uVersion; ULONG m_uTokenType; ULONG m_uNameListSize; LPCWSTR* m_ppszNameList; BOOL m_bArraysUsed; BOOL* m_pbArrayElUsed; ULONG* m_puArrayIndex; }; +union tag_SWbemRpnConst{ LPCWSTR m_pszStrVal; BOOL m_bBoolVal; LONG m_lLongVal; ULONG m_uLongVal; double m_dblVal; long long m_lVal64; long long m_uVal64; }; +struct tag_SWbemRpnQueryToken{ ULONG m_uVersion; ULONG m_uTokenType; ULONG m_uSubexpressionShape; ULONG m_uOperator; SWbemQueryQualifiedName* m_pRightIdent; SWbemQueryQualifiedName* m_pLeftIdent; ULONG m_uConstApparentType; SWbemRpnConst m_Const; ULONG m_uConst2ApparentType; SWbemRpnConst m_Const2; LPCWSTR m_pszRightFunc; LPCWSTR m_pszLeftFunc; }; +struct tag_SWbemRpnTokenList{ ULONG m_uVersion; ULONG m_uTokenType; ULONG m_uNumTokens; }; +enum tag_WMIQ_LANGUAGE_FEATURES{ WMIQ_LF1_BASIC_SELECT = 1, WMIQ_LF2_CLASS_NAME_IN_QUERY = 2, WMIQ_LF3_STRING_CASE_FUNCTIONS = 3, WMIQ_LF4_PROP_TO_PROP_TESTS = 4, WMIQ_LF5_COUNT_STAR = 5, WMIQ_LF6_ORDER_BY = 6, WMIQ_LF7_DISTINCT = 7, WMIQ_LF8_ISA = 8, WMIQ_LF9_THIS = 9, WMIQ_LF10_COMPEX_SUBEXPRESSIONS = 10, WMIQ_LF11_ALIASING = 11, WMIQ_LF12_GROUP_BY_HAVING = 12, WMIQ_LF13_WMI_WITHIN = 13, WMIQ_LF14_SQL_WRITE_OPERATIONS = 14, WMIQ_LF15_GO = 15, WMIQ_LF16_SINGLE_LEVEL_TRANSACTIONS = 16, WMIQ_LF17_QUALIFIED_NAMES = 17, WMIQ_LF18_ASSOCIATONS = 18, WMIQ_LF19_SYSTEM_PROPERTIES = 19, WMIQ_LF20_EXTENDED_SYSTEM_PROPERTIES = 20, WMIQ_LF21_SQL89_JOINS = 21, WMIQ_LF22_SQL92_JOINS = 22, WMIQ_LF23_SUBSELECTS = 23, WMIQ_LF24_UMI_EXTENSIONS = 24, WMIQ_LF25_DATEPART = 25, WMIQ_LF26_LIKE = 26, WMIQ_LF27_CIM_TEMPORAL_CONSTRUCTS = 27, WMIQ_LF28_STANDARD_AGGREGATES = 28, WMIQ_LF29_MULTI_LEVEL_ORDER_BY = 29, WMIQ_LF30_WMI_PRAGMAS = 30, WMIQ_LF31_QUALIFIER_TESTS = 31, WMIQ_LF32_SP_EXECUTE = 32, WMIQ_LF33_ARRAY_ACCESS = 33, WMIQ_LF34_UNION = 34, WMIQ_LF35_COMPLEX_SELECT_TARGET = 35, WMIQ_LF36_REFERENCE_TESTS = 36, WMIQ_LF37_SELECT_INTO = 37, WMIQ_LF38_BASIC_DATETIME_TESTS = 38, WMIQ_LF39_COUNT_COLUMN = 39, WMIQ_LF40_BETWEEN = 40, WMIQ_LF_LAST = 40 }; +enum tag_WMIQ_RPNQ_FEATURE{ WMIQ_RPNF_WHERE_CLAUSE_PRESENT = 1, WMIQ_RPNF_QUERY_IS_CONJUNCTIVE = 2, WMIQ_RPNF_QUERY_IS_DISJUNCTIVE = 4, WMIQ_RPNF_PROJECTION = 8, WMIQ_RPNF_FEATURE_SELECT_STAR = 16, WMIQ_RPNF_EQUALITY_TESTS_ONLY = 32, WMIQ_RPNF_COUNT_STAR = 64, WMIQ_RPNF_QUALIFIED_NAMES_USED = 128, WMIQ_RPNF_SYSPROP_CLASS_USED = 256, WMIQ_RPNF_PROP_TO_PROP_TESTS = 512, WMIQ_RPNF_ORDER_BY = 1024, WMIQ_RPNF_ISA_USED = 2048, WMIQ_RPNF_GROUP_BY_HAVING = 4096, WMIQ_RPNF_ARRAY_ACCESS_USED = 8192 }; +struct tag_SWbemRpnEncodedQuery{ ULONG m_uVersion; ULONG m_uTokenType; unsigned long long m_uParsedFeatureMask; ULONG m_uDetectedArraySize; ULONG* m_puDetectedFeatures; ULONG m_uSelectListSize; SWbemQueryQualifiedName** m_ppSelectList; ULONG m_uFromTargetType; LPCWSTR m_pszOptionalFromPath; ULONG m_uFromListSize; LPCWSTR* m_ppszFromList; ULONG m_uWhereClauseSize; SWbemRpnQueryToken** m_ppRpnWhereClause; double m_dblWithinPolling; double m_dblWithinWindow; ULONG m_uOrderByListSize; LPCWSTR* m_ppszOrderByList; ULONG* m_uOrderDirectionEl; }; +struct tag_SWbemAnalysisMatrix{ ULONG m_uVersion; ULONG m_uMatrixType; LPCWSTR m_pszProperty; ULONG m_uPropertyType; ULONG m_uEntries; LPVOID* m_pValues; BOOL* m_pbTruthTable; }; +struct tag_SWbemAnalysisMatrixList{ ULONG m_uVersion; ULONG m_uMatrixType; ULONG m_uNumMatrices; SWbemAnalysisMatrix* m_pMatrices; }; +struct tag_SWbemAssocQueryInf{ ULONG m_uVersion; ULONG m_uAnalysisType; ULONG m_uFeatureMask; IWbemPath* m_pPath; LPWSTR m_pszPath; LPWSTR m_pszQueryText; LPWSTR m_pszResultClass; LPWSTR m_pszAssocClass; LPWSTR m_pszRole; LPWSTR m_pszResultRole; LPWSTR m_pszRequiredQualifier; LPWSTR m_pszRequiredAssocQualifier; }; +struct tag_GPOBROWSEINFO{ ULONG dwSize; ULONG dwFlags; HWND hwndOwner; LPOLESTR lpTitle; LPOLESTR lpInitialOU; LPOLESTR lpDSPath; ULONG dwDSPathSize; LPOLESTR lpName; ULONG dwNameSize; GROUP_POLICY_OBJECT_TYPE gpoType; GROUP_POLICY_HINT_TYPE gpoHint; }; +struct tagHLITEM{ ULONG uHLID; LPWSTR pwzFriendlyName; }; +struct _tagHLTBINFO{ ULONG uDockType; RECT rcTbPos; }; +struct _tagHLBWINFO{ ULONG cbSize; ULONG grfHLBWIF; RECT rcFramePos; RECT rcDocPos; HLTBINFO hltbinfo; }; +struct tagNavigateData{ ULONG ulTarget; ULONG ulURL; ULONG ulRefURL; ULONG ulPostData; ULONG dwFlags; }; +struct tagHHN_NOTIFY{ NMHDR hdr; PCSTR pszUrl; }; +struct tagHH_POPUP{ int cbStruct; HINSTANCE hinst; UINT idString; LPCTSTR pszText; POINT pt; COLORREF clrForeground; COLORREF clrBackground; RECT rcMargins; LPCTSTR pszFont; }; +struct tagHH_AKLINK{ int cbStruct; BOOL fReserved; LPCTSTR pszKeywords; LPCTSTR pszUrl; LPCTSTR pszMsgText; LPCTSTR pszMsgTitle; LPCTSTR pszWindow; BOOL fIndexOnFail; }; +struct tagHH_ENUM_IT{ int cbStruct; int iType; LPCSTR pszCatName; LPCSTR pszITName; LPCSTR pszITDescription; }; +struct tagHH_ENUM_CAT{ int cbStruct; LPCSTR pszCatName; LPCSTR pszCatDescription; }; +struct tagHH_SET_INFOTYPE{ int cbStruct; LPCSTR pszCatName; LPCSTR pszInfoTypeName; }; +struct tagHH_FTS_QUERY{ int cbStruct; BOOL fUniCodeStrings; LPCTSTR pszSearchQuery; LONG iProximity; BOOL fStemmedSearch; BOOL fTitleOnly; BOOL fExecute; LPCTSTR pszWindow; }; +struct tagHH_WINTYPE{ int cbStruct; BOOL fUniCodeStrings; LPCTSTR pszType; ULONG fsValidMembers; ULONG fsWinProperties; LPCTSTR pszCaption; ULONG dwStyles; ULONG dwExStyles; RECT rcWindowPos; int nShowState; HWND hwndHelp; HWND hwndCaller; HH_INFOTYPE* paInfoTypes; HWND hwndToolBar; HWND hwndNavigation; HWND hwndHTML; int iNavWidth; RECT rcHTML; LPCTSTR pszToc; LPCTSTR pszIndex; LPCTSTR pszFile; LPCTSTR pszHome; ULONG fsToolBarFlags; BOOL fNotExpanded; int curNavType; int tabpos; int idNotify; UCHAR tabOrder[20]; int cHistory; LPCTSTR pszJump1; LPCTSTR pszJump2; LPCTSTR pszUrlJump1; LPCTSTR pszUrlJump2; RECT rcMinSize; int cbInfoTypes; LPCTSTR pszCustomTabs; }; +struct tagHHNTRACK{ NMHDR hdr; PCSTR pszCurUrl; int idAction; HH_WINTYPE* phhWinType; }; +enum tagHH_GPROPID{ HH_GPROPID_SINGLETHREAD = 1, HH_GPROPID_TOOLBAR_MARGIN = 2, HH_GPROPID_UI_LANGUAGE = 3, HH_GPROPID_CURRENT_SUBSET = 4, HH_GPROPID_CONTENT_LANGUAGE = 5 }; +struct tagHH_GLOBAL_PROPERTY{ HH_GPROPID id; VARIANT var; }; +struct tagNAMED_PROFILE_INFO{ ULONG dwFlags; ULONG dwCount; ULONG dwCountDevCoordinates; COLOR_NAME szPrefix; COLOR_NAME szSuffix; }; +union tagCOLOR{ GRAYCOLOR gray; RGBCOLOR rgb; CMYKCOLOR cmyk; XYZCOLOR XYZ; YxyCOLOR Yxy; LabCOLOR Lab; GENERIC3CHANNEL gen3ch; NAMEDCOLOR named; HiFiCOLOR hifi; }; +struct tagPROFILEHEADER{ ULONG phSize; ULONG phCMMType; ULONG phVersion; ULONG phClass; ULONG phDataColorSpace; ULONG phConnectionSpace; ULONG phDateTime[3]; ULONG phSignature; ULONG phPlatform; ULONG phProfileFlags; ULONG phManufacturer; ULONG phModel; ULONG phAttributes[2]; ULONG phRenderingIntent; CIEXYZ phIlluminant; ULONG phCreator; UCHAR phReserved[44]; }; +struct tagPROFILE{ ULONG dwType; PVOID pProfileData; ULONG cbDataSize; }; +struct tagENUMTYPEA{ ULONG dwSize; ULONG dwVersion; ULONG dwFields; PCSTR pDeviceName; ULONG dwMediaType; ULONG dwDitheringMode; ULONG dwResolution[2]; ULONG dwCMMType; ULONG dwClass; ULONG dwDataColorSpace; ULONG dwConnectionSpace; ULONG dwSignature; ULONG dwPlatform; ULONG dwProfileFlags; ULONG dwManufacturer; ULONG dwModel; ULONG dwAttributes[2]; ULONG dwRenderingIntent; ULONG dwCreator; ULONG dwDeviceClass; }; +struct tagENUMTYPEW{ ULONG dwSize; ULONG dwVersion; ULONG dwFields; PCWSTR pDeviceName; ULONG dwMediaType; ULONG dwDitheringMode; ULONG dwResolution[2]; ULONG dwCMMType; ULONG dwClass; ULONG dwDataColorSpace; ULONG dwConnectionSpace; ULONG dwSignature; ULONG dwPlatform; ULONG dwProfileFlags; ULONG dwManufacturer; ULONG dwModel; ULONG dwAttributes[2]; ULONG dwRenderingIntent; ULONG dwCreator; ULONG dwDeviceClass; }; +struct _tagCOLORMATCHSETUPW{ ULONG dwSize; ULONG dwVersion; ULONG dwFlags; HWND hwndOwner; PCWSTR pSourceName; PCWSTR pDisplayName; PCWSTR pPrinterName; ULONG dwRenderIntent; ULONG dwProofingIntent; PWSTR pMonitorProfile; ULONG ccMonitorProfile; PWSTR pPrinterProfile; ULONG ccPrinterProfile; PWSTR pTargetProfile; ULONG ccTargetProfile; DLGPROC lpfnHook; LPARAM lParam; PCMSCALLBACKW lpfnApplyCallback; LPARAM lParamApplyCallback; }; +struct _tagCOLORMATCHSETUPA{ ULONG dwSize; ULONG dwVersion; ULONG dwFlags; HWND hwndOwner; PCSTR pSourceName; PCSTR pDisplayName; PCSTR pPrinterName; ULONG dwRenderIntent; ULONG dwProofingIntent; PSTR pMonitorProfile; ULONG ccMonitorProfile; PSTR pPrinterProfile; ULONG ccPrinterProfile; PSTR pTargetProfile; ULONG ccTargetProfile; DLGPROC lpfnHook; LPARAM lParam; PCMSCALLBACKA lpfnApplyCallback; LPARAM lParamApplyCallback; }; +int32_t uloc_addLikelySubtags( char* localeID, char* maximizedLocaleID, int32_t maximizedLocaleIDCapacity, UErrorCode* err ); +int32_t uloc_minimizeSubtags( char* localeID, char* minimizedLocaleID, int32_t minimizedLocaleIDCapacity, UErrorCode* err ); +enum tag_IdentityUpdateEvent{ IDENTITY_ASSOCIATED = 1, IDENTITY_DISASSOCIATED = 2, IDENTITY_CREATED = 4, IDENTITY_IMPORTED = 8, IDENTITY_DELETED = 16, IDENTITY_PROPCHANGED = 32, IDENTITY_CONNECTED = 64, IDENTITY_DISCONNECTED = 128 }; +enum tagSCROLLABLECONTEXTMENU_PLACEMENT{ SCMP_TOP = 0, SCMP_BOTTOM = 1, SCMP_LEFT = 2, SCMP_RIGHT = 3, SCMP_FULL = 4 }; +enum tagTI_FLAGS{ TI_BITMAP = 1, TI_JPEG = 2 }; +struct tagIMESTRUCT{ UINT fnc; WPARAM wParam; UINT wCount; UINT dchSource; UINT dchDest; LPARAM lParam1; LPARAM lParam2; LPARAM lParam3; }; +struct tagUNDETERMINESTRUCT{ ULONG dwSize; UINT uDefIMESize; UINT uDefIMEPos; UINT uUndetTextLen; UINT uUndetTextPos; UINT uUndetAttrPos; UINT uCursorPos; UINT uDeltaStart; UINT uDetermineTextLen; UINT uDetermineTextPos; UINT uDetermineDelimPos; UINT uYomiTextLen; UINT uYomiTextPos; UINT uYomiDelimPos; }; +struct tagSTRINGEXSTRUCT{ ULONG dwSize; UINT uDeterminePos; UINT uDetermineDelimPos; UINT uYomiPos; UINT uYomiDelimPos; }; +struct tagAPPLETIDLIST{ INT count; IID* pIIDList; }; +struct tagIMESTRINGCANDIDATE{ UINT uCount; LPWSTR lpwstr[1]; }; +struct tagIMEITEM{ INT cbSize; INT iType; LPVOID lpItemData; }; +struct tagIMEITEMCANDIDATE{ UINT uCount; IMEITEM imeItem[1]; }; +struct tagIMESTRINGCANDIDATEINFO{ ULONG dwFarEastId; LPIMEFAREASTINFO lpFarEastInfo; ULONG fInfoMask; INT iSelIndex; UINT uCount; LPWSTR lpwstr[1]; }; +struct tagIMECOMPOSITIONSTRINGINFO{ INT iCompStrLen; INT iCaretPos; INT iEditStart; INT iEditLen; INT iTargetStart; INT iTargetLen; }; +struct tagIMECHARINFO{ WCHAR wch; ULONG dwCharInfo; }; +struct tagAPPLETCFG{ ULONG dwConfig; WCHAR wchTitle[64]; WCHAR wchTitleFontFace[32]; ULONG dwCharSet; INT iCategory; HICON hIcon; LANGID langID; WORD dummy; LPARAM lReserved1; }; +struct tagIMEAPPLETUI{ HWND hwnd; ULONG dwStyle; INT width; INT height; INT minWidth; INT minHeight; INT maxWidth; INT maxHeight; LPARAM lReserved1; LPARAM lReserved2; }; +struct tagAPPLYCANDEXPARAM{ ULONG dwSize; LPWSTR lpwstrDisplay; LPWSTR lpwstrReading; ULONG dwReserved; }; +struct tagCOMPOSITIONSTRING{ ULONG dwSize; ULONG dwCompReadAttrLen; ULONG dwCompReadAttrOffset; ULONG dwCompReadClauseLen; ULONG dwCompReadClauseOffset; ULONG dwCompReadStrLen; ULONG dwCompReadStrOffset; ULONG dwCompAttrLen; ULONG dwCompAttrOffset; ULONG dwCompClauseLen; ULONG dwCompClauseOffset; ULONG dwCompStrLen; ULONG dwCompStrOffset; ULONG dwCursorPos; ULONG dwDeltaStart; ULONG dwResultReadClauseLen; ULONG dwResultReadClauseOffset; ULONG dwResultReadStrLen; ULONG dwResultReadStrOffset; ULONG dwResultClauseLen; ULONG dwResultClauseOffset; ULONG dwResultStrLen; ULONG dwResultStrOffset; ULONG dwPrivateSize; ULONG dwPrivateOffset; }; +struct tagGUIDELINE{ ULONG dwSize; ULONG dwLevel; ULONG dwIndex; ULONG dwStrLen; ULONG dwStrOffset; ULONG dwPrivateSize; ULONG dwPrivateOffset; }; +struct tagTRANSMSG{ UINT message; WPARAM wParam; LPARAM lParam; }; +struct tagTRANSMSGLIST{ UINT uMsgCount; TRANSMSG TransMsg[1]; }; +struct tagCANDIDATEINFO{ ULONG dwSize; ULONG dwCount; ULONG dwOffset[32]; ULONG dwPrivateSize; ULONG dwPrivateOffset; }; +struct tagINPUTCONTEXT{ HWND hWnd; BOOL fOpen; POINT ptStatusWndPos; POINT ptSoftKbdPos; ULONG fdwConversion; ULONG fdwSentence; 4E50796C6B6852365938424245376441756A527974305A376B6D4D3D lfFont; COMPOSITIONFORM cfCompForm; CANDIDATEFORM cfCandForm[4]; HIMCC hCompStr; HIMCC hCandInfo; HIMCC hGuideLine; HIMCC hPrivate; ULONG dwNumMsgBuf; HIMCC hMsgBuf; ULONG fdwInit; ULONG dwReserve[3]; }; +struct tagIMEINFO{ ULONG dwPrivateDataSize; ULONG fdwProperty; ULONG fdwConversionCaps; ULONG fdwSentenceCaps; ULONG fdwUICaps; ULONG fdwSCSCaps; ULONG fdwSelectCaps; }; +struct tagSOFTKBDDATA{ UINT uCount; WORD wCode[1]; }; +enum tagWORDREP_BREAK_TYPE{ WORDREP_BREAK_EOW = 0, WORDREP_BREAK_EOS = 1, WORDREP_BREAK_EOP = 2, WORDREP_BREAK_EOC = 3 }; +struct tagTEXT_SOURCE{ PFNFILLTEXTBUFFER pfnFillTextBuffer; WCHAR* awcBuffer; ULONG iEnd; ULONG iCur; }; +struct tagROWSTATUS{ LONG lRowFirst; LONG cRows; LONG cProperties; LONG cRowsTotal; }; +struct tagCOLUMNSTATUS{ LONG cPropCount; LONG cPropsLoaded; }; +struct tagSYSTEM_EVENT_DATA{ UCHAR bModifier; WCHAR wKey; LONG xPos; LONG yPos; UCHAR bCursorMode; ULONG dwButtonState; }; +struct tagSTROKE_RANGE{ ULONG iStrokeBegin; ULONG iStrokeEnd; }; +struct tagINKMETRIC{ INT iHeight; INT iFontAscent; INT iFontDescent; ULONG dwFlags; COLORREF color; }; +struct tag_VerError{ unsigned long flags; unsigned long opcode; unsigned long uOffset; unsigned long Token; unsigned long item1_flags; int* item1_data; unsigned long item2_flags; int* item2_data; }; +struct tagJsDebugPropertyInfo{ BSTR name; BSTR type; BSTR value; BSTR fullName; JS_PROPERTY_ATTRIBUTES attr; }; +struct tagKbdLayer{ PMODIFIERS pCharModifiers; PVK_TO_WCHAR_TABLE pVkToWcharTable; PDEADKEY pDeadKey; PVSC_LPWSTR pKeyNames; PVSC_LPWSTR pKeyNamesExt; WCHAR** pKeyNamesDead; USHORT* pusVSCtoVK; UCHAR bMaxVSCtoVK; PVSC_VK pVSCtoVK_E0; PVSC_VK pVSCtoVK_E1; ULONG fLocaleFlags; UCHAR nLgMax; UCHAR cbLgEntry; PLIGATURE1 pLigature; ULONG dwType; ULONG dwSubType; }; +struct tagKbdNlsLayer{ USHORT OEMIdentifier; USHORT LayoutInformation; UINT NumOfVkToF; PVK_F pVkToF; INT NumOfMouseVKey; USHORT* pusMouseVKey; }; +struct tagKBDTABLE_DESC{ WCHAR wszDllName[32]; ULONG dwType; ULONG dwSubType; }; +struct tagKBDTABLE_MULTI{ UINT nTables; KBDTABLE_DESC aKbdTables[8]; }; +struct tagKBD_TYPE_INFO{ ULONG dwVersion; ULONG dwType; ULONG dwSubType; }; +struct tagMAGTRANSFORM{ float v[3]; }; +struct tagMAGIMAGEHEADER{ UINT width; UINT height; WICPixelFormatGUID format; UINT stride; UINT offset; SIZE_T cbSize; }; +struct tagMAGCOLOREFFECT{ float transform[5]; }; +struct tagIMMPID_MP_STRUCT{ }; +enum tagIMMPID_MP_ENUM{ IMMPID_MP_BEFORE__ = 4095, IMMPID_MP_RECIPIENT_LIST = 4096, IMMPID_MP_CONTENT_FILE_NAME = 4097, IMMPID_MP_SENDER_ADDRESS_SMTP = 4098, IMMPID_MP_SENDER_ADDRESS_X500 = 4099, IMMPID_MP_SENDER_ADDRESS_X400 = 4100, IMMPID_MP_SENDER_ADDRESS_LEGACY_EX_DN = 4101, IMMPID_MP_DOMAIN_LIST = 4102, IMMPID_MP_PICKUP_FILE_NAME = 4103, IMMPID_MP_AUTHENTICATED_USER_NAME = 4104, IMMPID_MP_CONNECTION_IP_ADDRESS = 4105, IMMPID_MP_HELO_DOMAIN = 4106, IMMPID_MP_EIGHTBIT_MIME_OPTION = 4107, IMMPID_MP_CHUNKING_OPTION = 4108, IMMPID_MP_BINARYMIME_OPTION = 4109, IMMPID_MP_REMOTE_AUTHENTICATION_TYPE = 4110, IMMPID_MP_ERROR_CODE = 4111, IMMPID_MP_DSN_ENVID_VALUE = 4112, IMMPID_MP_DSN_RET_VALUE = 4113, IMMPID_MP_REMOTE_SERVER_DSN_CAPABLE = 4114, IMMPID_MP_ARRIVAL_TIME = 4115, IMMPID_MP_MESSAGE_STATUS = 4116, IMMPID_MP_EXPIRE_DELAY = 4117, IMMPID_MP_EXPIRE_NDR = 4118, IMMPID_MP_LOCAL_EXPIRE_DELAY = 4119, IMMPID_MP_LOCAL_EXPIRE_NDR = 4120, IMMPID_MP_ARRIVAL_FILETIME = 4121, IMMPID_MP_HR_CAT_STATUS = 4122, IMMPID_MP_MSG_GUID = 4123, IMMPID_MP_SUPERSEDES_MSG_GUID = 4124, IMMPID_MP_SCANNED_FOR_CRLF_DOT_CRLF = 4125, IMMPID_MP_FOUND_EMBEDDED_CRLF_DOT_CRLF = 4126, IMMPID_MP_MSG_SIZE_HINT = 4127, IMMPID_MP_RFC822_MSG_ID = 4128, IMMPID_MP_RFC822_MSG_SUBJECT = 4129, IMMPID_MP_RFC822_FROM_ADDRESS = 4130, IMMPID_MP_RFC822_TO_ADDRESS = 4131, IMMPID_MP_RFC822_CC_ADDRESS = 4132, IMMPID_MP_RFC822_BCC_ADDRESS = 4133, IMMPID_MP_CONNECTION_SERVER_IP_ADDRESS = 4134, IMMPID_MP_SERVER_NAME = 4135, IMMPID_MP_SERVER_VERSION = 4136, IMMPID_MP_NUM_RECIPIENTS = 4137, IMMPID_MP_X_PRIORITY = 4138, IMMPID_MP_FROM_ADDRESS = 4139, IMMPID_MP_SENDER_ADDRESS = 4140, IMMPID_MP_DEFERRED_DELIVERY_FILETIME = 4141, IMMPID_MP_SENDER_ADDRESS_OTHER = 4142, IMMPID_MP_ORIGINAL_ARRIVAL_TIME = 4143, IMMPID_MP_MSGCLASS = 4144, IMMPID_MP_CONTENT_TYPE = 4145, IMMPID_MP_ENCRYPTION_TYPE = 4146, IMMPID_MP_CONNECTION_SERVER_PORT = 4147, IMMPID_MP_CLIENT_AUTH_USER = 4148, IMMPID_MP_CLIENT_AUTH_TYPE = 4149, IMMPID_MP_CRC_GLOBAL = 4150, IMMPID_MP_CRC_RECIPS = 4151, IMMPID_MP_INBOUND_MAIL_FROM_AUTH = 4152, IMMPID_MP_AFTER__ = 4153 }; +struct tagIMMPID_RP_STRUCT{ }; +enum tagIMMPID_RP_ENUM{ IMMPID_RP_BEFORE__ = 8191, IMMPID_RP_DSN_NOTIFY_SUCCESS = 8192, IMMPID_RP_DSN_NOTIFY_INVALID = 8193, IMMPID_RP_ADDRESS_TYPE = 8194, IMMPID_RP_ADDRESS = 8195, IMMPID_RP_ADDRESS_TYPE_SMTP = 8196, IMMPID_RP_ERROR_CODE = 8197, IMMPID_RP_ERROR_STRING = 8198, IMMPID_RP_DSN_NOTIFY_VALUE = 8199, IMMPID_RP_DSN_ORCPT_VALUE = 8200, IMMPID_RP_ADDRESS_SMTP = 8201, IMMPID_RP_ADDRESS_X400 = 8202, IMMPID_RP_ADDRESS_X500 = 8203, IMMPID_RP_LEGACY_EX_DN = 8204, IMMPID_RP_RECIPIENT_FLAGS = 8205, IMMPID_RP_SMTP_STATUS_STRING = 8206, IMMPID_RP_DSN_PRE_CAT_ADDRESS = 8207, IMMPID_RP_MDB_GUID = 8208, IMMPID_RP_USER_GUID = 8209, IMMPID_RP_DOMAIN = 8210, IMMPID_RP_ADDRESS_OTHER = 8211, IMMPID_RP_DISPLAY_NAME = 8212, IMMPID_RP_AFTER__ = 8213 }; +struct tagIMMPID_MPV_STRUCT{ }; +enum tagIMMPID_MPV_ENUM{ IMMPID_MPV_BEFORE__ = 12287, IMMPID_MPV_STORE_DRIVER_HANDLE = 12288, IMMPID_MPV_MESSAGE_CREATION_FLAGS = 12289, IMMPID_MPV_MESSAGE_OPEN_HANDLES = 12290, IMMPID_MPV_TOTAL_OPEN_HANDLES = 12291, IMMPID_MPV_TOTAL_OPEN_PROPERTY_STREAM_HANDLES = 12292, IMMPID_MPV_TOTAL_OPEN_CONTENT_HANDLES = 12293, IMMPID_MPV_AFTER__ = 12294 }; +struct tagIMMP_MPV_STORE_DRIVER_HANDLE{ GUID guidSignature; }; +struct tagIMMPID_RPV_STRUCT{ }; +enum tagIMMPID_RPV_ENUM{ IMMPID_RPV_BEFORE__ = 16383, IMMPID_RPV_DONT_DELIVER = 16384, IMMPID_RPV_NO_NAME_COLLISIONS = 16385, IMMPID_RPV_AFTER__ = 16386 }; +struct tagIMMPID_NMP_STRUCT{ }; +enum tagIMMPID_NMP_ENUM{ IMMPID_NMP_BEFORE__ = 24575, IMMPID_NMP_SECONDARY_GROUPS = 24576, IMMPID_NMP_SECONDARY_ARTNUM = 24577, IMMPID_NMP_PRIMARY_GROUP = 24578, IMMPID_NMP_PRIMARY_ARTID = 24579, IMMPID_NMP_POST_TOKEN = 24580, IMMPID_NMP_NEWSGROUP_LIST = 24581, IMMPID_NMP_HEADERS = 24582, IMMPID_NMP_NNTP_PROCESSING = 24583, IMMPID_NMP_NNTP_APPROVED_HEADER = 24584, IMMPID_NMP_AFTER__ = 24585 }; +struct tagIMMPID_CPV_STRUCT{ }; +enum tagIMMPID_CPV_ENUM{ IMMPID_CPV_BEFORE__ = 32767, IMMPID_CP_START = 32768, IMMPID_CPV_AFTER__ = 32769 }; +struct tagIMMPID_GUIDLIST_ITEM{ GUID* pguid; ULONG dwStart; ULONG dwLast; }; +struct tagDRVENABLEDATA{ ULONG iDriverVersion; ULONG c; DRVFN* pdrvfn; }; +struct tagDEVINFO{ FLONG flGraphicsCaps; LOGFONTW lfDefaultFont; LOGFONTW lfAnsiVarFont; LOGFONTW lfAnsiFixFont; ULONG cFonts; ULONG iDitherFormat; USHORT cxDither; USHORT cyDither; HPALETTE hpalDefault; FLONG flGraphicsCaps2; }; +struct tagCDDDXGK_REDIRBITMAPPRESENTINFO{ UINT NumDirtyRects; RECT* DirtyRect; UINT NumContexts; HANDLE hContext[65]; BOOLEAN bDoNotSynchronizeWithDxContent; }; +struct tagFLOATOBJ_XFORM{ FLOATOBJ eM11; FLOATOBJ eM12; FLOATOBJ eM21; FLOATOBJ eM22; FLOATOBJ eDx; FLOATOBJ eDy; }; +enum tagMIMECONTF{ MIMECONTF_MAILNEWS = 1, MIMECONTF_BROWSER = 2, MIMECONTF_MINIMAL = 4, MIMECONTF_IMPORT = 8, MIMECONTF_SAVABLE_MAILNEWS = 256, MIMECONTF_SAVABLE_BROWSER = 512, MIMECONTF_EXPORT = 1024, MIMECONTF_PRIVCONVERTER = 65536, MIMECONTF_VALID = 131072, MIMECONTF_VALID_NLS = 262144, MIMECONTF_MIME_IE4 = 268435456, MIMECONTF_MIME_LATEST = 536870912, MIMECONTF_MIME_REGISTRY = 1073741824 }; +struct tagMIMECPINFO{ ULONG dwFlags; UINT uiCodePage; UINT uiFamilyCodePage; WCHAR wszDescription[64]; WCHAR wszWebCharset[50]; WCHAR wszHeaderCharset[50]; WCHAR wszBodyCharset[50]; WCHAR wszFixedWidthFont[32]; WCHAR wszProportionalFont[32]; UCHAR bGDICharset; }; +struct tagMIMECSETINFO{ UINT uiCodePage; UINT uiInternetEncoding; WCHAR wszCharset[50]; }; +struct tagRFC1766INFO{ LCID lcid; WCHAR wszRfc1766[6]; WCHAR wszLocaleName[32]; }; +enum tagSCRIPTCONTF{ sidDefault = 0, sidMerge = 1, sidAsciiSym = 2, sidAsciiLatin = 3, sidLatin = 4, sidGreek = 5, sidCyrillic = 6, sidArmenian = 7, sidHebrew = 8, sidArabic = 9, sidDevanagari = 10, sidBengali = 11, sidGurmukhi = 12, sidGujarati = 13, sidOriya = 14, sidTamil = 15, sidTelugu = 16, sidKannada = 17, sidMalayalam = 18, sidThai = 19, sidLao = 20, sidTibetan = 21, sidGeorgian = 22, sidHangul = 23, sidKana = 24, sidBopomofo = 25, sidHan = 26, sidEthiopic = 27, sidCanSyllabic = 28, sidCherokee = 29, sidYi = 30, sidBraille = 31, sidRunic = 32, sidOgham = 33, sidSinhala = 34, sidSyriac = 35, sidBurmese = 36, sidKhmer = 37, sidThaana = 38, sidMongolian = 39, sidUserDefined = 40, sidLim = 41, sidFEFirst = 23, sidFELast = 26 }; +struct tagSCRIPTINFO{ SCRIPT_ID ScriptId; UINT uiCodePage; WCHAR wszDescription[48]; WCHAR wszFixedWidthFont[32]; WCHAR wszProportionalFont[32]; }; +enum tagMLCONVCHARF{ MLCONVCHARF_AUTODETECT = 1, MLCONVCHARF_ENTITIZE = 2, MLCONVCHARF_NCR_ENTITIZE = 2, MLCONVCHARF_NAME_ENTITIZE = 4, MLCONVCHARF_USEDEFCHAR = 8, MLCONVCHARF_NOBESTFITCHARS = 16, MLCONVCHARF_DETECTJPN = 32 }; +enum tagMLCPF{ MLDETECTF_MAILNEWS = 1, MLDETECTF_BROWSER = 2, MLDETECTF_VALID = 4, MLDETECTF_VALID_NLS = 8, MLDETECTF_PRESERVE_ORDER = 16, MLDETECTF_PREFERRED_ONLY = 32, MLDETECTF_FILTER_SPECIALCHAR = 64, MLDETECTF_EURO_UTF8 = 128 }; +enum tagMLDETECTCP{ MLDETECTCP_NONE = 0, MLDETECTCP_7BIT = 1, MLDETECTCP_8BIT = 2, MLDETECTCP_DBCS = 4, MLDETECTCP_HTML = 8, MLDETECTCP_NUMBER = 16 }; +struct tagDetectEncodingInfo{ UINT nLangID; UINT nCodePage; INT nDocPercent; INT nConfidence; }; +enum tagSCRIPTFONTCONTF{ SCRIPTCONTF_FIXED_FONT = 1, SCRIPTCONTF_PROPORTIONAL_FONT = 2, SCRIPTCONTF_SCRIPT_USER = 65536, SCRIPTCONTF_SCRIPT_HIDE = 131072, SCRIPTCONTF_SCRIPT_SYSTEM = 262144 }; +struct tagSCRIPFONTINFO{ SCRIPT_IDS scripts; WCHAR wszFont[32]; }; +struct tagUNICODERANGE{ WCHAR wcFrom; WCHAR wcTo; }; +enum tagMLSTR_FLAGS{ MLSTR_READ = 1, MLSTR_WRITE = 2 }; +enum tagIconIdentifier{ Icon_None = 0, Icon_Error = 32513, Icon_Question = 32514, Icon_Warning = 32515, Icon_Information = 32516, Icon_First = 32513, Icon_Last = 32516 }; +struct waveopendesc_tag{ HWAVE hWave; LPWAVEFORMAT lpFormat; DWORD_PTR dwCallback; DWORD_PTR dwInstance; UINT uMappedDeviceID; DWORD_PTR dnDevNode; }; +struct midiopenstrmid_tag{ ULONG dwStreamID; UINT uDeviceID; }; +struct midiopendesc_tag{ HMIDI hMidi; DWORD_PTR dwCallback; DWORD_PTR dwInstance; DWORD_PTR dnDevNode; ULONG cIds; MIDIOPENSTRMID rgIds[1]; }; +struct timerevent_tag{ WORD wDelay; WORD wResolution; LPTIMECALLBACK lpFunction; ULONG dwUser; WORD wFlags; WORD wReserved1; }; +enum _tagSYNCMGRSTATUS{ SYNCMGRSTATUS_STOPPED = 0, SYNCMGRSTATUS_SKIPPED = 1, SYNCMGRSTATUS_PENDING = 2, SYNCMGRSTATUS_UPDATING = 3, SYNCMGRSTATUS_SUCCEEDED = 4, SYNCMGRSTATUS_FAILED = 5, SYNCMGRSTATUS_PAUSED = 6, SYNCMGRSTATUS_RESUMING = 7, SYNCMGRSTATUS_UPDATING_INDETERMINATE = 8, SYNCMGRSTATUS_DELETED = 256 }; +struct _tagSYNCMGRPROGRESSITEM{ ULONG cbSize; UINT mask; LPCWSTR lpcStatusText; ULONG dwStatusType; int iProgValue; int iMaxValue; }; +enum _tagSYNCMGRLOGLEVEL{ SYNCMGRLOGLEVEL_INFORMATION = 1, SYNCMGRLOGLEVEL_WARNING = 2, SYNCMGRLOGLEVEL_ERROR = 3, SYNCMGRLOGLEVEL_LOGLEVELMAX = 3 }; +enum _tagSYNCMGRERRORFLAGS{ SYNCMGRERRORFLAG_ENABLEJUMPTEXT = 1 }; +struct _tagSYNCMGRLOGERRORINFO{ ULONG cbSize; ULONG mask; ULONG dwSyncMgrErrorFlags; GUID ErrorID; GUID ItemID; }; +enum _tagSYNCMGRITEMFLAGS{ SYNCMGRITEM_HASPROPERTIES = 1, SYNCMGRITEM_TEMPORARY = 2, SYNCMGRITEM_ROAMINGUSER = 4, SYNCMGRITEM_LASTUPDATETIME = 8, SYNCMGRITEM_MAYDELETEITEM = 16, SYNCMGRITEM_HIDDEN = 32 }; +struct _tagSYNCMGRITEM{ ULONG cbSize; ULONG dwFlags; GUID ItemID; ULONG dwItemState; HICON hIcon; WCHAR wszItemName[128]; FILETIME ftLastUpdate; }; +enum _tagSYNCMGRFLAG{ SYNCMGRFLAG_CONNECT = 1, SYNCMGRFLAG_PENDINGDISCONNECT = 2, SYNCMGRFLAG_MANUAL = 3, SYNCMGRFLAG_IDLE = 4, SYNCMGRFLAG_INVOKE = 5, SYNCMGRFLAG_SCHEDULED = 6, SYNCMGRFLAG_EVENTMASK = 255, SYNCMGRFLAG_SETTINGS = 256, SYNCMGRFLAG_MAYBOTHERUSER = 512 }; +enum _tagSYNCMGRHANDLERFLAGS{ SYNCMGRHANDLER_HASPROPERTIES = 1, SYNCMGRHANDLER_MAYESTABLISHCONNECTION = 2, SYNCMGRHANDLER_ALWAYSLISTHANDLER = 4, SYNCMGRHANDLER_HIDDEN = 8 }; +struct _tagSYNCMGRHANDLERINFO{ ULONG cbSize; HICON hIcon; ULONG SyncMgrHandlerFlags; WCHAR wszHandlerName[32]; }; +enum _tagSYNCMGRITEMSTATE{ SYNCMGRITEMSTATE_UNCHECKED = 0, SYNCMGRITEMSTATE_CHECKED = 1 }; +enum _tagSYNCMGRINVOKEFLAGS{ SYNCMGRINVOKE_STARTSYNC = 2, SYNCMGRINVOKE_MINIMIZED = 4 }; +enum _tagSYNCMGRREGISTERFLAGS{ SYNCMGRREGISTERFLAG_CONNECT = 1, SYNCMGRREGISTERFLAG_PENDINGDISCONNECT = 2, SYNCMGRREGISTERFLAG_IDLE = 4 }; +struct tagAM_MPEGSTREAMTYPE{ ULONG dwStreamId; ULONG dwReserved; AM_MEDIA_TYPE mt; UCHAR bFormat[1]; }; +struct tagAM_MPEGSYSTEMTYPE{ ULONG dwBitRate; ULONG cStreams; AM_MPEGSTREAMTYPE Streams[1]; }; +struct tagRASTUNNELENDPOINT{ ULONG dwType; }; +struct tagRASCONNW{ ULONG dwSize; HRASCONN hrasconn; WCHAR szEntryName[257]; WCHAR szDeviceType[17]; WCHAR szDeviceName[129]; WCHAR szPhonebook[260]; ULONG dwSubEntry; GUID guidEntry; ULONG dwFlags; LUID luid; GUID guidCorrelationId; }; +struct tagRASCONNA{ ULONG dwSize; HRASCONN hrasconn; CHAR szEntryName[257]; CHAR szDeviceType[17]; CHAR szDeviceName[129]; CHAR szPhonebook[260]; ULONG dwSubEntry; GUID guidEntry; ULONG dwFlags; LUID luid; GUID guidCorrelationId; }; +enum tagRASCONNSTATE{ RASCS_OpenPort = 0, RASCS_PortOpened = 1, RASCS_ConnectDevice = 2, RASCS_DeviceConnected = 3, RASCS_AllDevicesConnected = 4, RASCS_Authenticate = 5, RASCS_AuthNotify = 6, RASCS_AuthRetry = 7, RASCS_AuthCallback = 8, RASCS_AuthChangePassword = 9, RASCS_AuthProject = 10, RASCS_AuthLinkSpeed = 11, RASCS_AuthAck = 12, RASCS_ReAuthenticate = 13, RASCS_Authenticated = 14, RASCS_PrepareForCallback = 15, RASCS_WaitForModemReset = 16, RASCS_WaitForCallback = 17, RASCS_Projected = 18, RASCS_StartAuthentication = 19, RASCS_CallbackComplete = 20, RASCS_LogonNetwork = 21, RASCS_SubEntryConnected = 22, RASCS_SubEntryDisconnected = 23, RASCS_ApplySettings = 24, RASCS_Interactive = 4096, RASCS_RetryAuthentication = 4097, RASCS_CallbackSetByCaller = 4098, RASCS_PasswordExpired = 4099, RASCS_InvokeEapUI = 4100, RASCS_Connected = 8192, RASCS_Disconnected = 8193 }; +enum tagRASCONNSUBSTATE{ RASCSS_None = 0, RASCSS_Dormant = 1, RASCSS_Reconnecting = 2, RASCSS_Reconnected = 8192 }; +struct tagRASCONNSTATUSW{ ULONG dwSize; tagRASCONNSTATE rasconnstate; ULONG dwError; WCHAR szDeviceType[17]; WCHAR szDeviceName[129]; WCHAR szPhoneNumber[129]; tagRASTUNNELENDPOINT localEndPoint; tagRASTUNNELENDPOINT remoteEndPoint; tagRASCONNSUBSTATE rasconnsubstate; }; +struct tagRASCONNSTATUSA{ ULONG dwSize; tagRASCONNSTATE rasconnstate; ULONG dwError; CHAR szDeviceType[17]; CHAR szDeviceName[129]; CHAR szPhoneNumber[129]; tagRASTUNNELENDPOINT localEndPoint; tagRASTUNNELENDPOINT remoteEndPoint; tagRASCONNSUBSTATE rasconnsubstate; }; +struct tagRASDIALPARAMSW{ ULONG dwSize; WCHAR szEntryName[257]; WCHAR szPhoneNumber[129]; WCHAR szCallbackNumber[129]; WCHAR szUserName[257]; WCHAR szPassword[257]; WCHAR szDomain[16]; ULONG dwSubEntry; ULONG_PTR dwCallbackId; ULONG dwIfIndex; LPWSTR szEncPassword; }; +struct tagRASDIALPARAMSA{ ULONG dwSize; CHAR szEntryName[257]; CHAR szPhoneNumber[129]; CHAR szCallbackNumber[129]; CHAR szUserName[257]; CHAR szPassword[257]; CHAR szDomain[16]; ULONG dwSubEntry; ULONG_PTR dwCallbackId; ULONG dwIfIndex; LPSTR szEncPassword; }; +struct tagRASEAPINFO{ ULONG dwSizeofEapInfo; UCHAR* pbEapInfo; }; +struct tagRASDEVSPECIFICINFO{ ULONG dwSize; UCHAR* pbDevSpecificInfo; }; +struct tagRASDIALEXTENSIONS{ ULONG dwSize; ULONG dwfOptions; HWND hwndParent; ULONG_PTR reserved; ULONG_PTR reserved1; tagRASEAPINFO RasEapInfo; BOOL fSkipPppAuth; RASDEVSPECIFICINFO RasDevSpecificInfo; }; +struct tagRASENTRYNAMEW{ ULONG dwSize; WCHAR szEntryName[257]; ULONG dwFlags; WCHAR szPhonebookPath[261]; }; +struct tagRASENTRYNAMEA{ ULONG dwSize; CHAR szEntryName[257]; ULONG dwFlags; CHAR szPhonebookPath[261]; }; +enum tagRASPROJECTION{ RASP_Amb = 65536, RASP_PppNbf = 32831, RASP_PppIpx = 32811, RASP_PppIp = 32801, RASP_PppCcp = 33021, RASP_PppLcp = 49185, RASP_PppIpv6 = 32855 }; +struct tagRASAMBW{ ULONG dwSize; ULONG dwError; WCHAR szNetBiosError[17]; UCHAR bLana; }; +struct tagRASAMBA{ ULONG dwSize; ULONG dwError; CHAR szNetBiosError[17]; UCHAR bLana; }; +struct tagRASPPPNBFW{ ULONG dwSize; ULONG dwError; ULONG dwNetBiosError; WCHAR szNetBiosError[17]; WCHAR szWorkstationName[17]; UCHAR bLana; }; +struct tagRASPPPNBFA{ ULONG dwSize; ULONG dwError; ULONG dwNetBiosError; CHAR szNetBiosError[17]; CHAR szWorkstationName[17]; UCHAR bLana; }; +struct tagRASIPXW{ ULONG dwSize; ULONG dwError; WCHAR szIpxAddress[22]; }; +struct tagRASPPPIPXA{ ULONG dwSize; ULONG dwError; CHAR szIpxAddress[22]; }; +struct tagRASPPPIPW{ ULONG dwSize; ULONG dwError; WCHAR szIpAddress[16]; WCHAR szServerIpAddress[16]; ULONG dwOptions; ULONG dwServerOptions; }; +struct tagRASPPPIPA{ ULONG dwSize; ULONG dwError; CHAR szIpAddress[16]; CHAR szServerIpAddress[16]; ULONG dwOptions; ULONG dwServerOptions; }; +struct tagRASPPPIPV6{ ULONG dwSize; ULONG dwError; UCHAR bLocalInterfaceIdentifier[8]; UCHAR bPeerInterfaceIdentifier[8]; UCHAR bLocalCompressionProtocol[2]; UCHAR bPeerCompressionProtocol[2]; }; +struct tagRASPPPLCPW{ ULONG dwSize; BOOL fBundled; ULONG dwError; ULONG dwAuthenticationProtocol; ULONG dwAuthenticationData; ULONG dwEapTypeId; ULONG dwServerAuthenticationProtocol; ULONG dwServerAuthenticationData; ULONG dwServerEapTypeId; BOOL fMultilink; ULONG dwTerminateReason; ULONG dwServerTerminateReason; WCHAR szReplyMessage[1024]; ULONG dwOptions; ULONG dwServerOptions; }; +struct tagRASPPPLCPA{ ULONG dwSize; BOOL fBundled; ULONG dwError; ULONG dwAuthenticationProtocol; ULONG dwAuthenticationData; ULONG dwEapTypeId; ULONG dwServerAuthenticationProtocol; ULONG dwServerAuthenticationData; ULONG dwServerEapTypeId; BOOL fMultilink; ULONG dwTerminateReason; ULONG dwServerTerminateReason; CHAR szReplyMessage[1024]; ULONG dwOptions; ULONG dwServerOptions; }; +struct tagRASPPPCCP{ ULONG dwSize; ULONG dwError; ULONG dwCompressionAlgorithm; ULONG dwOptions; ULONG dwServerCompressionAlgorithm; ULONG dwServerOptions; }; +struct tagRASDEVINFOW{ ULONG dwSize; WCHAR szDeviceType[17]; WCHAR szDeviceName[129]; }; +struct tagRASDEVINFOA{ ULONG dwSize; CHAR szDeviceType[17]; CHAR szDeviceName[129]; }; +struct tagRASENTRYA{ ULONG dwSize; ULONG dwfOptions; ULONG dwCountryID; ULONG dwCountryCode; CHAR szAreaCode[11]; CHAR szLocalPhoneNumber[129]; ULONG dwAlternateOffset; RASIPADDR ipaddr; RASIPADDR ipaddrDns; RASIPADDR ipaddrDnsAlt; RASIPADDR ipaddrWins; RASIPADDR ipaddrWinsAlt; ULONG dwFrameSize; ULONG dwfNetProtocols; ULONG dwFramingProtocol; CHAR szScript[260]; CHAR szAutodialDll[260]; CHAR szAutodialFunc[260]; CHAR szDeviceType[17]; CHAR szDeviceName[129]; CHAR szX25PadType[33]; CHAR szX25Address[201]; CHAR szX25Facilities[201]; CHAR szX25UserData[201]; ULONG dwChannels; ULONG dwReserved1; ULONG dwReserved2; ULONG dwSubEntries; ULONG dwDialMode; ULONG dwDialExtraPercent; ULONG dwDialExtraSampleSeconds; ULONG dwHangUpExtraPercent; ULONG dwHangUpExtraSampleSeconds; ULONG dwIdleDisconnectSeconds; ULONG dwType; ULONG dwEncryptionType; ULONG dwCustomAuthKey; GUID guidId; CHAR szCustomDialDll[260]; ULONG dwVpnStrategy; ULONG dwfOptions2; ULONG dwfOptions3; CHAR szDnsSuffix[256]; ULONG dwTcpWindowSize; CHAR szPrerequisitePbk[260]; CHAR szPrerequisiteEntry[257]; ULONG dwRedialCount; ULONG dwRedialPause; RASIPV6ADDR ipv6addrDns; RASIPV6ADDR ipv6addrDnsAlt; ULONG dwIPv4InterfaceMetric; ULONG dwIPv6InterfaceMetric; RASIPV6ADDR ipv6addr; ULONG dwIPv6PrefixLength; ULONG dwNetworkOutageTime; CHAR szIDi[257]; CHAR szIDr[257]; BOOL fIsImsConfig; IKEV2_ID_PAYLOAD_TYPE IdiType; IKEV2_ID_PAYLOAD_TYPE IdrType; BOOL fDisableIKEv2Fragmentation; }; +struct tagRASENTRYW{ ULONG dwSize; ULONG dwfOptions; ULONG dwCountryID; ULONG dwCountryCode; WCHAR szAreaCode[11]; WCHAR szLocalPhoneNumber[129]; ULONG dwAlternateOffset; RASIPADDR ipaddr; RASIPADDR ipaddrDns; RASIPADDR ipaddrDnsAlt; RASIPADDR ipaddrWins; RASIPADDR ipaddrWinsAlt; ULONG dwFrameSize; ULONG dwfNetProtocols; ULONG dwFramingProtocol; WCHAR szScript[260]; WCHAR szAutodialDll[260]; WCHAR szAutodialFunc[260]; WCHAR szDeviceType[17]; WCHAR szDeviceName[129]; WCHAR szX25PadType[33]; WCHAR szX25Address[201]; WCHAR szX25Facilities[201]; WCHAR szX25UserData[201]; ULONG dwChannels; ULONG dwReserved1; ULONG dwReserved2; ULONG dwSubEntries; ULONG dwDialMode; ULONG dwDialExtraPercent; ULONG dwDialExtraSampleSeconds; ULONG dwHangUpExtraPercent; ULONG dwHangUpExtraSampleSeconds; ULONG dwIdleDisconnectSeconds; ULONG dwType; ULONG dwEncryptionType; ULONG dwCustomAuthKey; GUID guidId; WCHAR szCustomDialDll[260]; ULONG dwVpnStrategy; ULONG dwfOptions2; ULONG dwfOptions3; WCHAR szDnsSuffix[256]; ULONG dwTcpWindowSize; WCHAR szPrerequisitePbk[260]; WCHAR szPrerequisiteEntry[257]; ULONG dwRedialCount; ULONG dwRedialPause; RASIPV6ADDR ipv6addrDns; RASIPV6ADDR ipv6addrDnsAlt; ULONG dwIPv4InterfaceMetric; ULONG dwIPv6InterfaceMetric; RASIPV6ADDR ipv6addr; ULONG dwIPv6PrefixLength; ULONG dwNetworkOutageTime; WCHAR szIDi[257]; WCHAR szIDr[257]; BOOL fIsImsConfig; IKEV2_ID_PAYLOAD_TYPE IdiType; IKEV2_ID_PAYLOAD_TYPE IdrType; BOOL fDisableIKEv2Fragmentation; }; +struct tagRASADPARAMS{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; }; +struct tagRASSUBENTRYA{ ULONG dwSize; ULONG dwfFlags; CHAR szDeviceType[17]; CHAR szDeviceName[129]; CHAR szLocalPhoneNumber[129]; ULONG dwAlternateOffset; }; +struct tagRASSUBENTRYW{ ULONG dwSize; ULONG dwfFlags; WCHAR szDeviceType[17]; WCHAR szDeviceName[129]; WCHAR szLocalPhoneNumber[129]; ULONG dwAlternateOffset; }; +struct tagRASCREDENTIALSA{ ULONG dwSize; ULONG dwMask; CHAR szUserName[257]; CHAR szPassword[257]; CHAR szDomain[16]; }; +struct tagRASCREDENTIALSW{ ULONG dwSize; ULONG dwMask; WCHAR szUserName[257]; WCHAR szPassword[257]; WCHAR szDomain[16]; }; +struct tagRASAUTODIALENTRYA{ ULONG dwSize; ULONG dwFlags; ULONG dwDialingLocation; CHAR szEntry[257]; }; +struct tagRASAUTODIALENTRYW{ ULONG dwSize; ULONG dwFlags; ULONG dwDialingLocation; WCHAR szEntry[257]; }; +struct tagRASEAPUSERIDENTITYA{ CHAR szUserName[257]; ULONG dwSizeofEapInfo; UCHAR pbEapInfo[1]; }; +struct tagRASEAPUSERIDENTITYW{ WCHAR szUserName[257]; ULONG dwSizeofEapInfo; UCHAR pbEapInfo[1]; }; +struct tagRASCOMMSETTINGS{ ULONG dwSize; UCHAR bParity; UCHAR bStop; UCHAR bByteSize; UCHAR bAlign; }; +struct tagRASCUSTOMSCRIPTEXTENSIONS{ ULONG dwSize; PFNRASSETCOMMSETTINGS pfnRasSetCommSettings; }; +struct tagRASUPDATECONN{ RASAPIVERSION version; ULONG dwSize; ULONG dwFlags; ULONG dwIfIndex; tagRASTUNNELENDPOINT localEndPoint; tagRASTUNNELENDPOINT remoteEndPoint; }; +typedef tagMQPROPVARIANT tagPROPVARIANT; +struct tagMQPROPERTYRESTRICTION{ ULONG rel; PROPID prop; MQPROPVARIANT prval; }; +struct tagMQRESTRICTION{ ULONG cRes; MQPROPERTYRESTRICTION* paPropRes; }; +struct tagMQCOLUMNSET{ ULONG cCol; PROPID* aCol; }; +struct tagMQSORTKEY{ PROPID propColumn; ULONG dwOrder; }; +struct tagMQSORTSET{ ULONG cCol; MQSORTKEY* aCol; }; +struct tagMQMSGPROPS{ ULONG cProp; MSGPROPID* aPropID; MQPROPVARIANT* aPropVar; HRESULT* aStatus; }; +struct tagMQQUEUEPROPS{ ULONG cProp; QUEUEPROPID* aPropID; MQPROPVARIANT* aPropVar; HRESULT* aStatus; }; +struct tagMQQMPROPS{ ULONG cProp; QMPROPID* aPropID; MQPROPVARIANT* aPropVar; HRESULT* aStatus; }; +struct tagMQPRIVATEPROPS{ ULONG cProp; QMPROPID* aPropID; MQPROPVARIANT* aPropVar; HRESULT* aStatus; }; +struct tagMQMGMTPROPS{ ULONG cProp; MGMTPROPID* aPropID; MQPROPVARIANT* aPropVar; HRESULT* aStatus; }; +struct tagSEQUENCE_INFO{ LONGLONG SeqID; ULONG SeqNo; ULONG PrevNo; }; +enum tagMQConnectionState{ MQCONN_NOFAILURE = 0, MQCONN_ESTABLISH_PACKET_RECEIVED = 1, MQCONN_READY = 2, MQCONN_UNKNOWN_FAILURE = 2147483648, MQCONN_PING_FAILURE = 2147483649, MQCONN_CREATE_SOCKET_FAILURE = 2147483650, MQCONN_BIND_SOCKET_FAILURE = 2147483651, MQCONN_CONNECT_SOCKET_FAILURE = 2147483652, MQCONN_TCP_NOT_ENABLED = 2147483653, MQCONN_SEND_FAILURE = 2147483654, MQCONN_NOT_READY = 2147483655, MQCONN_NAME_RESOLUTION_FAILURE = 2147483656, MQCONN_INVALID_SERVER_CERT = 2147483657, MQCONN_LIMIT_REACHED = 2147483658, MQCONN_REFUSED_BY_OTHER_SIDE = 2147483659, MQCONN_ROUTING_FAILURE = 2147483660, MQCONN_OUT_OF_MEMORY = 2147483661 }; +struct tagDCINFO{ DCINFOTYPE eInfoType; VARIANT vData; }; +enum tagEBindInfoOptions{ BIO_BINDER = 1 }; +enum tagDBPROMPTOPTIONSENUM{ DBPROMPTOPTIONS_NONE = 0, DBPROMPTOPTIONS_WIZARDSHEET = 1, DBPROMPTOPTIONS_PROPERTYSHEET = 2, DBPROMPTOPTIONS_BROWSEONLY = 8, DBPROMPTOPTIONS_DISABLE_PROVIDER_SELECTION = 16, DBPROMPTOPTIONS_DISABLESAVEPASSWORD = 32 }; +struct tagKAGREQDIAG{ ULONG ulDiagFlags; VARTYPE vt; SHORT sDiagField; }; +struct tagKAGGETDIAG{ ULONG ulSize; VARIANTARG vDiagInfo; SHORT sDiagField; }; +enum tagDOCHOSTUITYPE{ DOCHOSTUITYPE_BROWSE = 0, DOCHOSTUITYPE_AUTHOR = 1 }; +enum tagDOCHOSTUIDBLCLK{ DOCHOSTUIDBLCLK_DEFAULT = 0, DOCHOSTUIDBLCLK_SHOWPROPERTIES = 1, DOCHOSTUIDBLCLK_SHOWCODE = 2 }; +enum tagDOCHOSTUIFLAG{ DOCHOSTUIFLAG_DIALOG = 1, DOCHOSTUIFLAG_DISABLE_HELP_MENU = 2, DOCHOSTUIFLAG_NO3DBORDER = 4, DOCHOSTUIFLAG_SCROLL_NO = 8, DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE = 16, DOCHOSTUIFLAG_OPENNEWWIN = 32, DOCHOSTUIFLAG_DISABLE_OFFSCREEN = 64, DOCHOSTUIFLAG_FLAT_SCROLLBAR = 128, DOCHOSTUIFLAG_DIV_BLOCKDEFAULT = 256, DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY = 512, DOCHOSTUIFLAG_OVERRIDEBEHAVIORFACTORY = 1024, DOCHOSTUIFLAG_CODEPAGELINKEDFONTS = 2048, DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8 = 4096, DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 = 8192, DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE = 16384, DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION = 65536, DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION = 131072, DOCHOSTUIFLAG_THEME = 262144, DOCHOSTUIFLAG_NOTHEME = 524288, DOCHOSTUIFLAG_NOPICS = 1048576, DOCHOSTUIFLAG_NO3DOUTERBORDER = 2097152, DOCHOSTUIFLAG_DISABLE_EDIT_NS_FIXUP = 4194304, DOCHOSTUIFLAG_LOCAL_MACHINE_ACCESS_CHECK = 8388608, DOCHOSTUIFLAG_DISABLE_UNTRUSTEDPROTOCOL = 16777216, DOCHOSTUIFLAG_HOST_NAVIGATES = 33554432, DOCHOSTUIFLAG_ENABLE_REDIRECT_NOTIFICATION = 67108864, DOCHOSTUIFLAG_USE_WINDOWLESS_SELECTCONTROL = 134217728, DOCHOSTUIFLAG_USE_WINDOWED_SELECTCONTROL = 268435456, DOCHOSTUIFLAG_ENABLE_ACTIVEX_INACTIVATE_MODE = 536870912, DOCHOSTUIFLAG_DPI_AWARE = 1073741824 }; +enum tagINSTALLMESSAGE{ INSTALLMESSAGE_FATALEXIT = 0, INSTALLMESSAGE_ERROR = 16777216, INSTALLMESSAGE_WARNING = 33554432, INSTALLMESSAGE_USER = 50331648, INSTALLMESSAGE_INFO = 67108864, INSTALLMESSAGE_FILESINUSE = 83886080, INSTALLMESSAGE_RESOLVESOURCE = 100663296, INSTALLMESSAGE_OUTOFDISKSPACE = 117440512, INSTALLMESSAGE_ACTIONSTART = 134217728, INSTALLMESSAGE_ACTIONDATA = 150994944, INSTALLMESSAGE_PROGRESS = 167772160, INSTALLMESSAGE_COMMONDATA = 184549376, INSTALLMESSAGE_INITIALIZE = 201326592, INSTALLMESSAGE_TERMINATE = 218103808, INSTALLMESSAGE_SHOWDIALOG = 234881024, INSTALLMESSAGE_PERFORMANCE = 251658240, INSTALLMESSAGE_RMFILESINUSE = 419430400, INSTALLMESSAGE_INSTALLSTART = 436207616, INSTALLMESSAGE_INSTALLEND = 452984832 }; +enum tagINSTALLUILEVEL{ INSTALLUILEVEL_NOCHANGE = 0, INSTALLUILEVEL_DEFAULT = 1, INSTALLUILEVEL_NONE = 2, INSTALLUILEVEL_BASIC = 3, INSTALLUILEVEL_REDUCED = 4, INSTALLUILEVEL_FULL = 5, INSTALLUILEVEL_ENDDIALOG = 128, INSTALLUILEVEL_PROGRESSONLY = 64, INSTALLUILEVEL_HIDECANCEL = 32, INSTALLUILEVEL_SOURCERESONLY = 256, INSTALLUILEVEL_UACONLY = 512 }; +enum tagINSTALLSTATE{ INSTALLSTATE_NOTUSED = 4294967289, INSTALLSTATE_BADCONFIG = 4294967290, INSTALLSTATE_INCOMPLETE = 4294967291, INSTALLSTATE_SOURCEABSENT = 4294967292, INSTALLSTATE_MOREDATA = 4294967293, INSTALLSTATE_INVALIDARG = 4294967294, INSTALLSTATE_UNKNOWN = 4294967295, INSTALLSTATE_BROKEN = 0, INSTALLSTATE_ADVERTISED = 1, INSTALLSTATE_REMOVED = 1, INSTALLSTATE_ABSENT = 2, INSTALLSTATE_LOCAL = 3, INSTALLSTATE_SOURCE = 4, INSTALLSTATE_DEFAULT = 5 }; +enum tagUSERINFOSTATE{ USERINFOSTATE_MOREDATA = 4294967293, USERINFOSTATE_INVALIDARG = 4294967294, USERINFOSTATE_UNKNOWN = 4294967295, USERINFOSTATE_ABSENT = 0, USERINFOSTATE_PRESENT = 1 }; +enum tagINSTALLLEVEL{ INSTALLLEVEL_DEFAULT = 0, INSTALLLEVEL_MINIMUM = 1, INSTALLLEVEL_MAXIMUM = 65535 }; +enum tagREINSTALLMODE{ REINSTALLMODE_REPAIR = 1, REINSTALLMODE_FILEMISSING = 2, REINSTALLMODE_FILEOLDERVERSION = 4, REINSTALLMODE_FILEEQUALVERSION = 8, REINSTALLMODE_FILEEXACT = 16, REINSTALLMODE_FILEVERIFY = 32, REINSTALLMODE_FILEREPLACE = 64, REINSTALLMODE_MACHINEDATA = 128, REINSTALLMODE_USERDATA = 256, REINSTALLMODE_SHORTCUT = 512, REINSTALLMODE_PACKAGE = 1024 }; +enum tagINSTALLOGMODE{ INSTALLLOGMODE_FATALEXIT = 1, INSTALLLOGMODE_ERROR = 2, INSTALLLOGMODE_WARNING = 4, INSTALLLOGMODE_USER = 8, INSTALLLOGMODE_INFO = 16, INSTALLLOGMODE_RESOLVESOURCE = 64, INSTALLLOGMODE_OUTOFDISKSPACE = 128, INSTALLLOGMODE_ACTIONSTART = 256, INSTALLLOGMODE_ACTIONDATA = 512, INSTALLLOGMODE_COMMONDATA = 2048, INSTALLLOGMODE_PROPERTYDUMP = 1024, INSTALLLOGMODE_VERBOSE = 4096, INSTALLLOGMODE_EXTRADEBUG = 8192, INSTALLLOGMODE_LOGONLYONERROR = 16384, INSTALLLOGMODE_LOGPERFORMANCE = 32768, INSTALLLOGMODE_PROGRESS = 1024, INSTALLLOGMODE_INITIALIZE = 4096, INSTALLLOGMODE_TERMINATE = 8192, INSTALLLOGMODE_SHOWDIALOG = 16384, INSTALLLOGMODE_FILESINUSE = 32, INSTALLLOGMODE_RMFILESINUSE = 33554432, INSTALLLOGMODE_INSTALLSTART = 67108864, INSTALLLOGMODE_INSTALLEND = 134217728 }; +enum tagINSTALLLOGATTRIBUTES{ INSTALLLOGATTRIBUTES_APPEND = 1, INSTALLLOGATTRIBUTES_FLUSHEACHLINE = 2 }; +enum tagINSTALLFEATUREATTRIBUTE{ INSTALLFEATUREATTRIBUTE_FAVORLOCAL = 1, INSTALLFEATUREATTRIBUTE_FAVORSOURCE = 2, INSTALLFEATUREATTRIBUTE_FOLLOWPARENT = 4, INSTALLFEATUREATTRIBUTE_FAVORADVERTISE = 8, INSTALLFEATUREATTRIBUTE_DISALLOWADVERTISE = 16, INSTALLFEATUREATTRIBUTE_NOUNSUPPORTEDADVERTISE = 32 }; +enum tagINSTALLMODE{ INSTALLMODE_NODETECTION_ANY = 4294967292, INSTALLMODE_NOSOURCERESOLUTION = 4294967293, INSTALLMODE_NODETECTION = 4294967294, INSTALLMODE_EXISTING = 4294967295, INSTALLMODE_DEFAULT = 0 }; +enum tagMSIPATCHSTATE{ MSIPATCHSTATE_INVALID = 0, MSIPATCHSTATE_APPLIED = 1, MSIPATCHSTATE_SUPERSEDED = 2, MSIPATCHSTATE_OBSOLETED = 4, MSIPATCHSTATE_REGISTERED = 8, MSIPATCHSTATE_ALL = 15 }; +enum tagMSIINSTALLCONTEXT{ MSIINSTALLCONTEXT_FIRSTVISIBLE = 0, MSIINSTALLCONTEXT_NONE = 0, MSIINSTALLCONTEXT_USERMANAGED = 1, MSIINSTALLCONTEXT_USERUNMANAGED = 2, MSIINSTALLCONTEXT_MACHINE = 4, MSIINSTALLCONTEXT_ALL = 7, MSIINSTALLCONTEXT_ALLUSERMANAGED = 8 }; +enum tagMSIPATCHDATATYPE{ MSIPATCH_DATATYPE_PATCHFILE = 0, MSIPATCH_DATATYPE_XMLPATH = 1, MSIPATCH_DATATYPE_XMLBLOB = 2 }; +struct tagMSIPATCHSEQUENCEINFOA{ LPCSTR szPatchData; MSIPATCHDATATYPE ePatchDataType; ULONG dwOrder; UINT uStatus; }; +struct tagMSIPATCHSEQUENCEINFOW{ LPCWSTR szPatchData; MSIPATCHDATATYPE ePatchDataType; ULONG dwOrder; UINT uStatus; }; +enum tagSCRIPTFLAGS{ SCRIPTFLAGS_CACHEINFO = 1, SCRIPTFLAGS_SHORTCUTS = 4, SCRIPTFLAGS_MACHINEASSIGN = 8, SCRIPTFLAGS_REGDATA_CNFGINFO = 32, SCRIPTFLAGS_VALIDATE_TRANSFORMS_LIST = 64, SCRIPTFLAGS_REGDATA_CLASSINFO = 128, SCRIPTFLAGS_REGDATA_EXTENSIONINFO = 256, SCRIPTFLAGS_REGDATA_APPINFO = 384, SCRIPTFLAGS_REGDATA = 416 }; +enum tagADVERTISEFLAGS{ ADVERTISEFLAGS_MACHINEASSIGN = 0, ADVERTISEFLAGS_USERASSIGN = 1 }; +enum tagINSTALLTYPE{ INSTALLTYPE_DEFAULT = 0, INSTALLTYPE_NETWORK_IMAGE = 1, INSTALLTYPE_SINGLE_INSTANCE = 2 }; +enum tagMSIARCHITECTUREFLAGS{ MSIARCHITECTUREFLAGS_X86 = 1, MSIARCHITECTUREFLAGS_IA64 = 2, MSIARCHITECTUREFLAGS_AMD64 = 4, MSIARCHITECTUREFLAGS_ARM = 8 }; +enum tagMSIOPENPACKAGEFLAGS{ MSIOPENPACKAGEFLAGS_IGNOREMACHINESTATE = 1 }; +enum tagMSIADVERTISEOPTIONFLAGS{ MSIADVERTISEOPTIONFLAGS_INSTANCE = 1 }; +enum tagMSISOURCETYPE{ MSISOURCETYPE_UNKNOWN = 0, MSISOURCETYPE_NETWORK = 1, MSISOURCETYPE_URL = 2, MSISOURCETYPE_MEDIA = 4 }; +enum tagMSICODE{ MSICODE_PRODUCT = 0, MSICODE_PATCH = 1073741824 }; +enum tagMSITRANSACTION{ MSITRANSACTION_CHAIN_EMBEDDEDUI = 1, MSITRANSACTION_JOIN_EXISTING_EMBEDDEDUI = 2 }; +enum tagMSITRANSACTIONSTATE{ MSITRANSACTIONSTATE_ROLLBACK = 0, MSITRANSACTIONSTATE_COMMIT = 1 }; +struct tagWDD{ WORD wDispPos; WORD cchDisp; ULONG WDD_nReserve1; WORD nPos; WORD fPhrase : 1; WORD fAutoCorrect : 1; WORD fNumericPrefix : 1; WORD fUserRegistered : 1; WORD fUnknown : 1; WORD fRecentUsed : 1; void* pReserved; }; +struct tagMORRSLT{ ULONG dwSize; WCHAR* pwchOutput; WORD cchOutput; WORD* pchInputPos; WORD* pchOutputIdxWDD; WORD* paMonoRubyPos; WDD* pWDD; INT cWDD; void* pPrivate; WCHAR BLKBuff; }; +struct tagIMEKMSINIT{ INT cbSize; HWND hWnd; }; +struct tagIMEKMSKEY{ ULONG dwStatus; ULONG dwCompStatus; ULONG dwVKEY; }; +struct tagIMEKMS{ INT cbSize; HIMC hIMC; ULONG cKeyList; IMEKMSKEY* pKeyList; }; +struct tagIMEKMSNTFY{ INT cbSize; HIMC hIMC; BOOL fSelect; }; +struct tagIMEKMSKMP{ INT cbSize; HIMC hIMC; LANGID idLang; WORD wVKStart; WORD wVKEnd; INT cKeyList; IMEKMSKEY* pKeyList; }; +struct tagIMEKMSINVK{ INT cbSize; HIMC hIMC; ULONG dwControl; }; +struct tagIMEKMSFUNCDESC{ INT cbSize; LANGID idLang; ULONG dwControl; WCHAR pwszDescription[128]; }; +enum tagMSIDBSTATE{ MSIDBSTATE_ERROR = 4294967295, MSIDBSTATE_READ = 0, MSIDBSTATE_WRITE = 1 }; +enum tagMSIMODIFY{ MSIMODIFY_SEEK = 4294967295, MSIMODIFY_REFRESH = 0, MSIMODIFY_INSERT = 1, MSIMODIFY_UPDATE = 2, MSIMODIFY_ASSIGN = 3, MSIMODIFY_REPLACE = 4, MSIMODIFY_MERGE = 5, MSIMODIFY_DELETE = 6, MSIMODIFY_INSERT_TEMPORARY = 7, MSIMODIFY_VALIDATE = 8, MSIMODIFY_VALIDATE_NEW = 9, MSIMODIFY_VALIDATE_FIELD = 10, MSIMODIFY_VALIDATE_DELETE = 11 }; +enum tagMSICOLINFO{ MSICOLINFO_NAMES = 0, MSICOLINFO_TYPES = 1 }; +enum tagMSICONDITION{ MSICONDITION_FALSE = 0, MSICONDITION_TRUE = 1, MSICONDITION_NONE = 2, MSICONDITION_ERROR = 3 }; +enum tagMSICOSTTREE{ MSICOSTTREE_SELFONLY = 0, MSICOSTTREE_CHILDREN = 1, MSICOSTTREE_PARENTS = 2, MSICOSTTREE_RESERVED = 3 }; +enum tagMSIDBERROR{ MSIDBERROR_INVALIDARG = 4294967293, MSIDBERROR_MOREDATA = 4294967294, MSIDBERROR_FUNCTIONERROR = 4294967295, MSIDBERROR_NOERROR = 0, MSIDBERROR_DUPLICATEKEY = 1, MSIDBERROR_REQUIRED = 2, MSIDBERROR_BADLINK = 3, MSIDBERROR_OVERFLOW = 4, MSIDBERROR_UNDERFLOW = 5, MSIDBERROR_NOTINSET = 6, MSIDBERROR_BADVERSION = 7, MSIDBERROR_BADCASE = 8, MSIDBERROR_BADGUID = 9, MSIDBERROR_BADWILDCARD = 10, MSIDBERROR_BADIDENTIFIER = 11, MSIDBERROR_BADLANGUAGE = 12, MSIDBERROR_BADFILENAME = 13, MSIDBERROR_BADPATH = 14, MSIDBERROR_BADCONDITION = 15, MSIDBERROR_BADFORMATTED = 16, MSIDBERROR_BADTEMPLATE = 17, MSIDBERROR_BADDEFAULTDIR = 18, MSIDBERROR_BADREGPATH = 19, MSIDBERROR_BADCUSTOMSOURCE = 20, MSIDBERROR_BADPROPERTY = 21, MSIDBERROR_MISSINGDATA = 22, MSIDBERROR_BADCATEGORY = 23, MSIDBERROR_BADKEYTABLE = 24, MSIDBERROR_BADMAXMINVALUES = 25, MSIDBERROR_BADCABINET = 26, MSIDBERROR_BADSHORTCUT = 27, MSIDBERROR_STRINGOVERFLOW = 28, MSIDBERROR_BADLOCALIZEATTRIB = 29 }; +enum tagMSIRUNMODE{ MSIRUNMODE_ADMIN = 0, MSIRUNMODE_ADVERTISE = 1, MSIRUNMODE_MAINTENANCE = 2, MSIRUNMODE_ROLLBACKENABLED = 3, MSIRUNMODE_LOGENABLED = 4, MSIRUNMODE_OPERATIONS = 5, MSIRUNMODE_REBOOTATEND = 6, MSIRUNMODE_REBOOTNOW = 7, MSIRUNMODE_CABINET = 8, MSIRUNMODE_SOURCESHORTNAMES = 9, MSIRUNMODE_TARGETSHORTNAMES = 10, MSIRUNMODE_RESERVED11 = 11, MSIRUNMODE_WINDOWS9X = 12, MSIRUNMODE_ZAWENABLED = 13, MSIRUNMODE_RESERVED14 = 14, MSIRUNMODE_RESERVED15 = 15, MSIRUNMODE_SCHEDULED = 16, MSIRUNMODE_ROLLBACK = 17, MSIRUNMODE_COMMIT = 18 }; +enum tagMSITRANSFORM_ERROR{ MSITRANSFORM_ERROR_ADDEXISTINGROW = 1, MSITRANSFORM_ERROR_DELMISSINGROW = 2, MSITRANSFORM_ERROR_ADDEXISTINGTABLE = 4, MSITRANSFORM_ERROR_DELMISSINGTABLE = 8, MSITRANSFORM_ERROR_UPDATEMISSINGROW = 16, MSITRANSFORM_ERROR_CHANGECODEPAGE = 32, MSITRANSFORM_ERROR_VIEWTRANSFORM = 256 }; +enum tagMSITRANSFORM_VALIDATE{ MSITRANSFORM_VALIDATE_LANGUAGE = 1, MSITRANSFORM_VALIDATE_PRODUCT = 2, MSITRANSFORM_VALIDATE_PLATFORM = 4, MSITRANSFORM_VALIDATE_MAJORVERSION = 8, MSITRANSFORM_VALIDATE_MINORVERSION = 16, MSITRANSFORM_VALIDATE_UPDATEVERSION = 32, MSITRANSFORM_VALIDATE_NEWLESSBASEVERSION = 64, MSITRANSFORM_VALIDATE_NEWLESSEQUALBASEVERSION = 128, MSITRANSFORM_VALIDATE_NEWEQUALBASEVERSION = 256, MSITRANSFORM_VALIDATE_NEWGREATEREQUALBASEVERSION = 512, MSITRANSFORM_VALIDATE_NEWGREATERBASEVERSION = 1024, MSITRANSFORM_VALIDATE_UPGRADECODE = 2048 }; +enum tagWMDM_TAG_DATATYPE{ WMDM_TYPE_DWORD = 0, WMDM_TYPE_STRING = 1, WMDM_TYPE_BINARY = 2, WMDM_TYPE_BOOL = 3, WMDM_TYPE_QWORD = 4, WMDM_TYPE_WORD = 5, WMDM_TYPE_GUID = 6, WMDM_TYPE_DATE = 7 }; +enum tagWMDM_SESSION_TYPE{ WMDM_SESSION_NONE = 0, WMDM_SESSION_TRANSFER_TO_DEVICE = 1, WMDM_SESSION_TRANSFER_FROM_DEVICE = 16, WMDM_SESSION_DELETE = 256, WMDM_SESSION_CUSTOM = 4096 }; +struct _tagBITMAPINFOHEADER{ ULONG biSize; LONG biWidth; LONG biHeight; WORD biPlanes; WORD biBitCount; ULONG biCompression; ULONG biSizeImage; LONG biXPelsPerMeter; LONG biYPelsPerMeter; ULONG biClrUsed; ULONG biClrImportant; }; +struct _tagVIDEOINFOHEADER{ RECT rcSource; RECT rcTarget; ULONG dwBitRate; ULONG dwBitErrorRate; LONGLONG AvgTimePerFrame; _BITMAPINFOHEADER bmiHeader; }; +struct _tagWMFILECAPABILITIES{ LPWSTR pwszMimeType; ULONG dwReserved; }; +enum tagWMDM_STORAGE_ENUM_MODE{ ENUM_MODE_RAW = 0, ENUM_MODE_USE_DEVICE_PREF = 1, ENUM_MODE_METADATA_VIEWS = 2 }; +enum tagWMDM_FORMATCODE{ WMDM_FORMATCODE_NOTUSED = 0, WMDM_FORMATCODE_ALLIMAGES = 4294967295, WMDM_FORMATCODE_UNDEFINED = 12288, WMDM_FORMATCODE_ASSOCIATION = 12289, WMDM_FORMATCODE_SCRIPT = 12290, WMDM_FORMATCODE_EXECUTABLE = 12291, WMDM_FORMATCODE_TEXT = 12292, WMDM_FORMATCODE_HTML = 12293, WMDM_FORMATCODE_DPOF = 12294, WMDM_FORMATCODE_AIFF = 12295, WMDM_FORMATCODE_WAVE = 12296, WMDM_FORMATCODE_MP3 = 12297, WMDM_FORMATCODE_AVI = 12298, WMDM_FORMATCODE_MPEG = 12299, WMDM_FORMATCODE_ASF = 12300, WMDM_FORMATCODE_RESERVED_FIRST = 12301, WMDM_FORMATCODE_RESERVED_LAST = 14335, WMDM_FORMATCODE_IMAGE_UNDEFINED = 14336, WMDM_FORMATCODE_IMAGE_EXIF = 14337, WMDM_FORMATCODE_IMAGE_TIFFEP = 14338, WMDM_FORMATCODE_IMAGE_FLASHPIX = 14339, WMDM_FORMATCODE_IMAGE_BMP = 14340, WMDM_FORMATCODE_IMAGE_CIFF = 14341, WMDM_FORMATCODE_IMAGE_GIF = 14343, WMDM_FORMATCODE_IMAGE_JFIF = 14344, WMDM_FORMATCODE_IMAGE_PCD = 14345, WMDM_FORMATCODE_IMAGE_PICT = 14346, WMDM_FORMATCODE_IMAGE_PNG = 14347, WMDM_FORMATCODE_IMAGE_TIFF = 14349, WMDM_FORMATCODE_IMAGE_TIFFIT = 14350, WMDM_FORMATCODE_IMAGE_JP2 = 14351, WMDM_FORMATCODE_IMAGE_JPX = 14352, WMDM_FORMATCODE_IMAGE_RESERVED_FIRST = 14353, WMDM_FORMATCODE_IMAGE_RESERVED_LAST = 16383, WMDM_FORMATCODE_UNDEFINEDFIRMWARE = 47106, WMDM_FORMATCODE_WBMP = 47107, WMDM_FORMATCODE_JPEGXR = 47108, WMDM_FORMATCODE_WINDOWSIMAGEFORMAT = 47233, WMDM_FORMATCODE_UNDEFINEDAUDIO = 47360, WMDM_FORMATCODE_WMA = 47361, WMDM_FORMATCODE_OGG = 47362, WMDM_FORMATCODE_AAC = 47363, WMDM_FORMATCODE_AUDIBLE = 47364, WMDM_FORMATCODE_FLAC = 47366, WMDM_FORMATCODE_QCELP = 47367, WMDM_FORMATCODE_AMR = 47368, WMDM_FORMATCODE_UNDEFINEDVIDEO = 47488, WMDM_FORMATCODE_WMV = 47489, WMDM_FORMATCODE_MP4 = 47490, WMDM_FORMATCODE_MP2 = 47491, WMDM_FORMATCODE_3GP = 47492, WMDM_FORMATCODE_3G2 = 47493, WMDM_FORMATCODE_AVCHD = 47494, WMDM_FORMATCODE_ATSCTS = 47495, WMDM_FORMATCODE_DVBTS = 47496, WMDM_FORMATCODE_MKV = 47497, WMDM_FORMATCODE_MKA = 47498, WMDM_FORMATCODE_MK3D = 47499, WMDM_FORMATCODE_UNDEFINEDCOLLECTION = 47616, WMDM_FORMATCODE_ABSTRACTMULTIMEDIAALBUM = 47617, WMDM_FORMATCODE_ABSTRACTIMAGEALBUM = 47618, WMDM_FORMATCODE_ABSTRACTAUDIOALBUM = 47619, WMDM_FORMATCODE_ABSTRACTVIDEOALBUM = 47620, WMDM_FORMATCODE_ABSTRACTAUDIOVIDEOPLAYLIST = 47621 }; +enum tagWMDM_FIND_SCOPE{ WMDM_FIND_SCOPE_GLOBAL = 0, WMDM_FIND_SCOPE_IMMEDIATE_CHILDREN = 1 }; +enum tagMxdcLandscapeRotationEnums{ MXDC_LANDSCAPE_ROTATE_COUNTERCLOCKWISE_90_DEGREES = 90, MXDC_LANDSCAPE_ROTATE_NONE = 0, MXDC_LANDSCAPE_ROTATE_COUNTERCLOCKWISE_270_DEGREES = 4294967206 }; +enum tagMxdcImageTypeEnums{ MXDC_IMAGETYPE_JPEGHIGH_COMPRESSION = 1, MXDC_IMAGETYPE_JPEGMEDIUM_COMPRESSION = 2, MXDC_IMAGETYPE_JPEGLOW_COMPRESSION = 3, MXDC_IMAGETYPE_PNG = 4 }; +struct tagMxdcEscapeHeader{ ULONG cbInput; ULONG cbOutput; ULONG opCode; }; +struct tagMxdcGetFileNameData{ ULONG cbOutput; wchar_t wszData[1]; }; +struct tagMxdcS0PageData{ ULONG dwSize; UCHAR bData[1]; }; +enum tagMxdcS0PageEnums{ MXDC_RESOURCE_TTF = 0, MXDC_RESOURCE_JPEG = 1, MXDC_RESOURCE_PNG = 2, MXDC_RESOURCE_TIFF = 3, MXDC_RESOURCE_WDP = 4, MXDC_RESOURCE_DICTIONARY = 5, MXDC_RESOURCE_ICC_PROFILE = 6, MXDC_RESOURCE_JPEG_THUMBNAIL = 7, MXDC_RESOURCE_PNG_THUMBNAIL = 8, MXDC_RESOURCE_MAX = 9 }; +struct tagMxdcXpsS0PageResource{ ULONG dwSize; ULONG dwResourceType; UCHAR szUri[260]; ULONG dwDataSize; UCHAR bData[1]; }; +struct tagMxdcPrintTicketPassthrough{ ULONG dwDataSize; UCHAR bData[1]; }; +struct tagMxdcPrintTicketEscape{ MXDC_ESCAPE_HEADER_T mxdcEscape; MXDC_PRINTTICKET_DATA_T printTicketData; }; +struct tagMxdcS0PagePassthroughEscape{ MXDC_ESCAPE_HEADER_T mxdcEscape; MXDC_S0PAGE_DATA_T xpsS0PageData; }; +struct tagMxdcS0PageResourceEscape{ MXDC_ESCAPE_HEADER_T mxdcEscape; MXDC_XPS_S0PAGE_RESOURCE_T xpsS0PageResourcePassthrough; }; +enum tagIsolationState{ isolationStateNotRestricted = 1, isolationStateInProbation = 2, isolationStateRestrictedAccess = 3 }; +enum tagExtendedIsolationState{ extendedIsolationStateNoData = 0, extendedIsolationStateTransition = 1, extendedIsolationStateInfected = 2, extendedIsolationStateUnknown = 3 }; +enum tagNapTracingLevel{ tracingLevelUndefined = 0, tracingLevelBasic = 1, tracingLevelAdvanced = 2, tracingLevelDebug = 3 }; +struct tagCountedString{ UINT16 length; WCHAR* string; }; +struct tagIsolationInfo{ IsolationState isolationState; ProbationTime probEndTime; CountedString failureUrl; }; +struct tagIsolationInfoEx{ IsolationState isolationState; ExtendedIsolationState extendedIsolationState; ProbationTime probEndTime; CountedString failureUrl; }; +enum tagFailureCategory{ failureCategoryNone = 0, failureCategoryOther = 1, failureCategoryClientComponent = 2, failureCategoryClientCommunication = 3, failureCategoryServerComponent = 4, failureCategoryServerCommunication = 5 }; +struct tagFailureCategoryMapping{ BOOL mappingCompliance[5]; }; +struct tagCorrelationId{ GUID connId; FILETIME timeStamp; }; +typedef Percentage UINT8; +struct tagResultCodes{ UINT16 count; HRESULT* results; }; +struct tagIpv4Address{ UCHAR addr[4]; }; +struct tagIpv6Address{ UCHAR addr[16]; }; +enum tagFixupState{ fixupStateSuccess = 0, fixupStateInProgress = 1, fixupStateCouldNotUpdate = 2 }; +struct tagFixupInfo{ FixupState state; Percentage percentage; ResultCodes resultCodes; MessageId fixupMsgId; }; +enum tagNapNotifyType{ napNotifyTypeUnknown = 0, napNotifyTypeServiceState = 1, napNotifyTypeQuarState = 2 }; +struct tagSystemHealthAgentState{ SystemHealthEntityId id; ResultCodes shaResultCodes; FailureCategory failureCategory; FixupInfo fixupInfo; }; +struct tagSoHAttribute{ UINT16 type; UINT16 size; UCHAR* value; }; +struct tagSoH{ UINT16 count; SoHAttribute* attributes; }; +struct tagNetworkSoH{ UINT16 size; UCHAR* data; }; +struct tagPrivateData{ UINT16 size; UCHAR* data; }; +struct tagNapComponentRegistrationInfo{ NapComponentId id; CountedString friendlyName; CountedString description; CountedString version; CountedString vendorName; CLSID infoClsid; CLSID configClsid; FILETIME registrationDate; UINT32 componentType; }; +enum tagRemoteConfigurationType{ remoteConfigTypeMachine = 1, remoteConfigTypeConfigBlob = 2 }; +enum tagATTRIBUTE_TYPE{ AT_INVALID = 0, AT_BOOLEAN = 1, AT_INT8 = 2, AT_UINT8 = 3, AT_INT16 = 4, AT_UINT16 = 5, AT_INT32 = 6, AT_UINT32 = 7, AT_INT64 = 8, AT_UINT64 = 9, AT_STRING = 10, AT_GUID = 11, AT_LIFE_TIME = 12, AT_SOCKADDR = 13, AT_OCTET_STRING = 14 }; +struct tagOCTET_STRING{ ULONG dwLength; UCHAR* lpValue; }; +struct tagLIFE_TIME{ FILETIME startTime; FILETIME endTime; }; +struct tagSOCK_ADDR{ USHORT family; CHAR data[126]; }; +struct tagHELPER_ATTRIBUTE{ LPWSTR pwszName; ATTRIBUTE_TYPE type; }; +enum tagREPAIR_SCOPE{ RS_SYSTEM = 0, RS_USER = 1, RS_APPLICATION = 2, RS_PROCESS = 3 }; +struct tagShellCommandInfo{ LPWSTR pwszOperation; LPWSTR pwszFile; LPWSTR pwszParameters; LPWSTR pwszDirectory; ULONG nShowCmd; }; +struct tagUiInfo{ UI_INFO_TYPE type; }; +struct tagRepairInfo{ GUID guid; LPWSTR pwszClassName; LPWSTR pwszDescription; ULONG sidType; long cost; ULONG flags; REPAIR_SCOPE scope; REPAIR_RISK risk; UiInfo UiInfo; int rootCauseIndex; }; +struct tagRepairInfoEx{ RepairInfo repair; USHORT repairRank; }; +struct tagRootCauseInfo{ LPWSTR pwszDescription; GUID rootCauseID; ULONG rootCauseFlags; GUID networkInterfaceID; RepairInfoEx* pRepairs; USHORT repairCount; }; +enum tagDIAGNOSIS_STATUS{ DS_NOT_IMPLEMENTED = 0, DS_CONFIRMED = 1, DS_REJECTED = 2, DS_INDETERMINATE = 3, DS_DEFERRED = 4, DS_PASSTHROUGH = 5 }; +enum tagREPAIR_STATUS{ RS_NOT_IMPLEMENTED = 0, RS_REPAIRED = 1, RS_UNREPAIRED = 2, RS_DEFERRED = 3, RS_USER_ACTION = 4 }; +enum tagPROBLEM_TYPE{ PT_INVALID = 0, PT_LOW_HEALTH = 1, PT_LOWER_HEALTH = 2, PT_DOWN_STREAM_HEALTH = 4, PT_HIGH_UTILIZATION = 8, PT_HIGHER_UTILIZATION = 16, PT_UP_STREAM_UTILIZATION = 32 }; +struct tagHYPOTHESIS{ LPWSTR pwszClassName; LPWSTR pwszDescription; ULONG celt; PHELPER_ATTRIBUTE rgAttributes; }; +struct tagHelperAttributeInfo{ LPWSTR pwszName; ATTRIBUTE_TYPE type; }; +struct tagDiagnosticsInfo{ long cost; ULONG flags; }; +struct tagHypothesisResult{ HYPOTHESIS hypothesis; DIAGNOSIS_STATUS pathStatus; }; +enum _tagEXPR_TOKEN{ FC_EXPR_START = 0, FC_EXPR_ILLEGAL = 0, FC_EXPR_CONST32 = 1, FC_EXPR_CONST64 = 2, FC_EXPR_VAR = 3, FC_EXPR_OPER = 4, FC_EXPR_NOOP = 5, FC_EXPR_END = 6 }; +enum tagOBO_TOKEN_TYPE{ OBO_USER = 1, OBO_COMPONENT = 2, OBO_SOFTWARE = 3 }; +struct tagOBO_TOKEN{ OBO_TOKEN_TYPE Type; INetCfgComponent* pncc; LPCWSTR pszwManufacturer; LPCWSTR pszwProduct; LPCWSTR pszwDisplayName; BOOL fRegistered; }; +enum tagCOMPONENT_CHARACTERISTICS{ NCF_VIRTUAL = 1, NCF_SOFTWARE_ENUMERATED = 2, NCF_PHYSICAL = 4, NCF_HIDDEN = 8, NCF_NO_SERVICE = 16, NCF_NOT_USER_REMOVABLE = 32, NCF_MULTIPORT_INSTANCED_ADAPTER = 64, NCF_HAS_UI = 128, NCF_SINGLE_INSTANCE = 256, NCF_FILTER = 1024, NCF_DONTEXPOSELOWER = 4096, NCF_HIDE_BINDING = 8192, NCF_NDIS_PROTOCOL = 16384, NCF_FIXED_BINDING = 131072, NCF_LW_FILTER = 262144 }; +enum tagNCRP_FLAGS{ NCRP_QUERY_PROPERTY_UI = 1, NCRP_SHOW_PROPERTY_UI = 2 }; +enum tagSUPPORTS_BINDING_INTERFACE_FLAGS{ NCF_LOWER = 1, NCF_UPPER = 2 }; +enum tagENUM_BINDING_PATHS_FLAGS{ EBP_ABOVE = 1, EBP_BELOW = 2 }; +enum tagNCPNP_RECONFIG_LAYER{ NCRL_NDIS = 1, NCRL_TDI = 2 }; +enum tagNETWORK_INSTALL_TIME{ NSF_PRIMARYINSTALL = 1, NSF_POSTSYSINSTALL = 2 }; +enum tagNETWORK_UPGRADE_TYPE{ NSF_WIN16_UPGRADE = 16, NSF_WIN95_UPGRADE = 32, NSF_WINNT_WKS_UPGRADE = 64, NSF_WINNT_SVR_UPGRADE = 128, NSF_WINNT_SBS_UPGRADE = 256, NSF_COMPONENT_UPDATE = 512 }; +enum tagDEFAULT_PAGES{ DPP_ADVANCED = 1 }; +enum tagBIND_FLAGS1{ NCN_ADD = 1, NCN_REMOVE = 2, NCN_UPDATE = 4, NCN_ENABLE = 16, NCN_DISABLE = 32, NCN_BINDING_PATH = 256, NCN_PROPERTYCHANGE = 512, NCN_NET = 65536, NCN_NETTRANS = 131072, NCN_NETCLIENT = 262144, NCN_NETSERVICE = 524288 }; +enum tagRASCON_IPUI_FLAGS{ RCUIF_VPN = 1, RCUIF_DEMAND_DIAL = 2, RCUIF_NOT_ADMIN = 4, RCUIF_USE_IPv4_STATICADDRESS = 8, RCUIF_USE_IPv4_NAME_SERVERS = 16, RCUIF_USE_IPv4_REMOTE_GATEWAY = 32, RCUIF_USE_IPv4_EXPLICIT_METRIC = 64, RCUIF_USE_HEADER_COMPRESSION = 128, RCUIF_USE_DISABLE_REGISTER_DNS = 256, RCUIF_USE_PRIVATE_DNS_SUFFIX = 512, RCUIF_ENABLE_NBT = 1024, RCUIF_USE_IPv6_STATICADDRESS = 2048, RCUIF_USE_IPv6_NAME_SERVERS = 4096, RCUIF_USE_IPv6_REMOTE_GATEWAY = 8192, RCUIF_USE_IPv6_EXPLICIT_METRIC = 16384, RCUIF_DISABLE_CLASS_BASED_ROUTE = 32768 }; +struct tagRASCON_IPUI{ GUID guidConnection; BOOL fIPv6Cfg; ULONG dwFlags; WCHAR pszwIpAddr[16]; WCHAR pszwDnsAddr[16]; WCHAR pszwDns2Addr[16]; WCHAR pszwWinsAddr[16]; WCHAR pszwWins2Addr[16]; WCHAR pszwDnsSuffix[256]; WCHAR pszwIpv6Addr[65]; ULONG dwIpv6PrefixLength; WCHAR pszwIpv6DnsAddr[65]; WCHAR pszwIpv6Dns2Addr[65]; ULONG dwIPv4InfMetric; ULONG dwIPv6InfMetric; }; +enum tagNETCON_CHARACTERISTIC_FLAGS{ NCCF_NONE = 0, NCCF_ALL_USERS = 1, NCCF_ALLOW_DUPLICATION = 2, NCCF_ALLOW_REMOVAL = 4, NCCF_ALLOW_RENAME = 8, NCCF_INCOMING_ONLY = 32, NCCF_OUTGOING_ONLY = 64, NCCF_BRANDED = 128, NCCF_SHARED = 256, NCCF_BRIDGED = 512, NCCF_FIREWALLED = 1024, NCCF_DEFAULT = 2048, NCCF_HOMENET_CAPABLE = 4096, NCCF_SHARED_PRIVATE = 8192, NCCF_QUARANTINED = 16384, NCCF_RESERVED = 32768, NCCF_HOSTED_NETWORK = 65536, NCCF_VIRTUAL_STATION = 131072, NCCF_WIFI_DIRECT = 262144, NCCF_BLUETOOTH_MASK = 983040, NCCF_LAN_MASK = 15728640 }; +enum tagNETCON_STATUS{ NCS_DISCONNECTED = 0, NCS_CONNECTING = 1, NCS_CONNECTED = 2, NCS_DISCONNECTING = 3, NCS_HARDWARE_NOT_PRESENT = 4, NCS_HARDWARE_DISABLED = 5, NCS_HARDWARE_MALFUNCTION = 6, NCS_MEDIA_DISCONNECTED = 7, NCS_AUTHENTICATING = 8, NCS_AUTHENTICATION_SUCCEEDED = 9, NCS_AUTHENTICATION_FAILED = 10, NCS_INVALID_ADDRESS = 11, NCS_CREDENTIALS_REQUIRED = 12, NCS_ACTION_REQUIRED = 13, NCS_ACTION_REQUIRED_RETRY = 14, NCS_CONNECT_FAILED = 15 }; +enum tagNETCON_TYPE{ NCT_DIRECT_CONNECT = 0, NCT_INBOUND = 1, NCT_INTERNET = 2, NCT_LAN = 3, NCT_PHONE = 4, NCT_TUNNEL = 5, NCT_BRIDGE = 6 }; +enum tagNETCON_MEDIATYPE{ NCM_NONE = 0, NCM_DIRECT = 1, NCM_ISDN = 2, NCM_LAN = 3, NCM_PHONE = 4, NCM_TUNNEL = 5, NCM_PPPOE = 6, NCM_BRIDGE = 7, NCM_SHAREDACCESSHOST_LAN = 8, NCM_SHAREDACCESSHOST_RAS = 9 }; +struct tagNETCON_PROPERTIES{ GUID guidId; LPWSTR pszwName; LPWSTR pszwDeviceName; NETCON_STATUS Status; NETCON_MEDIATYPE MediaType; ULONG dwCharacter; CLSID clsidThisObject; CLSID clsidUiObject; }; +enum tagNETCONMGR_ENUM_FLAGS{ NCME_DEFAULT = 0, NCME_HIDDEN = 1 }; +enum tagNETCONUI_CONNECT_FLAGS{ NCUC_DEFAULT = 0, NCUC_NO_UI = 1, NCUC_ENABLE_DISABLE = 2 }; +enum tagSHARINGCONNECTIONTYPE{ ICSSHARINGTYPE_PUBLIC = 0, ICSSHARINGTYPE_PRIVATE = 1 }; +enum tagSHARINGCONNECTION_ENUM_FLAGS{ ICSSC_DEFAULT = 0, ICSSC_ENABLED = 1 }; +enum tagICS_TARGETTYPE{ ICSTT_NAME = 0, ICSTT_IPADDRESS = 1 }; +enum _tag_FW_DYNAMIC_KEYWORD_ORIGIN_TYPE{ FW_DYNAMIC_KEYWORD_ORIGIN_INVALID = 0, FW_DYNAMIC_KEYWORD_ORIGIN_LOCAL = 1, FW_DYNAMIC_KEYWORD_ORIGIN_MDM = 2 }; +struct _tag_FW_DYNAMIC_KEYWORD_ADDRESS0{ GUID id; PCWSTR keyword; ULONG flags; PCWSTR addresses; }; +struct _tag_FW_DYNAMIC_KEYWORD_ADDRESS_DATA0{ _tag_FW_DYNAMIC_KEYWORD_ADDRESS0 dynamicKeywordAddress; _tag_FW_DYNAMIC_KEYWORD_ADDRESS_DATA0* next; WORD schemaVersion; FW_DYNAMIC_KEYWORD_ORIGIN_TYPE originType; }; +enum _tag_FW_DYNAMIC_KEYWORD_ADDRESS_FLAGS{ FW_DYNAMIC_KEYWORD_ADDRESS_FLAGS_AUTO_RESOLVE = 1 }; +enum _tag_FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS{ FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS_AUTO_RESOLVE = 1, FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS_NON_AUTO_RESOLVE = 2, FW_DYNAMIC_KEYWORD_ADDRESS_ENUM_FLAGS_ALL = 3 }; +enum napi_provider_type_tag{ ProviderType_Application = 1, ProviderType_Service = 2 }; +enum napi_provider_level_tag{ ProviderLevel_None = 0, ProviderLevel_Secondary = 1, ProviderLevel_Primary = 2 }; +struct napi_domain_description_blob_tag{ ULONG AuthLevel; ULONG cchDomainName; ULONG OffsetNextDomainDescription; ULONG OffsetThisDomainName; }; +struct napi_provider_installation_blob_tag{ ULONG dwVersion; ULONG dwProviderType; ULONG fSupportsWildCard; ULONG cDomains; ULONG OffsetFirstDomain; }; +struct tagCIPROPERTYDEF{ LPWSTR wcsFriendlyName; ULONG dbType; DBID dbCol; }; +struct tagDATE_STRUCT{ SQLSMALLINT year; SQLUSMALLINT month; SQLUSMALLINT day; }; +struct tagTIME_STRUCT{ SQLUSMALLINT hour; SQLUSMALLINT minute; SQLUSMALLINT second; }; +struct tagTIMESTAMP_STRUCT{ SQLSMALLINT year; SQLUSMALLINT month; SQLUSMALLINT day; SQLUSMALLINT hour; SQLUSMALLINT minute; SQLUSMALLINT second; SQLUINTEGER fraction; }; +struct tagSQL_YEAR_MONTH{ SQLUINTEGER year; SQLUINTEGER month; }; +struct tagSQL_DAY_SECOND{ SQLUINTEGER day; SQLUINTEGER hour; SQLUINTEGER minute; SQLUINTEGER second; SQLUINTEGER fraction; }; +struct tagSQL_INTERVAL_STRUCT{ SQLINTERVAL interval_type; SQLSMALLINT interval_sign; 756C4E754E556548445130486B4542626658444F58562B7A5966673D intval; }; +struct tagSQL_NUMERIC_STRUCT{ SQLCHAR precision; SQLSCHAR scale; SQLCHAR sign; SQLCHAR val[16]; }; +struct tagMSAAMENUINFO{ ULONG dwMSAASignature; ULONG cchWText; LPWSTR pszWText; }; +struct tagDBROWWATCHRANGE{ HWATCHREGION hRegion; DBROWCHANGEKIND eChangeKind; HROW hRow; DBCOUNTITEM iRow; }; +struct tagDBCOST{ DBRESOURCEKIND eKind; DBCOSTUNIT dwUnits; LONG lValue; }; +struct tagOLEUIINSERTOBJECTW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; CLSID clsid; LPWSTR lpszFile; UINT cchFile; UINT cClsidExclude; LPCLSID lpClsidExclude; IID iid; ULONG oleRender; LPFORMATETC lpFormatEtc; LPOLECLIENTSITE lpIOleClientSite; LPSTORAGE lpIStorage; LPVOID* ppvObj; SCODE sc; HANDLE hMetaPict; }; +struct tagOLEUIINSERTOBJECTA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; CLSID clsid; LPSTR lpszFile; UINT cchFile; UINT cClsidExclude; LPCLSID lpClsidExclude; IID iid; ULONG oleRender; LPFORMATETC lpFormatEtc; LPOLECLIENTSITE lpIOleClientSite; LPSTORAGE lpIStorage; LPVOID* ppvObj; SCODE sc; HANDLE hMetaPict; }; +enum tagOLEUIPASTEFLAG{ OLEUIPASTE_ENABLEICON = 2048, OLEUIPASTE_PASTEONLY = 0, OLEUIPASTE_PASTE = 512, OLEUIPASTE_LINKANYTYPE = 1024, OLEUIPASTE_LINKTYPE1 = 1, OLEUIPASTE_LINKTYPE2 = 2, OLEUIPASTE_LINKTYPE3 = 4, OLEUIPASTE_LINKTYPE4 = 8, OLEUIPASTE_LINKTYPE5 = 16, OLEUIPASTE_LINKTYPE6 = 32, OLEUIPASTE_LINKTYPE7 = 64, OLEUIPASTE_LINKTYPE8 = 128 }; +struct tagOLEUIPASTEENTRYW{ FORMATETC fmtetc; LPCWSTR lpstrFormatName; LPCWSTR lpstrResultText; ULONG dwFlags; ULONG dwScratchSpace; }; +struct tagOLEUIPASTEENTRYA{ FORMATETC fmtetc; LPCSTR lpstrFormatName; LPCSTR lpstrResultText; ULONG dwFlags; ULONG dwScratchSpace; }; +struct tagOLEUIPASTESPECIALW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; LPDATAOBJECT lpSrcDataObj; LPOLEUIPASTEENTRYW arrPasteEntries; int cPasteEntries; UINT* arrLinkTypes; int cLinkTypes; UINT cClsidExclude; LPCLSID lpClsidExclude; int nSelectedIndex; BOOL fLink; HANDLE hMetaPict; SIZEL sizel; }; +struct tagOLEUIPASTESPECIALA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; LPDATAOBJECT lpSrcDataObj; LPOLEUIPASTEENTRYA arrPasteEntries; int cPasteEntries; UINT* arrLinkTypes; int cLinkTypes; UINT cClsidExclude; LPCLSID lpClsidExclude; int nSelectedIndex; BOOL fLink; HANDLE hMetaPict; SIZEL sizel; }; +struct tagOLEUIEDITLINKSW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; LPOLEUILINKCONTAINERW lpOleUILinkContainer; }; +struct tagOLEUIEDITLINKSA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; LPOLEUILINKCONTAINERA lpOleUILinkContainer; }; +struct tagOLEUICHANGEICONW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; HANDLE hMetaPict; CLSID clsid; WCHAR szIconExe[260]; int cchIconExe; }; +struct tagOLEUICHANGEICONA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; HANDLE hMetaPict; CLSID clsid; CHAR szIconExe[260]; int cchIconExe; }; +struct tagOLEUICONVERTW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; CLSID clsid; CLSID clsidConvertDefault; CLSID clsidActivateDefault; CLSID clsidNew; ULONG dvAspect; WORD wFormat; BOOL fIsLinkedObject; HANDLE hMetaPict; LPWSTR lpszUserType; BOOL fObjectsIconChanged; LPWSTR lpszDefLabel; UINT cClsidExclude; LPCLSID lpClsidExclude; }; +struct tagOLEUICONVERTA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; CLSID clsid; CLSID clsidConvertDefault; CLSID clsidActivateDefault; CLSID clsidNew; ULONG dvAspect; WORD wFormat; BOOL fIsLinkedObject; HANDLE hMetaPict; LPSTR lpszUserType; BOOL fObjectsIconChanged; LPSTR lpszDefLabel; UINT cClsidExclude; LPCLSID lpClsidExclude; }; +struct tagOLEUIBUSYW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; HTASK hTask; HWND* lphWndDialog; }; +struct tagOLEUIBUSYA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; HTASK hTask; HWND* lphWndDialog; }; +struct tagOLEUICHANGESOURCEW{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCWSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCWSTR lpszTemplate; HRSRC hResource; OPENFILENAMEW* lpOFN; ULONG dwReserved1[4]; LPOLEUILINKCONTAINERW lpOleUILinkContainer; ULONG dwLink; LPWSTR lpszDisplayName; ULONG nFileLength; LPWSTR lpszFrom; LPWSTR lpszTo; }; +struct tagOLEUICHANGESOURCEA{ ULONG cbStruct; ULONG dwFlags; HWND hWndOwner; LPCSTR lpszCaption; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; HINSTANCE hInstance; LPCSTR lpszTemplate; HRSRC hResource; OPENFILENAMEA* lpOFN; ULONG dwReserved1[4]; LPOLEUILINKCONTAINERA lpOleUILinkContainer; ULONG dwLink; LPSTR lpszDisplayName; ULONG nFileLength; LPSTR lpszFrom; LPSTR lpszTo; }; +struct tagOLEUIOBJECTPROPSW{ ULONG cbStruct; ULONG dwFlags; LPPROPSHEETHEADERW lpPS; ULONG dwObject; LPOLEUIOBJINFOW lpObjInfo; ULONG dwLink; LPOLEUILINKINFOW lpLinkInfo; LPOLEUIGNRLPROPSW lpGP; LPOLEUIVIEWPROPSW lpVP; LPOLEUILINKPROPSW lpLP; }; +struct tagOLEUIOBJECTPROPSA{ ULONG cbStruct; ULONG dwFlags; LPPROPSHEETHEADERA lpPS; ULONG dwObject; LPOLEUIOBJINFOA lpObjInfo; ULONG dwLink; LPOLEUILINKINFOA lpLinkInfo; LPOLEUIGNRLPROPSA lpGP; LPOLEUIVIEWPROPSA lpVP; LPOLEUILINKPROPSA lpLP; }; +struct tagOLEUIGNRLPROPSW{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSW* lpOP; }; +struct tagOLEUIGNRLPROPSA{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSA* lpOP; }; +struct tagOLEUIVIEWPROPSW{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSW* lpOP; int nScaleMin; int nScaleMax; }; +struct tagOLEUIVIEWPROPSA{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSA* lpOP; int nScaleMin; int nScaleMax; }; +struct tagOLEUILINKPROPSW{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSW* lpOP; }; +struct tagOLEUILINKPROPSA{ ULONG cbStruct; ULONG dwFlags; ULONG dwReserved1[2]; LPFNOLEUIHOOK lpfnHook; LPARAM lCustData; ULONG dwReserved2[3]; tagOLEUIOBJECTPROPSA* lpOP; }; +enum peer_record_change_type_tag{ PEER_RECORD_ADDED = 1, PEER_RECORD_UPDATED = 2, PEER_RECORD_DELETED = 3, PEER_RECORD_EXPIRED = 4 }; +enum peer_connection_status_tag{ PEER_CONNECTED = 1, PEER_DISCONNECTED = 2, PEER_CONNECTION_FAILED = 3 }; +enum peer_connection_flags_tag{ PEER_CONNECTION_NEIGHBOR = 1, PEER_CONNECTION_DIRECT = 2 }; +enum peer_record_flags_tag{ PEER_RECORD_FLAG_AUTOREFRESH = 1, PEER_RECORD_FLAG_DELETED = 2 }; +struct peer_version_data_tag{ WORD wVersion; WORD wHighestVersion; }; +struct peer_data_tag{ ULONG cbData; PBYTE pbData; }; +struct peer_record_tag{ ULONG dwSize; GUID type; GUID id; ULONG dwVersion; ULONG dwFlags; PWSTR pwzCreatorId; PWSTR pwzModifiedById; PWSTR pwzAttributes; FILETIME ftCreation; FILETIME ftExpiration; FILETIME ftLastModified; PEER_DATA securityData; PEER_DATA data; }; +struct peer_address_tag{ ULONG dwSize; SOCKADDR_IN6 sin6; }; +struct peer_connection_info_tag{ ULONG dwSize; ULONG dwFlags; ULONGLONG ullConnectionId; ULONGLONG ullNodeId; PWSTR pwzPeerId; PEER_ADDRESS address; }; +struct peer_event_incoming_data_tag{ ULONG dwSize; ULONGLONG ullConnectionId; GUID type; PEER_DATA data; }; +struct peer_event_record_change_data_tag{ ULONG dwSize; PEER_RECORD_CHANGE_TYPE changeType; GUID recordId; GUID recordType; }; +struct peer_event_connection_change_data_tag{ ULONG dwSize; PEER_CONNECTION_STATUS status; ULONGLONG ullConnectionId; ULONGLONG ullNodeId; ULONGLONG ullNextConnectionId; HRESULT hrConnectionFailedReason; }; +struct peer_event_synchronized_data_tag{ ULONG dwSize; GUID recordType; }; +enum peer_graph_event_type_tag{ PEER_GRAPH_EVENT_STATUS_CHANGED = 1, PEER_GRAPH_EVENT_PROPERTY_CHANGED = 2, PEER_GRAPH_EVENT_RECORD_CHANGED = 3, PEER_GRAPH_EVENT_DIRECT_CONNECTION = 4, PEER_GRAPH_EVENT_NEIGHBOR_CONNECTION = 5, PEER_GRAPH_EVENT_INCOMING_DATA = 6, PEER_GRAPH_EVENT_CONNECTION_REQUIRED = 7, PEER_GRAPH_EVENT_NODE_CHANGED = 8, PEER_GRAPH_EVENT_SYNCHRONIZED = 9 }; +enum peer_node_change_type_tag{ PEER_NODE_CHANGE_CONNECTED = 1, PEER_NODE_CHANGE_DISCONNECTED = 2, PEER_NODE_CHANGE_UPDATED = 3 }; +enum peer_graph_status_flags_tag{ PEER_GRAPH_STATUS_LISTENING = 1, PEER_GRAPH_STATUS_HAS_CONNECTIONS = 2, PEER_GRAPH_STATUS_SYNCHRONIZED = 4 }; +enum peer_graph_property_flags_tag{ PEER_GRAPH_PROPERTY_HEARTBEATS = 1, PEER_GRAPH_PROPERTY_DEFER_EXPIRATION = 2 }; +enum peer_graph_scope_tag{ PEER_GRAPH_SCOPE_ANY = 0, PEER_GRAPH_SCOPE_GLOBAL = 1, PEER_GRAPH_SCOPE_SITELOCAL = 2, PEER_GRAPH_SCOPE_LINKLOCAL = 3, PEER_GRAPH_SCOPE_LOOPBACK = 4 }; +struct peer_graph_properties_tag{ ULONG dwSize; ULONG dwFlags; ULONG dwScope; ULONG dwMaxRecordSize; PWSTR pwzGraphId; PWSTR pwzCreatorId; PWSTR pwzFriendlyName; PWSTR pwzComment; ULONG ulPresenceLifetime; ULONG cPresenceMax; }; +struct peer_node_info_tag{ ULONG dwSize; ULONGLONG ullNodeId; PWSTR pwzPeerId; ULONG cAddresses; PPEER_ADDRESS pAddresses; PWSTR pwzAttributes; }; +struct peer_event_node_change_data_tag{ ULONG dwSize; PEER_NODE_CHANGE_TYPE changeType; ULONGLONG ullNodeId; PWSTR pwzPeerId; }; +struct peer_graph_event_registration_tag{ PEER_GRAPH_EVENT_TYPE eventType; GUID* pType; }; +struct peer_graph_event_data_tag{ PEER_GRAPH_EVENT_TYPE eventType; }; +struct peer_security_interface_tag{ ULONG dwSize; PWSTR pwzSspFilename; PWSTR pwzPackageName; ULONG cbSecurityInfo; PBYTE pbSecurityInfo; PVOID pvContext; PFNPEER_VALIDATE_RECORD pfnValidateRecord; PFNPEER_SECURE_RECORD pfnSecureRecord; PFNPEER_FREE_SECURITY_DATA pfnFreeSecurityData; PFNPEER_ON_PASSWORD_AUTH_FAILED pfnAuthFailed; }; +enum peer_group_event_type_tag{ PEER_GROUP_EVENT_STATUS_CHANGED = 1, PEER_GROUP_EVENT_PROPERTY_CHANGED = 2, PEER_GROUP_EVENT_RECORD_CHANGED = 3, PEER_GROUP_EVENT_DIRECT_CONNECTION = 4, PEER_GROUP_EVENT_NEIGHBOR_CONNECTION = 5, PEER_GROUP_EVENT_INCOMING_DATA = 6, PEER_GROUP_EVENT_MEMBER_CHANGED = 8, PEER_GROUP_EVENT_CONNECTION_FAILED = 10, PEER_GROUP_EVENT_AUTHENTICATION_FAILED = 11 }; +enum peer_group_status_tag{ PEER_GROUP_STATUS_LISTENING = 1, PEER_GROUP_STATUS_HAS_CONNECTIONS = 2 }; +enum peer_group_property_flags_tag{ PEER_MEMBER_DATA_OPTIONAL = 1, PEER_DISABLE_PRESENCE = 2, PEER_DEFER_EXPIRATION = 4 }; +enum peer_group_authentication_scheme_tag{ PEER_GROUP_GMC_AUTHENTICATION = 1, PEER_GROUP_PASSWORD_AUTHENTICATION = 2 }; +enum peer_member_flags_tag{ PEER_MEMBER_PRESENT = 1 }; +enum peer_member_change_type_tag{ PEER_MEMBER_CONNECTED = 1, PEER_MEMBER_DISCONNECTED = 2, PEER_MEMBER_UPDATED = 3, PEER_MEMBER_JOINED = 4, PEER_MEMBER_LEFT = 5 }; +enum peer_issue_credential_flags_tag{ PEER_GROUP_STORE_CREDENTIALS = 1 }; +struct peer_credential_info_tag{ ULONG dwSize; ULONG dwFlags; PWSTR pwzFriendlyName; CERT_PUBLIC_KEY_INFO* pPublicKey; PWSTR pwzIssuerPeerName; PWSTR pwzIssuerFriendlyName; FILETIME ftValidityStart; FILETIME ftValidityEnd; ULONG cRoles; PEER_ROLE_ID* pRoles; }; +struct peer_member_tag{ ULONG dwSize; ULONG dwFlags; PWSTR pwzIdentity; PWSTR pwzAttributes; ULONGLONG ullNodeId; ULONG cAddresses; PEER_ADDRESS* pAddresses; PEER_CREDENTIAL_INFO* pCredentialInfo; }; +struct peer_invitation_info_tag{ ULONG dwSize; ULONG dwFlags; PWSTR pwzCloudName; ULONG dwScope; ULONG dwCloudFlags; PWSTR pwzGroupPeerName; PWSTR pwzIssuerPeerName; PWSTR pwzSubjectPeerName; PWSTR pwzGroupFriendlyName; PWSTR pwzIssuerFriendlyName; PWSTR pwzSubjectFriendlyName; FILETIME ftValidityStart; FILETIME ftValidityEnd; ULONG cRoles; PEER_ROLE_ID* pRoles; ULONG cClassifiers; PWSTR* ppwzClassifiers; CERT_PUBLIC_KEY_INFO* pSubjectPublicKey; PEER_GROUP_AUTHENTICATION_SCHEME authScheme; }; +struct peer_group_properties_tag{ ULONG dwSize; ULONG dwFlags; PWSTR pwzCloud; PWSTR pwzClassifier; PWSTR pwzGroupPeerName; PWSTR pwzCreatorPeerName; PWSTR pwzFriendlyName; PWSTR pwzComment; ULONG ulMemberDataLifetime; ULONG ulPresenceLifetime; ULONG dwAuthenticationSchemes; PWSTR pwzGroupPassword; PEER_ROLE_ID groupPasswordRole; }; +struct peer_event_member_change_data_tag{ ULONG dwSize; PEER_MEMBER_CHANGE_TYPE changeType; PWSTR pwzIdentity; }; +struct peer_group_event_registration_tag{ PEER_GROUP_EVENT_TYPE eventType; GUID* pType; }; +struct peer_group_event_data_tag{ PEER_GROUP_EVENT_TYPE eventType; }; +struct peer_name_pair_tag{ ULONG dwSize; PWSTR pwzPeerName; PWSTR pwzFriendlyName; }; +enum peer_signin_flags_tag{ PEER_SIGNIN_NONE = 0, PEER_SIGNIN_NEAR_ME = 1, PEER_SIGNIN_INTERNET = 2, PEER_SIGNIN_ALL = 3 }; +enum peer_watch_permission_tag{ PEER_WATCH_BLOCKED = 0, PEER_WATCH_ALLOWED = 1 }; +enum peer_publication_scope_tag{ PEER_PUBLICATION_SCOPE_NONE = 0, PEER_PUBLICATION_SCOPE_NEAR_ME = 1, PEER_PUBLICATION_SCOPE_INTERNET = 2, PEER_PUBLICATION_SCOPE_ALL = 3 }; +struct peer_application_tag{ GUID id; PEER_DATA data; PWSTR pwzDescription; }; +struct peer_object_tag{ GUID id; PEER_DATA data; ULONG dwPublicationScope; }; +struct peer_contact_tag{ PWSTR pwzPeerName; PWSTR pwzNickName; PWSTR pwzDisplayName; PWSTR pwzEmailAddress; BOOL fWatch; PEER_WATCH_PERMISSION WatcherPermissions; PEER_DATA credentials; }; +struct peer_endpoint_tag{ PEER_ADDRESS address; PWSTR pwzEndpointName; }; +struct peer_people_near_me_tag{ PWSTR pwzNickName; PEER_ENDPOINT endpoint; GUID id; }; +enum peer_invitation_response_type_tag{ PEER_INVITATION_RESPONSE_DECLINED = 0, PEER_INVITATION_RESPONSE_ACCEPTED = 1, PEER_INVITATION_RESPONSE_EXPIRED = 2, PEER_INVITATION_RESPONSE_ERROR = 3 }; +enum peer_application_registration_type_tag{ PEER_APPLICATION_CURRENT_USER = 0, PEER_APPLICATION_ALL_USERS = 1 }; +struct peer_invitation_tag{ GUID applicationId; PEER_DATA applicationData; PWSTR pwzMessage; }; +struct peer_invitation_response_tag{ PEER_INVITATION_RESPONSE_TYPE action; PWSTR pwzMessage; HRESULT hrExtendedInfo; }; +struct peer_app_launch_info_tag{ PPEER_CONTACT pContact; PPEER_ENDPOINT pEndpoint; PPEER_INVITATION pInvitation; }; +struct peer_application_registration_info_tag{ PEER_APPLICATION application; PWSTR pwzApplicationToLaunch; PWSTR pwzApplicationArguments; ULONG dwPublicationScope; }; +enum peer_presence_status_tag{ PEER_PRESENCE_OFFLINE = 0, PEER_PRESENCE_OUT_TO_LUNCH = 1, PEER_PRESENCE_AWAY = 2, PEER_PRESENCE_BE_RIGHT_BACK = 3, PEER_PRESENCE_IDLE = 4, PEER_PRESENCE_BUSY = 5, PEER_PRESENCE_ON_THE_PHONE = 6, PEER_PRESENCE_ONLINE = 7 }; +struct peer_presence_info_tag{ PEER_PRESENCE_STATUS status; PWSTR pwzDescriptiveText; }; +enum peer_change_type_tag{ PEER_CHANGE_ADDED = 0, PEER_CHANGE_DELETED = 1, PEER_CHANGE_UPDATED = 2 }; +enum peer_collab_event_type_tag{ PEER_EVENT_WATCHLIST_CHANGED = 1, PEER_EVENT_ENDPOINT_CHANGED = 2, PEER_EVENT_ENDPOINT_PRESENCE_CHANGED = 3, PEER_EVENT_ENDPOINT_APPLICATION_CHANGED = 4, PEER_EVENT_ENDPOINT_OBJECT_CHANGED = 5, PEER_EVENT_MY_ENDPOINT_CHANGED = 6, PEER_EVENT_MY_PRESENCE_CHANGED = 7, PEER_EVENT_MY_APPLICATION_CHANGED = 8, PEER_EVENT_MY_OBJECT_CHANGED = 9, PEER_EVENT_PEOPLE_NEAR_ME_CHANGED = 10, PEER_EVENT_REQUEST_STATUS_CHANGED = 11 }; +struct peer_collab_event_registration_tag{ PEER_COLLAB_EVENT_TYPE eventType; GUID* pInstance; }; +struct peer_event_watchlist_changed_data_tag{ PPEER_CONTACT pContact; PEER_CHANGE_TYPE changeType; }; +struct peer_event_presence_changed_data_tag{ PPEER_CONTACT pContact; PPEER_ENDPOINT pEndpoint; PEER_CHANGE_TYPE changeType; PPEER_PRESENCE_INFO pPresenceInfo; }; +struct peer_event_application_changed_data_tag{ PPEER_CONTACT pContact; PPEER_ENDPOINT pEndpoint; PEER_CHANGE_TYPE changeType; PPEER_APPLICATION pApplication; }; +struct peer_event_object_changed_data_tag{ PPEER_CONTACT pContact; PPEER_ENDPOINT pEndpoint; PEER_CHANGE_TYPE changeType; PPEER_OBJECT pObject; }; +struct peer_event_endpoint_changed_data_tag{ PPEER_CONTACT pContact; PPEER_ENDPOINT pEndpoint; }; +struct peer_event_people_near_me_changed_data_tag{ PEER_CHANGE_TYPE changeType; PPEER_PEOPLE_NEAR_ME pPeopleNearMe; }; +struct peer_event_request_status_changed_data_tag{ PPEER_ENDPOINT pEndpoint; HRESULT hrChange; }; +struct peer_collab_event_data_tag{ PEER_COLLAB_EVENT_TYPE eventType; }; +struct peer_pnrp_endpoint_info_tag{ PWSTR pwzPeerName; ULONG cAddresses; SOCKADDR** ppAddresses; PWSTR pwzComment; PEER_DATA payload; }; +struct peer_pnrp_cloud_info_tag{ PWSTR pwzCloudName; PNRP_SCOPE dwScope; ULONG dwScopeId; }; +struct peer_pnrp_registration_info_tag{ PWSTR pwzCloudName; PWSTR pwzPublishingIdentity; ULONG cAddresses; SOCKADDR** ppAddresses; WORD wPort; PWSTR pwzComment; PEER_DATA payload; }; +enum _tagTILE_TEMPLATE_TYPE{ TILE_TEMPLATE_INVALID = 0, TILE_TEMPLATE_FLIP = 5, TILE_TEMPLATE_DEEPLINK = 13, TILE_TEMPLATE_CYCLE = 14, TILE_TEMPLATE_METROCOUNT = 1, TILE_TEMPLATE_AGILESTORE = 2, TILE_TEMPLATE_GAMES = 3, TILE_TEMPLATE_CALENDAR = 4, TILE_TEMPLATE_MUSICVIDEO = 7, TILE_TEMPLATE_PEOPLE = 10, TILE_TEMPLATE_CONTACT = 11, TILE_TEMPLATE_GROUP = 12, TILE_TEMPLATE_DEFAULT = 15, TILE_TEMPLATE_BADGE = 16, TILE_TEMPLATE_BLOCK = 17, TILE_TEMPLATE_TEXT01 = 18, TILE_TEMPLATE_TEXT02 = 19, TILE_TEMPLATE_TEXT03 = 20, TILE_TEMPLATE_TEXT04 = 21, TILE_TEMPLATE_TEXT05 = 22, TILE_TEMPLATE_TEXT06 = 23, TILE_TEMPLATE_TEXT07 = 24, TILE_TEMPLATE_TEXT08 = 25, TILE_TEMPLATE_TEXT09 = 26, TILE_TEMPLATE_TEXT10 = 27, TILE_TEMPLATE_TEXT11 = 28, TILE_TEMPLATE_IMAGE = 29, TILE_TEMPLATE_IMAGECOLLECTION = 30, TILE_TEMPLATE_IMAGEANDTEXT01 = 31, TILE_TEMPLATE_IMAGEANDTEXT02 = 32, TILE_TEMPLATE_BLOCKANDTEXT01 = 33, TILE_TEMPLATE_BLOCKANDTEXT02 = 34, TILE_TEMPLATE_PEEKIMAGEANDTEXT01 = 35, TILE_TEMPLATE_PEEKIMAGEANDTEXT02 = 36, TILE_TEMPLATE_PEEKIMAGEANDTEXT03 = 37, TILE_TEMPLATE_PEEKIMAGEANDTEXT04 = 38, TILE_TEMPLATE_PEEKIMAGE01 = 39, TILE_TEMPLATE_PEEKIMAGE02 = 40, TILE_TEMPLATE_PEEKIMAGE03 = 41, TILE_TEMPLATE_PEEKIMAGE04 = 42, TILE_TEMPLATE_PEEKIMAGE05 = 43, TILE_TEMPLATE_PEEKIMAGE06 = 44, TILE_TEMPLATE_PEEKIMAGECOLLECTION01 = 45, TILE_TEMPLATE_PEEKIMAGECOLLECTION02 = 46, TILE_TEMPLATE_PEEKIMAGECOLLECTION03 = 47, TILE_TEMPLATE_PEEKIMAGECOLLECTION04 = 48, TILE_TEMPLATE_PEEKIMAGECOLLECTION05 = 49, TILE_TEMPLATE_PEEKIMAGECOLLECTION06 = 50, TILE_TEMPLATE_SMALLIMAGEANDTEXT01 = 51, TILE_TEMPLATE_SMALLIMAGEANDTEXT02 = 52, TILE_TEMPLATE_SMALLIMAGEANDTEXT03 = 53, TILE_TEMPLATE_SMALLIMAGEANDTEXT04 = 54, TILE_TEMPLATE_SMALLIMAGEANDTEXT05 = 55, TILE_TEMPLATE_METROCOUNTQUEUE = 56, TILE_TEMPLATE_SEARCH = 57, TILE_TEMPLATE_TILEFLYOUT01 = 58, TILE_TEMPLATE_FOLDER = 59, TILE_TEMPLATE_ALL = 100 }; +enum _tagPM_TASK_TYPE{ PM_TASK_TYPE_NORMAL = 0, PM_TASK_TYPE_DEFAULT = 1, PM_TASK_TYPE_SETTINGS = 2, PM_TASK_TYPE_BACKGROUNDSERVICEAGENT = 3, PM_TASK_TYPE_BACKGROUNDWORKER = 4, PM_TASK_TYPE_INVALID = 5 }; +enum _tagPM_ENUM_APP_FILTER{ PM_APP_FILTER_ALL = 0, PM_APP_FILTER_VISIBLE = 1, PM_APP_FILTER_GENRE = 2, PM_APP_FILTER_NONGAMES = 3, PM_APP_FILTER_HUBTYPE = 4, PM_APP_FILTER_PINABLEONKIDZONE = 5, PM_APP_FILTER_ALL_INCLUDE_MODERN = 6, PM_APP_FILTER_FRAMEWORK = 7, PM_APP_FILTER_MAX = 8 }; +enum _tagPM_ENUM_TILE_FILTER{ PM_TILE_FILTER_APPLIST = 8, PM_TILE_FILTER_PINNED = 9, PM_TILE_FILTER_HUBTYPE = 10, PM_TILE_FILTER_APP_ALL = 11, PM_TILE_FILTER_MAX = 12 }; +enum _tagPM_ENUM_TASK_FILTER{ PM_TASK_FILTER_APP_ALL = 12, PM_TASK_FILTER_TASK_TYPE = 13, PM_TASK_FILTER_DEHYD_SUPRESSING = 14, PM_TASK_FILTER_APP_TASK_TYPE = 15, PM_TASK_FILTER_BGEXECUTION = 16, PM_TASK_FILTER_MAX = 17 }; +enum _tagPM_ENUM_EXTENSION_FILTER{ PM_ENUM_EXTENSION_FILTER_BY_CONSUMER = 17, PM_ENUM_EXTENSION_FILTER_APPCONNECT = 17, PM_ENUM_EXTENSION_FILTER_PROTOCOL_ALL = 18, PM_ENUM_EXTENSION_FILTER_FTASSOC_FILETYPE_ALL = 19, PM_ENUM_EXTENSION_FILTER_FTASSOC_CONTENTTYPE_ALL = 20, PM_ENUM_EXTENSION_FILTER_FTASSOC_APPLICATION_ALL = 21, PM_ENUM_EXTENSION_FILTER_SHARETARGET_ALL = 22, PM_ENUM_EXTENSION_FILTER_FILEOPENPICKER_ALL = 23, PM_ENUM_EXTENSION_FILTER_FILESAVEPICKER_ALL = 24, PM_ENUM_EXTENSION_FILTER_CACHEDFILEUPDATER_ALL = 25, PM_ENUM_EXTENSION_FILTER_MAX = 26 }; +enum _tagPM_ENUM_BSA_FILTER{ PM_ENUM_BSA_FILTER_ALL = 26, PM_ENUM_BSA_FILTER_BY_TASKID = 27, PM_ENUM_BSA_FILTER_BY_PRODUCTID = 28, PM_ENUM_BSA_FILTER_BY_PERIODIC = 29, PM_ENUM_BSA_FILTER_BY_ALL_LAUNCHONBOOT = 30, PM_ENUM_BSA_FILTER_MAX = 31 }; +enum _tagPM_ENUM_BW_FILTER{ PM_ENUM_BW_FILTER_BOOTWORKER_ALL = 31, PM_ENUM_BW_FILTER_BY_TASKID = 32, PM_ENUM_BW_FILTER_MAX = 33 }; +struct _tagAPPTASKTYPE{ PRODUCTID ProductID; PM_TASK_TYPE TaskType; }; +struct _tagPM_EXTENSIONCONSUMER{ PRODUCTID ConsumerPID; BSTR ExtensionID; }; +struct _tagPM_BSATASKID{ PRODUCTID ProductID; BSTR TaskID; }; +struct _tagPM_BWTASKID{ PRODUCTID ProductID; BSTR TaskID; }; +enum _tagPM_LIVETILE_RECURRENCE_TYPE{ PM_LIVETILE_RECURRENCE_TYPE_INSTANT = 0, PM_LIVETILE_RECURRENCE_TYPE_ONETIME = 1, PM_LIVETILE_RECURRENCE_TYPE_INTERVAL = 2, PM_LIVETILE_RECURRENCE_TYPE_MAX = 2 }; +enum _tagPM_TILE_SIZE{ PM_TILE_SIZE_SMALL = 0, PM_TILE_SIZE_MEDIUM = 1, PM_TILE_SIZE_LARGE = 2, PM_TILE_SIZE_SQUARE310X310 = 3, PM_TILE_SIZE_TALL150X310 = 4, PM_TILE_SIZE_INVALID = 5 }; +enum _tagPM_LOGO_SIZE{ PM_LOGO_SIZE_SMALL = 0, PM_LOGO_SIZE_MEDIUM = 1, PM_LOGO_SIZE_LARGE = 2, PM_LOGO_SIZE_INVALID = 3 }; +struct _tagPM_STARTAPPBLOB{ ULONG cbSize; GUID ProductID; BSTR AppTitle; BSTR IconPath; BOOL IsUninstallable; PM_APPLICATION_INSTALL_TYPE AppInstallType; GUID InstanceID; PM_APPLICATION_STATE State; BOOL IsModern; BOOL IsModernLightUp; USHORT LightUpSupportMask; }; +struct _tagPM_INVOCATIONINFO{ BSTR URIBaseOrAUMID; BSTR URIFragmentOrArgs; }; +struct _tagPM_STARTTILEBLOB{ ULONG cbSize; PRODUCTID ProductID; BSTR TileID; TILE_TEMPLATE_TYPE TemplateType; ULONG HubPosition[32]; ULONG HubVisibilityBitmask; BOOL IsDefault; PM_STARTTILE_TYPE TileType; UCHAR* pbPropBlob; ULONG cbPropBlob; BOOL IsRestoring; BOOL IsModern; PM_INVOCATIONINFO InvocationInfo; }; +struct _tagPM_INSTALLINFO{ PRODUCTID ProductID; BSTR PackagePath; GUID InstanceID; UCHAR* pbLicense; ULONG cbLicense; BOOL IsUninstallDisabled; ULONG DeploymentOptions; GUID OfferID; BSTR MarketplaceAppVersion; }; +struct _tagPM_UPDATEINFO_LEGACY{ PRODUCTID ProductID; BSTR PackagePath; GUID InstanceID; UCHAR* pbLicense; ULONG cbLicense; BSTR MarketplaceAppVersion; }; +struct _tagPM_UPDATEINFO{ PRODUCTID ProductID; BSTR PackagePath; GUID InstanceID; UCHAR* pbLicense; ULONG cbLicense; BSTR MarketplaceAppVersion; ULONG DeploymentOptions; }; +struct peerdist_publication_options_tag{ ULONG dwVersion; ULONG dwFlags; }; +struct peerdist_content_tag_tag{ UCHAR Data[16]; }; +struct peerdist_retrieval_options_tag{ ULONG cbSize; ULONG dwContentInfoMinVersion; ULONG dwContentInfoMaxVersion; ULONG dwReserved; }; +struct peerdist_status_info_tag{ ULONG cbSize; PEERDIST_STATUS status; ULONG dwMinVer; ULONG dwMaxVer; }; +enum tagCDBURNINGEXTENSIONRET{ CDBE_RET_DEFAULT = 0, CDBE_RET_DONTRUNOTHEREXTS = 1, CDBE_RET_STOPWIZARD = 2 }; +enum tagUSER_INPUT_STRING_TYPE{ USER_INPUT_DEFAULT = 0, USER_INPUT_PATH_ELEMENT = 1 }; +enum tagERROR_ADVISE_MESSAGE_TYPE{ PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL = 0, PHOTOACQUIRE_ERROR_RETRYCANCEL = 1, PHOTOACQUIRE_ERROR_YESNO = 2, PHOTOACQUIRE_ERROR_OK = 3 }; +enum tagERROR_ADVISE_RESULT{ PHOTOACQUIRE_RESULT_YES = 0, PHOTOACQUIRE_RESULT_NO = 1, PHOTOACQUIRE_RESULT_OK = 2, PHOTOACQUIRE_RESULT_SKIP = 3, PHOTOACQUIRE_RESULT_SKIP_ALL = 4, PHOTOACQUIRE_RESULT_RETRY = 5, PHOTOACQUIRE_RESULT_ABORT = 6 }; +enum tagPROGRESS_DIALOG_IMAGE_TYPE{ PROGRESS_DIALOG_ICON_SMALL = 0, PROGRESS_DIALOG_ICON_LARGE = 1, PROGRESS_DIALOG_ICON_THUMBNAIL = 2, PROGRESS_DIALOG_BITMAP_THUMBNAIL = 3 }; +enum tagPROGRESS_DIALOG_CHECKBOX_ID{ PROGRESS_DIALOG_CHECKBOX_ID_DEFAULT = 0 }; +enum tagDEVICE_SELECTION_DEVICE_TYPE{ DST_UNKNOWN_DEVICE = 0, DST_WPD_DEVICE = 1, DST_WIA_DEVICE = 2, DST_STI_DEVICE = 3, DSF_TWAIN_DEVICE = 4, DST_FS_DEVICE = 5, DST_DV_DEVICE = 6 }; +enum tagDELETE_OBJECT_OPTIONS{ PORTABLE_DEVICE_DELETE_NO_RECURSION = 0, PORTABLE_DEVICE_DELETE_WITH_RECURSION = 1 }; +enum tagWPD_DEVICE_TYPES{ WPD_DEVICE_TYPE_GENERIC = 0, WPD_DEVICE_TYPE_CAMERA = 1, WPD_DEVICE_TYPE_MEDIA_PLAYER = 2, WPD_DEVICE_TYPE_PHONE = 3, WPD_DEVICE_TYPE_VIDEO = 4, WPD_DEVICE_TYPE_PERSONAL_INFORMATION_MANAGER = 5, WPD_DEVICE_TYPE_AUDIO_RECORDER = 6 }; +enum tagWpdAttributeForm{ WPD_PROPERTY_ATTRIBUTE_FORM_UNSPECIFIED = 0, WPD_PROPERTY_ATTRIBUTE_FORM_RANGE = 1, WPD_PROPERTY_ATTRIBUTE_FORM_ENUMERATION = 2, WPD_PROPERTY_ATTRIBUTE_FORM_REGULAR_EXPRESSION = 3, WPD_PROPERTY_ATTRIBUTE_FORM_OBJECT_IDENTIFIER = 4 }; +enum tagWpdParameterAttributeForm{ WPD_PARAMETER_ATTRIBUTE_FORM_UNSPECIFIED = 0, WPD_PARAMETER_ATTRIBUTE_FORM_RANGE = 1, WPD_PARAMETER_ATTRIBUTE_FORM_ENUMERATION = 2, WPD_PARAMETER_ATTRIBUTE_FORM_REGULAR_EXPRESSION = 3, WPD_PARAMETER_ATTRIBUTE_FORM_OBJECT_IDENTIFIER = 4 }; +enum tagWPD_DEVICE_TRANSPORTS{ WPD_DEVICE_TRANSPORT_UNSPECIFIED = 0, WPD_DEVICE_TRANSPORT_USB = 1, WPD_DEVICE_TRANSPORT_IP = 2, WPD_DEVICE_TRANSPORT_BLUETOOTH = 3 }; +enum tagWPD_STORAGE_TYPE_VALUES{ WPD_STORAGE_TYPE_UNDEFINED = 0, WPD_STORAGE_TYPE_FIXED_ROM = 1, WPD_STORAGE_TYPE_REMOVABLE_ROM = 2, WPD_STORAGE_TYPE_FIXED_RAM = 3, WPD_STORAGE_TYPE_REMOVABLE_RAM = 4 }; +enum tagWPD_STORAGE_ACCESS_CAPABILITY_VALUES{ WPD_STORAGE_ACCESS_CAPABILITY_READWRITE = 0, WPD_STORAGE_ACCESS_CAPABILITY_READ_ONLY_WITHOUT_OBJECT_DELETION = 1, WPD_STORAGE_ACCESS_CAPABILITY_READ_ONLY_WITH_OBJECT_DELETION = 2 }; +enum tagWPD_SMS_ENCODING_TYPES{ SMS_ENCODING_7_BIT = 0, SMS_ENCODING_8_BIT = 1, SMS_ENCODING_UTF_16 = 2 }; +enum tagSMS_MESSAGE_TYPES{ SMS_TEXT_MESSAGE = 0, SMS_BINARY_MESSAGE = 1 }; +enum tagWPD_POWER_SOURCES{ WPD_POWER_SOURCE_BATTERY = 0, WPD_POWER_SOURCE_EXTERNAL = 1 }; +enum tagWPD_WHITE_BALANCE_SETTINGS{ WPD_WHITE_BALANCE_UNDEFINED = 0, WPD_WHITE_BALANCE_MANUAL = 1, WPD_WHITE_BALANCE_AUTOMATIC = 2, WPD_WHITE_BALANCE_ONE_PUSH_AUTOMATIC = 3, WPD_WHITE_BALANCE_DAYLIGHT = 4, WPD_WHITE_BALANCE_FLORESCENT = 5, WPD_WHITE_BALANCE_TUNGSTEN = 6, WPD_WHITE_BALANCE_FLASH = 7 }; +enum tagWPD_FOCUS_MODES{ WPD_FOCUS_UNDEFINED = 0, WPD_FOCUS_MANUAL = 1, WPD_FOCUS_AUTOMATIC = 2, WPD_FOCUS_AUTOMATIC_MACRO = 3 }; +enum tagWPD_EXPOSURE_METERING_MODES{ WPD_EXPOSURE_METERING_MODE_UNDEFINED = 0, WPD_EXPOSURE_METERING_MODE_AVERAGE = 1, WPD_EXPOSURE_METERING_MODE_CENTER_WEIGHTED_AVERAGE = 2, WPD_EXPOSURE_METERING_MODE_MULTI_SPOT = 3, WPD_EXPOSURE_METERING_MODE_CENTER_SPOT = 4 }; +enum tagWPD_FLASH_MODES{ WPD_FLASH_MODE_UNDEFINED = 0, WPD_FLASH_MODE_AUTO = 1, WPD_FLASH_MODE_OFF = 2, WPD_FLASH_MODE_FILL = 3, WPD_FLASH_MODE_RED_EYE_AUTO = 4, WPD_FLASH_MODE_RED_EYE_FILL = 5, WPD_FLASH_MODE_EXTERNAL_SYNC = 6 }; +enum tagWPD_EXPOSURE_PROGRAM_MODES{ WPD_EXPOSURE_PROGRAM_MODE_UNDEFINED = 0, WPD_EXPOSURE_PROGRAM_MODE_MANUAL = 1, WPD_EXPOSURE_PROGRAM_MODE_AUTO = 2, WPD_EXPOSURE_PROGRAM_MODE_APERTURE_PRIORITY = 3, WPD_EXPOSURE_PROGRAM_MODE_SHUTTER_PRIORITY = 4, WPD_EXPOSURE_PROGRAM_MODE_CREATIVE = 5, WPD_EXPOSURE_PROGRAM_MODE_ACTION = 6, WPD_EXPOSURE_PROGRAM_MODE_PORTRAIT = 7 }; +enum tagWPD_CAPTURE_MODES{ WPD_CAPTURE_MODE_UNDEFINED = 0, WPD_CAPTURE_MODE_NORMAL = 1, WPD_CAPTURE_MODE_BURST = 2, WPD_CAPTURE_MODE_TIMELAPSE = 3 }; +enum tagWPD_EFFECT_MODES{ WPD_EFFECT_MODE_UNDEFINED = 0, WPD_EFFECT_MODE_COLOR = 1, WPD_EFFECT_MODE_BLACK_AND_WHITE = 2, WPD_EFFECT_MODE_SEPIA = 3 }; +enum tagWPD_FOCUS_METERING_MODES{ WPD_FOCUS_METERING_MODE_UNDEFINED = 0, WPD_FOCUS_METERING_MODE_CENTER_SPOT = 1, WPD_FOCUS_METERING_MODE_MULTI_SPOT = 2 }; +enum tagWPD_BITRATE_TYPES{ WPD_BITRATE_TYPE_UNUSED = 0, WPD_BITRATE_TYPE_DISCRETE = 1, WPD_BITRATE_TYPE_VARIABLE = 2, WPD_BITRATE_TYPE_FREE = 3 }; +enum tagWPD_META_GENRES{ WPD_META_GENRE_UNUSED = 0, WPD_META_GENRE_GENERIC_MUSIC_AUDIO_FILE = 1, WPD_META_GENRE_GENERIC_NON_MUSIC_AUDIO_FILE = 17, WPD_META_GENRE_SPOKEN_WORD_AUDIO_BOOK_FILES = 18, WPD_META_GENRE_SPOKEN_WORD_FILES_NON_AUDIO_BOOK = 19, WPD_META_GENRE_SPOKEN_WORD_NEWS = 20, WPD_META_GENRE_SPOKEN_WORD_TALK_SHOWS = 21, WPD_META_GENRE_GENERIC_VIDEO_FILE = 33, WPD_META_GENRE_NEWS_VIDEO_FILE = 34, WPD_META_GENRE_MUSIC_VIDEO_FILE = 35, WPD_META_GENRE_HOME_VIDEO_FILE = 36, WPD_META_GENRE_FEATURE_FILM_VIDEO_FILE = 37, WPD_META_GENRE_TELEVISION_VIDEO_FILE = 38, WPD_META_GENRE_TRAINING_EDUCATIONAL_VIDEO_FILE = 39, WPD_META_GENRE_PHOTO_MONTAGE_VIDEO_FILE = 40, WPD_META_GENRE_GENERIC_NON_AUDIO_NON_VIDEO = 48, WPD_META_GENRE_AUDIO_PODCAST = 64, WPD_META_GENRE_VIDEO_PODCAST = 65, WPD_META_GENRE_MIXED_PODCAST = 66 }; +enum tagWPD_CROPPED_STATUS_VALUES{ WPD_CROPPED_STATUS_NOT_CROPPED = 0, WPD_CROPPED_STATUS_CROPPED = 1, WPD_CROPPED_STATUS_SHOULD_NOT_BE_CROPPED = 2 }; +enum tagWPD_COLOR_CORRECTED_STATUS_VALUES{ WPD_COLOR_CORRECTED_STATUS_NOT_CORRECTED = 0, WPD_COLOR_CORRECTED_STATUS_CORRECTED = 1, WPD_COLOR_CORRECTED_STATUS_SHOULD_NOT_BE_CORRECTED = 2 }; +enum tagWPD_VIDEO_SCAN_TYPES{ WPD_VIDEO_SCAN_TYPE_UNUSED = 0, WPD_VIDEO_SCAN_TYPE_PROGRESSIVE = 1, WPD_VIDEO_SCAN_TYPE_FIELD_INTERLEAVED_UPPER_FIRST = 2, WPD_VIDEO_SCAN_TYPE_FIELD_INTERLEAVED_LOWER_FIRST = 3, WPD_VIDEO_SCAN_TYPE_FIELD_SINGLE_UPPER_FIRST = 4, WPD_VIDEO_SCAN_TYPE_FIELD_SINGLE_LOWER_FIRST = 5, WPD_VIDEO_SCAN_TYPE_MIXED_INTERLACE = 6, WPD_VIDEO_SCAN_TYPE_MIXED_INTERLACE_AND_PROGRESSIVE = 7 }; +enum tagWPD_OPERATION_STATES{ WPD_OPERATION_STATE_UNSPECIFIED = 0, WPD_OPERATION_STATE_STARTED = 1, WPD_OPERATION_STATE_RUNNING = 2, WPD_OPERATION_STATE_PAUSED = 3, WPD_OPERATION_STATE_CANCELLED = 4, WPD_OPERATION_STATE_FINISHED = 5, WPD_OPERATION_STATE_ABORTED = 6 }; +enum tagWPD_SECTION_DATA_UNITS_VALUES{ WPD_SECTION_DATA_UNITS_BYTES = 0, WPD_SECTION_DATA_UNITS_MILLISECONDS = 1 }; +enum tagWPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPES{ WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPE_OBJECT = 0, WPD_RENDERING_INFORMATION_PROFILE_ENTRY_TYPE_RESOURCE = 1 }; +enum tagWPD_COMMAND_ACCESS_TYPES{ WPD_COMMAND_ACCESS_READ = 1, WPD_COMMAND_ACCESS_READWRITE = 3, WPD_COMMAND_ACCESS_FROM_PROPERTY_WITH_STGM_ACCESS = 4, WPD_COMMAND_ACCESS_FROM_PROPERTY_WITH_FILE_ACCESS = 8, WPD_COMMAND_ACCESS_FROM_ATTRIBUTE_WITH_METHOD_ACCESS = 16 }; +enum tagWPD_SERVICE_INHERITANCE_TYPES{ WPD_SERVICE_INHERITANCE_IMPLEMENTATION = 0 }; +enum tagWPD_PARAMETER_USAGE_TYPES{ WPD_PARAMETER_USAGE_RETURN = 0, WPD_PARAMETER_USAGE_IN = 1, WPD_PARAMETER_USAGE_OUT = 2, WPD_PARAMETER_USAGE_INOUT = 3 }; +struct tagWPD_COMMAND_ACCESS_LOOKUP_ENTRY{ PROPERTYKEY Command; ULONG AccessType; PROPERTYKEY AccessProperty; }; +enum tagSHIMOPTS{ PTSHIM_DEFAULT = 0, PTSHIM_NOSNAPSHOT = 1 }; +enum tagPrintSchemaConstrainedSetting{ PrintSchemaConstrainedSetting_None = 0, PrintSchemaConstrainedSetting_PrintTicket = 1, PrintSchemaConstrainedSetting_Admin = 2, PrintSchemaConstrainedSetting_Device = 3 }; +enum tagPrintSchemaSelectionType{ PrintSchemaSelectionType_PickOne = 0, PrintSchemaSelectionType_PickMany = 1 }; +enum tagPrintSchemaParameterDataType{ PrintSchemaParameterDataType_Integer = 0, PrintSchemaParameterDataType_NumericString = 1, PrintSchemaParameterDataType_String = 2 }; +enum tagPrintJobStatus{ PrintJobStatus_Paused = 1, PrintJobStatus_Error = 2, PrintJobStatus_Deleting = 4, PrintJobStatus_Spooling = 8, PrintJobStatus_Printing = 16, PrintJobStatus_Offline = 32, PrintJobStatus_PaperOut = 64, PrintJobStatus_Printed = 128, PrintJobStatus_Deleted = 256, PrintJobStatus_BlockedDeviceQueue = 512, PrintJobStatus_UserIntervention = 1024, PrintJobStatus_Restarted = 2048, PrintJobStatus_Complete = 4096, PrintJobStatus_Retained = 8192 }; +enum tagEDefaultDevmodeType{ kUserDefaultDevmode = 0, kPrinterDefaultDevmode = 1 }; +struct tagRESTRICTION{ ULONG rt; ULONG weight; _URes res; }; +struct tagNOTRESTRICTION{ RESTRICTION* pRes; }; +struct tagNODERESTRICTION{ ULONG cRes; RESTRICTION** paRes; ULONG reserved; }; +struct tagVECTORRESTRICTION{ NODERESTRICTION Node; ULONG RankMethod; }; +struct tagCONTENTRESTRICTION{ FULLPROPSPEC prop; WCHAR* pwcsPhrase; LCID lcid; ULONG ulGenerateMethod; }; +struct tagNATLANGUAGERESTRICTION{ FULLPROPSPEC prop; WCHAR* pwcsPhrase; LCID lcid; }; +struct tagPROPERTYRESTRICTION{ ULONG rel; FULLPROPSPEC prop; PROPVARIANT prval; }; +struct tagCOLUMNSET{ ULONG cCol; FULLPROPSPEC* aCol; }; +struct tagSORTKEY{ FULLPROPSPEC propColumn; ULONG dwOrder; LCID locale; }; +struct tagSORTSET{ ULONG cCol; SORTKEY* aCol; }; +struct tagBUCKETCATEGORIZE{ ULONG cBuckets; ULONG Distribution; }; +struct tagRANGECATEGORIZE{ ULONG cRange; PROPVARIANT* aRangeBegin; }; +struct tagCATEGORIZATION{ ULONG ulCatType; COLUMNSET csColumns; }; +struct tagCATEGORIZATIONSET{ ULONG cCat; CATEGORIZATION* aCat; }; +struct tagRASNOUSERW{ ULONG dwSize; ULONG dwFlags; ULONG dwTimeoutMs; WCHAR szUserName[257]; WCHAR szPassword[257]; WCHAR szDomain[16]; }; +struct tagRASNOUSERA{ ULONG dwSize; ULONG dwFlags; ULONG dwTimeoutMs; CHAR szUserName[257]; CHAR szPassword[257]; CHAR szDomain[16]; }; +struct tagRASPBDLGW{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; ULONG_PTR dwCallbackId; RASPBDLGFUNCW pCallback; ULONG dwError; ULONG_PTR reserved; ULONG_PTR reserved2; }; +struct tagRASPBDLGA{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; ULONG_PTR dwCallbackId; RASPBDLGFUNCA pCallback; ULONG dwError; ULONG_PTR reserved; ULONG_PTR reserved2; }; +struct tagRASENTRYDLGW{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; WCHAR szEntry[257]; ULONG dwError; ULONG_PTR reserved; ULONG_PTR reserved2; }; +struct tagRASENTRYDLGA{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; CHAR szEntry[257]; ULONG dwError; ULONG_PTR reserved; ULONG_PTR reserved2; }; +struct tagRASDIALDLG{ ULONG dwSize; HWND hwndOwner; ULONG dwFlags; LONG xDlg; LONG yDlg; ULONG dwSubEntry; ULONG dwError; ULONG_PTR reserved; ULONG_PTR reserved2; }; +struct tagRECO_GUIDE{ int xOrigin; int yOrigin; int cxBox; int cyBox; int cxBase; int cyBase; int cHorzBox; int cVertBox; int cyMid; }; +struct tagRECO_ATTRS{ ULONG dwRecoCapabilityFlags; WCHAR awcVendorName[32]; WCHAR awcFriendlyName[64]; WORD awLanguageId[64]; }; +struct tagRECO_RANGE{ ULONG iwcBegin; ULONG cCount; }; +struct tagLINE_SEGMENT{ POINT PtA; POINT PtB; }; +struct tagLATTICE_METRICS{ LINE_SEGMENT lsBaseline; short iMidlineOffset; }; +struct tagRECO_LATTICE_PROPERTY{ GUID guidProperty; USHORT cbPropertyValue; UCHAR* pPropertyValue; }; +struct tagRECO_LATTICE_PROPERTIES{ ULONG cProperties; RECO_LATTICE_PROPERTY** apProps; }; +struct tagRECO_LATTICE_ELEMENT{ RECO_SCORE score; WORD type; UCHAR* pData; ULONG ulNextColumn; ULONG ulStrokeNumber; RECO_LATTICE_PROPERTIES epProp; }; +struct tagRECO_LATTICE_COLUMN{ ULONG key; RECO_LATTICE_PROPERTIES cpProp; ULONG cStrokes; ULONG* pStrokes; ULONG cLatticeElements; RECO_LATTICE_ELEMENT* pLatticeElements; }; +struct tagRECO_LATTICE{ ULONG ulColumnCount; RECO_LATTICE_COLUMN* pLatticeColumns; ULONG ulPropertyCount; GUID* pGuidProperties; ULONG ulBestResultColumnCount; ULONG* pulBestResultColumns; ULONG* pulBestResultIndexes; }; +struct tagCHARACTER_RANGE{ WCHAR wcLow; USHORT cChars; }; +enum tagTextMode{ TM_PLAINTEXT = 1, TM_RICHTEXT = 2, TM_SINGLELEVELUNDO = 4, TM_MULTILEVELUNDO = 8, TM_SINGLECODEPAGE = 16, TM_MULTICODEPAGE = 32 }; +struct tagRICHEDIT_IMAGE_PARAMETERS{ LONG xWidth; LONG yHeight; LONG Ascent; LONG Type; LPCWSTR pwszAlternateText; IStream* pIStream; }; +enum tagKHYPH{ khyphNil = 0, khyphNormal = 1, khyphAddBefore = 2, khyphChangeBefore = 3, khyphDeleteBefore = 4, khyphChangeAfter = 5, khyphDelAndChange = 6 }; +struct tagHyphenateInfo{ SHORT cbSize; SHORT dxHyphenateZone; }; +struct tagRIMDEVCHANGECALLBACK{ HANDLE hRim; HANDLE hRimDev; ULONG dwCode; ULONG dwDeviceType; ULONG dwRimInputType; USHORT usage; USHORT usagePage; PVOID pContext; }; +enum tagRIMOBSERVERMESSAGETYPE{ RIMMSG_DATA = 0, RIMMSG_ERR = 1, RIMMSG_MAX = 1 }; +enum tagRIMOBSERVERERRORCODE{ RIMERR_BUFFER_TOO_SMALL = 0, RIMERR_INPUT_INTERCEPTED = 1, RIMERR_DROPPED_INPUT = 2, RIMERR_MAX = 2 }; +struct tagRIMOBSERVERMESSAGE{ RIMOBSERVERMESSAGETYPE type; }; +struct tagPOINTEREVENTINT{ WORD wCursorId; USHORT usLinkCollectionIndex; POINTERINFOUNION Info; BOOL bMobileTestSyncFlag; BOOL bMobileTestInjectFlag; GUID ProprietaryId; BOOL bSkipActivation; BOOL bTouchpadShellGesture; }; +struct tagRIMPOINTERINFONODE{ ULONG dwRawDataIndex; POINTEREVENTINT PointerEventInt; }; +struct tagRIMPOINTERRAWDATA{ ULONG dwIndex; ULONG cbRawData; PBYTE pRawData; tagRIMPOINTERRAWDATA* pNextRawData; }; +struct tagTELEMETRY_POINTER_FRAME_TIMES{ UINT64 qpcRimFrameStart; UINT64 qpcRimFrameQueued; UINT64 qpcRimSignalReadComplete; UINT64 qpcInputProcessorStart; UINT64 qpcIsmSend; UINT64 qpcGestureTargetingSend; UINT64 qpcGenerateMessages; UINT64 qpcAppInputRetrieve; 55584542626672474A4B78426173614669545A474A754C2B52466F3D vail; }; +struct tagRTWQASYNCRESULT{ OVERLAPPED overlapped; IRtwqAsyncCallback* pCallback; HRESULT hrStatusResult; ULONG dwBytesTransferred; HANDLE hEvent; }; +struct tagSPTEXTSELECTIONINFO{ ULONG ulStartActiveOffset; ULONG cchActiveChars; ULONG ulStartSelection; ULONG cchSelection; }; +struct tagSPPROPERTYINFO{ LPCWSTR pszName; ULONG ulId; LPCWSTR pszValue; VARIANT vValue; }; +struct tagSPPHRASEALT{ ISpPhraseBuilder* pPhrase; ULONG ulStartElementInParent; ULONG cElementsInParent; ULONG cElementsInAlternate; void* pvAltExtra; ULONG cbAltExtra; }; +struct tagSPPHRASEALTREQUEST{ ULONG ulStartElement; ULONG cElements; ULONG ulRequestAltCount; void* pvResultExtra; ULONG cbResultExtra; ISpPhrase* pPhrase; ISpRecoContext* pRecoContext; }; +enum tagSTRUCTURED_QUERY_SYNTAX{ SQS_NO_SYNTAX = 0, SQS_ADVANCED_QUERY_SYNTAX = 1, SQS_NATURAL_QUERY_SYNTAX = 2 }; +enum tagSTRUCTURED_QUERY_SINGLE_OPTION{ SQSO_SCHEMA = 0, SQSO_LOCALE_WORD_BREAKING = 1, SQSO_WORD_BREAKER = 2, SQSO_NATURAL_SYNTAX = 3, SQSO_AUTOMATIC_WILDCARD = 4, SQSO_TRACE_LEVEL = 5, SQSO_LANGUAGE_KEYWORDS = 6, SQSO_SYNTAX = 7, SQSO_TIME_ZONE = 8, SQSO_IMPLICIT_CONNECTOR = 9, SQSO_CONNECTOR_CASE = 10 }; +enum tagSTRUCTURED_QUERY_MULTIOPTION{ SQMO_VIRTUAL_PROPERTY = 0, SQMO_DEFAULT_PROPERTY = 1, SQMO_GENERATOR_FOR_TYPE = 2, SQMO_MAP_PROPERTY = 3 }; +enum tagSTRUCTURED_QUERY_PARSE_ERROR{ SQPE_NONE = 0, SQPE_EXTRA_OPENING_PARENTHESIS = 1, SQPE_EXTRA_CLOSING_PARENTHESIS = 2, SQPE_IGNORED_MODIFIER = 3, SQPE_IGNORED_CONNECTOR = 4, SQPE_IGNORED_KEYWORD = 5, SQPE_UNHANDLED = 6 }; +enum tagINTERVAL_LIMIT_KIND{ ILK_EXPLICIT_INCLUDED = 0, ILK_EXPLICIT_EXCLUDED = 1, ILK_NEGATIVE_INFINITY = 2, ILK_POSITIVE_INFINITY = 3 }; +enum tagQUERY_PARSER_MANAGER_OPTION{ QPMO_SCHEMA_BINARY_NAME = 0, QPMO_PRELOCALIZED_SCHEMA_BINARY_PATH = 1, QPMO_UNLOCALIZED_SCHEMA_BINARY_PATH = 2, QPMO_LOCALIZED_SCHEMA_BINARY_PATH = 3, QPMO_APPEND_LCID_TO_LOCALIZED_PATH = 4, QPMO_LOCALIZER_SUPPORT = 5 }; +struct tagHITRANGE{ ULONG iPosition; ULONG cLength; }; +enum tagPRIORITIZE_FLAGS{ PRIORITIZE_FLAG_RETRYFAILEDITEMS = 1, PRIORITIZE_FLAG_IGNOREFAILURECOUNT = 2 }; +struct tagQOCINFO{ ULONG dwSize; ULONG dwFlags; ULONG dwInSpeed; ULONG dwOutSpeed; }; +enum _tagAppInfoFlags{ AIM_DISPLAYNAME = 1, AIM_VERSION = 2, AIM_PUBLISHER = 4, AIM_PRODUCTID = 8, AIM_REGISTEREDOWNER = 16, AIM_REGISTEREDCOMPANY = 32, AIM_LANGUAGE = 64, AIM_SUPPORTURL = 128, AIM_SUPPORTTELEPHONE = 256, AIM_HELPLINK = 512, AIM_INSTALLLOCATION = 1024, AIM_INSTALLSOURCE = 2048, AIM_INSTALLDATE = 4096, AIM_CONTACT = 16384, AIM_COMMENTS = 32768, AIM_IMAGE = 131072, AIM_READMEURL = 262144, AIM_UPDATEINFOURL = 524288 }; +enum _tagAppActionFlags{ APPACTION_INSTALL = 1, APPACTION_UNINSTALL = 2, APPACTION_MODIFY = 4, APPACTION_REPAIR = 8, APPACTION_UPGRADE = 16, APPACTION_CANGETSIZE = 32, APPACTION_MODIFYREMOVE = 128, APPACTION_ADDLATER = 256, APPACTION_UNSCHEDULE = 512 }; +struct _tagSlowAppInfo{ ULONGLONG ullSize; FILETIME ftLastUsed; int iTimesUsed; LPWSTR pszImage; }; +enum _tagPublishedAppInfoFlags{ PAI_SOURCE = 1, PAI_ASSIGNEDTIME = 2, PAI_PUBLISHEDTIME = 4, PAI_SCHEDULEDTIME = 8, PAI_EXPIRETIME = 16 }; +enum tagTLENUMF{ TLEF_RELATIVE_INCLUDE_CURRENT = 1, TLEF_RELATIVE_BACK = 16, TLEF_RELATIVE_FORE = 32, TLEF_INCLUDE_UNINVOKEABLE = 64, TLEF_ABSOLUTE = 49, TLEF_EXCLUDE_SUBFRAME_ENTRIES = 128, TLEF_EXCLUDE_ABOUT_PAGES = 256 }; +enum tagBNSTATE{ BNS_NORMAL = 0, BNS_BEGIN_NAVIGATE = 1, BNS_NAVIGATE = 2 }; +struct tagFolderSetData{ FOLDERSETTINGS _fs; SHELLVIEWID _vidRestore; ULONG _dwViewPriority; }; +enum _tagAUTOCOMPLETEOPTIONS{ ACO_NONE = 0, ACO_AUTOSUGGEST = 1, ACO_AUTOAPPEND = 2, ACO_SEARCH = 4, ACO_FILTERPREFIXES = 8, ACO_USETAB = 16, ACO_UPDOWNKEYDROPSLIST = 32, ACO_RTLREADING = 64, ACO_WORD_FILTER = 128, ACO_NOPREFIXFILTERING = 256 }; +enum _tagACENUMOPTION{ ACEO_NONE = 0, ACEO_MOSTRECENTFIRST = 1, ACEO_FIRSTUNUSED = 65536 }; +struct tagDATABLOCKHEADER{ ULONG cbSize; ULONG dwSignature; }; +enum _tagAUTOCOMPLETELISTOPTIONS{ ACLO_NONE = 0, ACLO_CURRENTDIR = 1, ACLO_MYCOMPUTER = 2, ACLO_DESKTOP = 4, ACLO_FAVORITES = 8, ACLO_FILESYSONLY = 16, ACLO_FILESYSDIRS = 32, ACLO_VIRTUALNAMESPACE = 64 }; +enum tagOPEN_AS_INFO_FLAGS{ OAIF_ALLOW_REGISTRATION = 1, OAIF_REGISTER_EXT = 2, OAIF_EXEC = 4, OAIF_FORCE_REGISTRATION = 8, OAIF_HIDE_REGISTRATION = 32, OAIF_URL_PROTOCOL = 64, OAIF_FILE_IS_URI = 128 }; +enum tagIESHORTCUTFLAGS{ IESHORTCUT_NEWBROWSER = 1, IESHORTCUT_OPENNEWTAB = 2, IESHORTCUT_FORCENAVIGATE = 4, IESHORTCUT_BACKGROUNDTAB = 8 }; +struct tagAAMENUFILENAME{ SHORT cbTotal; UCHAR rgbReserved[12]; WCHAR szFileName[1]; }; +struct tagAASHELLMENUITEM{ void* lpReserved1; int iReserved; UINT uiReserved; LPAASHELLMENUFILENAME lpName; LPWSTR psz; }; +enum _tagSLDATATYPE{ SL_DATA_NONE = 0, SL_DATA_SZ = 1, SL_DATA_DWORD = 4, SL_DATA_BINARY = 3, SL_DATA_MULTI_SZ = 7, SL_DATA_SUM = 100 }; +enum _tagSLIDTYPE{ SL_ID_APPLICATION = 0, SL_ID_PRODUCT_SKU = 1, SL_ID_LICENSE_FILE = 2, SL_ID_LICENSE = 3, SL_ID_PKEY = 4, SL_ID_ALL_LICENSES = 5, SL_ID_ALL_LICENSE_FILES = 6, SL_ID_STORE_TOKEN = 7, SL_ID_LAST = 8 }; +enum _tagSLLICENSINGSTATUS{ SL_LICENSING_STATUS_UNLICENSED = 0, SL_LICENSING_STATUS_LICENSED = 1, SL_LICENSING_STATUS_IN_GRACE_PERIOD = 2, SL_LICENSING_STATUS_NOTIFICATION = 3, SL_LICENSING_STATUS_LAST = 4 }; +struct _tagSL_LICENSING_STATUS{ SLID SkuId; SLLICENSINGSTATUS eStatus; ULONG dwGraceTime; ULONG dwTotalGraceDays; HRESULT hrReason; UINT64 qwValidityExpiration; }; +enum _tagSL_ACTIVATION_TYPE{ SL_ACTIVATION_TYPE_DEFAULT = 0, SL_ACTIVATION_TYPE_ACTIVE_DIRECTORY = 1 }; +struct _tagSL_ACTIVATION_INFO_HEADER{ ULONG cbSize; SL_ACTIVATION_TYPE type; }; +struct _tagSL_AD_ACTIVATION_INFO{ SL_ACTIVATION_INFO_HEADER header; PCWSTR pwszProductKey; PCWSTR pwszActivationObjectName; }; +struct _tagSL_NONGENUINE_UI_OPTIONS{ ULONG cbSize; SLID* pComponentId; HRESULT hResultUI; }; +enum tagDOCHOSTUIDBLCLKDispatch{ docHostUIDblClkDEFAULT = 0, docHostUIDblClkSHOWPROPERTIES = 1, docHostUIDblClkSHOWCODE = 2 }; +enum tagDocHostUIFlagDispatch{ docHostUIFlagDIALOG = 1, docHostUIFlagDISABLE_HELP_MENU = 2, docHostUIFlagNO3DBORDER = 4, docHostUIFlagSCROLL_NO = 8, docHostUIFlagDISABLE_SCRIPT_INACTIVE = 16, docHostUIFlagOPENNEWWIN = 32, docHostUIFlagDISABLE_OFFSCREEN = 64, docHostUIFlagFLAT_SCROLLBAR = 128, docHostUIFlagDIV_BLOCKDEFAULT = 256, docHostUIFlagACTIVATE_CLIENTHIT_ONLY = 512 }; +struct tagODBC_VS_ARGS{ GUID* pguidEvent; ULONG dwFlags; int RetCode; }; +struct tagSSErrorInfo{ LPOLESTR pwszMessage; LPOLESTR pwszServer; LPOLESTR pwszProcedure; LONG lNative; UCHAR bState; UCHAR bClass; WORD wLineNumber; }; +struct _tagITEMPROP{ VARIANT variantValue; LPWSTR pwszName; }; +struct tagSUBSCRIPTIONITEMINFO{ ULONG cbSize; ULONG dwFlags; ULONG dwPriority; SUBSCRIPTIONCOOKIE ScheduleGroup; CLSID clsidAgent; }; +struct _tagSubscriptionInfo{ ULONG cbSize; ULONG fUpdateFlags; SUBSCRIPTIONSCHEDULE schedule; CLSID customGroupCookie; LPVOID pTrigger; ULONG dwRecurseLevels; ULONG fWebcrawlerFlags; BOOL bMailNotification; BOOL bGleam; BOOL bChangesOnly; BOOL bNeedPassword; ULONG fChannelFlags; BSTR bstrUserName; BSTR bstrPassword; BSTR bstrFriendlyName; ULONG dwMaxSizeKB; SUBSCRIPTIONTYPE subType; ULONG fTaskFlags; ULONG dwReserved; }; +struct lineaddresscaps_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwLineDeviceID; ULONG dwAddressSize; ULONG dwAddressOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwAddressSharing; ULONG dwAddressStates; ULONG dwCallInfoStates; ULONG dwCallerIDFlags; ULONG dwCalledIDFlags; ULONG dwConnectedIDFlags; ULONG dwRedirectionIDFlags; ULONG dwRedirectingIDFlags; ULONG dwCallStates; ULONG dwDialToneModes; ULONG dwBusyModes; ULONG dwSpecialInfo; ULONG dwDisconnectModes; ULONG dwMaxNumActiveCalls; ULONG dwMaxNumOnHoldCalls; ULONG dwMaxNumOnHoldPendingCalls; ULONG dwMaxNumConference; ULONG dwMaxNumTransConf; ULONG dwAddrCapFlags; ULONG dwCallFeatures; ULONG dwRemoveFromConfCaps; ULONG dwRemoveFromConfState; ULONG dwTransferModes; ULONG dwParkModes; ULONG dwForwardModes; ULONG dwMaxForwardEntries; ULONG dwMaxSpecificEntries; ULONG dwMinFwdNumRings; ULONG dwMaxFwdNumRings; ULONG dwMaxCallCompletions; ULONG dwCallCompletionConds; ULONG dwCallCompletionModes; ULONG dwNumCompletionMessages; ULONG dwCompletionMsgTextEntrySize; ULONG dwCompletionMsgTextSize; ULONG dwCompletionMsgTextOffset; ULONG dwAddressFeatures; ULONG dwPredictiveAutoTransferStates; ULONG dwNumCallTreatments; ULONG dwCallTreatmentListSize; ULONG dwCallTreatmentListOffset; ULONG dwDeviceClassesSize; ULONG dwDeviceClassesOffset; ULONG dwMaxCallDataSize; ULONG dwCallFeatures2; ULONG dwMaxNoAnswerTimeout; ULONG dwConnectedModes; ULONG dwOfferingModes; ULONG dwAvailableMediaModes; }; +struct lineaddressstatus_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumInUse; ULONG dwNumActiveCalls; ULONG dwNumOnHoldCalls; ULONG dwNumOnHoldPendCalls; ULONG dwAddressFeatures; ULONG dwNumRingsNoAnswer; ULONG dwForwardNumEntries; ULONG dwForwardSize; ULONG dwForwardOffset; ULONG dwTerminalModesSize; ULONG dwTerminalModesOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; }; +struct lineagentactivityentry_tag{ ULONG dwID; ULONG dwNameSize; ULONG dwNameOffset; }; +struct lineagentactivitylist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct lineagentcaps_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwAgentHandlerInfoSize; ULONG dwAgentHandlerInfoOffset; ULONG dwCapsVersion; ULONG dwFeatures; ULONG dwStates; ULONG dwNextStates; ULONG dwMaxNumGroupEntries; ULONG dwAgentStatusMessages; ULONG dwNumAgentExtensionIDs; ULONG dwAgentExtensionIDListSize; ULONG dwAgentExtensionIDListOffset; GUID ProxyGUID; }; +struct lineagentgroupentry_tag{ 61667A65686C496570424D45445039724F755767325074364B37633D GroupID; ULONG dwNameSize; ULONG dwNameOffset; }; +struct lineagentgrouplist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct lineagentstatus_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwGroupListSize; ULONG dwGroupListOffset; ULONG dwState; ULONG dwNextState; ULONG dwActivityID; ULONG dwActivitySize; ULONG dwActivityOffset; ULONG dwAgentFeatures; ULONG dwValidStates; ULONG dwValidNextStates; }; +struct lineappinfo_tag{ ULONG dwMachineNameSize; ULONG dwMachineNameOffset; ULONG dwUserNameSize; ULONG dwUserNameOffset; ULONG dwModuleFilenameSize; ULONG dwModuleFilenameOffset; ULONG dwFriendlyNameSize; ULONG dwFriendlyNameOffset; ULONG dwMediaModes; ULONG dwAddressID; }; +struct lineagententry_tag{ HAGENT hAgent; ULONG dwNameSize; ULONG dwNameOffset; ULONG dwIDSize; ULONG dwIDOffset; ULONG dwPINSize; ULONG dwPINOffset; }; +struct lineagentlist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct lineagentinfo_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwAgentState; ULONG dwNextAgentState; ULONG dwMeasurementPeriod; CURRENCY cyOverallCallRate; ULONG dwNumberOfACDCalls; ULONG dwNumberOfIncomingCalls; ULONG dwNumberOfOutgoingCalls; ULONG dwTotalACDTalkTime; ULONG dwTotalACDCallTime; ULONG dwTotalACDWrapUpTime; }; +struct lineagentsession_tag{ HAGENTSESSION hAgentSession; HAGENT hAgent; GUID GroupID; ULONG dwWorkingAddressID; }; +struct lineagentsessionlist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct lineagentsessioninfo_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwAgentSessionState; ULONG dwNextAgentSessionState; DATE dateSessionStartTime; ULONG dwSessionDuration; ULONG dwNumberOfCalls; ULONG dwTotalTalkTime; ULONG dwAverageTalkTime; ULONG dwTotalCallTime; ULONG dwAverageCallTime; ULONG dwTotalWrapUpTime; ULONG dwAverageWrapUpTime; CURRENCY cyACDCallRate; ULONG dwLongestTimeToAnswer; ULONG dwAverageTimeToAnswer; }; +struct linequeueentry_tag{ ULONG dwQueueID; ULONG dwNameSize; ULONG dwNameOffset; }; +struct linequeuelist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct linequeueinfo_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwMeasurementPeriod; ULONG dwTotalCallsQueued; ULONG dwCurrentCallsQueued; ULONG dwTotalCallsAbandoned; ULONG dwTotalCallsFlowedIn; ULONG dwTotalCallsFlowedOut; ULONG dwLongestEverWaitTime; ULONG dwCurrentLongestWaitTime; ULONG dwAverageWaitTime; ULONG dwFinalDisposition; }; +struct lineproxyrequestlist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumEntries; ULONG dwListSize; ULONG dwListOffset; }; +struct linedialparams_tag{ ULONG dwDialPause; ULONG dwDialSpeed; ULONG dwDigitDuration; ULONG dwWaitForDialtone; }; +struct linecallinfo_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; HLINE hLine; ULONG dwLineDeviceID; ULONG dwAddressID; ULONG dwBearerMode; ULONG dwRate; ULONG dwMediaMode; ULONG dwAppSpecific; ULONG dwCallID; ULONG dwRelatedCallID; ULONG dwCallParamFlags; ULONG dwCallStates; ULONG dwMonitorDigitModes; ULONG dwMonitorMediaModes; LINEDIALPARAMS DialParams; ULONG dwOrigin; ULONG dwReason; ULONG dwCompletionID; ULONG dwNumOwners; ULONG dwNumMonitors; ULONG dwCountryCode; ULONG dwTrunk; ULONG dwCallerIDFlags; ULONG dwCallerIDSize; ULONG dwCallerIDOffset; ULONG dwCallerIDNameSize; ULONG dwCallerIDNameOffset; ULONG dwCalledIDFlags; ULONG dwCalledIDSize; ULONG dwCalledIDOffset; ULONG dwCalledIDNameSize; ULONG dwCalledIDNameOffset; ULONG dwConnectedIDFlags; ULONG dwConnectedIDSize; ULONG dwConnectedIDOffset; ULONG dwConnectedIDNameSize; ULONG dwConnectedIDNameOffset; ULONG dwRedirectionIDFlags; ULONG dwRedirectionIDSize; ULONG dwRedirectionIDOffset; ULONG dwRedirectionIDNameSize; ULONG dwRedirectionIDNameOffset; ULONG dwRedirectingIDFlags; ULONG dwRedirectingIDSize; ULONG dwRedirectingIDOffset; ULONG dwRedirectingIDNameSize; ULONG dwRedirectingIDNameOffset; ULONG dwAppNameSize; ULONG dwAppNameOffset; ULONG dwDisplayableAddressSize; ULONG dwDisplayableAddressOffset; ULONG dwCalledPartySize; ULONG dwCalledPartyOffset; ULONG dwCommentSize; ULONG dwCommentOffset; ULONG dwDisplaySize; ULONG dwDisplayOffset; ULONG dwUserUserInfoSize; ULONG dwUserUserInfoOffset; ULONG dwHighLevelCompSize; ULONG dwHighLevelCompOffset; ULONG dwLowLevelCompSize; }; +struct linecalllist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwCallsNumEntries; ULONG dwCallsSize; ULONG dwCallsOffset; }; +struct linecallparams_tag{ ULONG dwTotalSize; ULONG dwBearerMode; ULONG dwMinRate; ULONG dwMaxRate; ULONG dwMediaMode; ULONG dwCallParamFlags; ULONG dwAddressMode; ULONG dwAddressID; LINEDIALPARAMS DialParams; ULONG dwOrigAddressSize; ULONG dwOrigAddressOffset; ULONG dwDisplayableAddressSize; ULONG dwDisplayableAddressOffset; ULONG dwCalledPartySize; ULONG dwCalledPartyOffset; ULONG dwCommentSize; ULONG dwCommentOffset; ULONG dwUserUserInfoSize; ULONG dwUserUserInfoOffset; ULONG dwHighLevelCompSize; ULONG dwHighLevelCompOffset; ULONG dwLowLevelCompSize; ULONG dwLowLevelCompOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwPredictiveAutoTransferStates; ULONG dwTargetAddressSize; ULONG dwTargetAddressOffset; ULONG dwSendingFlowspecSize; ULONG dwSendingFlowspecOffset; ULONG dwReceivingFlowspecSize; ULONG dwReceivingFlowspecOffset; ULONG dwDeviceClassSize; ULONG dwDeviceClassOffset; ULONG dwDeviceConfigSize; ULONG dwDeviceConfigOffset; ULONG dwCallDataSize; ULONG dwCallDataOffset; ULONG dwNoAnswerTimeout; ULONG dwCallingPartyIDSize; ULONG dwCallingPartyIDOffset; }; +struct linecallstatus_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwCallState; ULONG dwCallStateMode; ULONG dwCallPrivilege; ULONG dwCallFeatures; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwCallFeatures2; WORD tStateEntryTime[8]; }; +struct linecalltreatmententry_tag{ ULONG dwCallTreatmentID; ULONG dwCallTreatmentNameSize; ULONG dwCallTreatmentNameOffset; }; +struct linecardentry_tag{ ULONG dwPermanentCardID; ULONG dwCardNameSize; ULONG dwCardNameOffset; ULONG dwCardNumberDigits; ULONG dwSameAreaRuleSize; ULONG dwSameAreaRuleOffset; ULONG dwLongDistanceRuleSize; ULONG dwLongDistanceRuleOffset; ULONG dwInternationalRuleSize; ULONG dwInternationalRuleOffset; ULONG dwOptions; }; +struct linecountryentry_tag{ ULONG dwCountryID; ULONG dwCountryCode; ULONG dwNextCountryID; ULONG dwCountryNameSize; ULONG dwCountryNameOffset; ULONG dwSameAreaRuleSize; ULONG dwSameAreaRuleOffset; ULONG dwLongDistanceRuleSize; ULONG dwLongDistanceRuleOffset; ULONG dwInternationalRuleSize; ULONG dwInternationalRuleOffset; }; +struct linecountrylist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumCountries; ULONG dwCountryListSize; ULONG dwCountryListOffset; }; +struct linedevcaps_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwProviderInfoSize; ULONG dwProviderInfoOffset; ULONG dwSwitchInfoSize; ULONG dwSwitchInfoOffset; ULONG dwPermanentLineID; ULONG dwLineNameSize; ULONG dwLineNameOffset; ULONG dwStringFormat; ULONG dwAddressModes; ULONG dwNumAddresses; ULONG dwBearerModes; ULONG dwMaxRate; ULONG dwMediaModes; ULONG dwGenerateToneModes; ULONG dwGenerateToneMaxNumFreq; ULONG dwGenerateDigitModes; ULONG dwMonitorToneMaxNumFreq; ULONG dwMonitorToneMaxNumEntries; ULONG dwMonitorDigitModes; ULONG dwGatherDigitsMinTimeout; ULONG dwGatherDigitsMaxTimeout; ULONG dwMedCtlDigitMaxListSize; ULONG dwMedCtlMediaMaxListSize; ULONG dwMedCtlToneMaxListSize; ULONG dwMedCtlCallStateMaxListSize; ULONG dwDevCapFlags; ULONG dwMaxNumActiveCalls; ULONG dwAnswerMode; ULONG dwRingModes; ULONG dwLineStates; ULONG dwUUIAcceptSize; ULONG dwUUIAnswerSize; ULONG dwUUIMakeCallSize; ULONG dwUUIDropSize; ULONG dwUUISendUserUserInfoSize; ULONG dwUUICallInfoSize; LINEDIALPARAMS MinDialParams; LINEDIALPARAMS MaxDialParams; LINEDIALPARAMS DefaultDialParams; ULONG dwNumTerminals; ULONG dwTerminalCapsSize; ULONG dwTerminalCapsOffset; ULONG dwTerminalTextEntrySize; ULONG dwTerminalTextSize; ULONG dwTerminalTextOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwLineFeatures; ULONG dwSettableDevStatus; ULONG dwDeviceClassesSize; ULONG dwDeviceClassesOffset; GUID PermanentLineGuid; }; +struct linedevstatus_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumOpens; ULONG dwOpenMediaModes; ULONG dwNumActiveCalls; ULONG dwNumOnHoldCalls; ULONG dwNumOnHoldPendCalls; ULONG dwLineFeatures; ULONG dwNumCallCompletions; ULONG dwRingMode; ULONG dwSignalLevel; ULONG dwBatteryLevel; ULONG dwRoamMode; ULONG dwDevStatusFlags; ULONG dwTerminalModesSize; ULONG dwTerminalModesOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwAvailableMediaModes; ULONG dwAppInfoSize; ULONG dwAppInfoOffset; }; +struct lineextensionid_tag{ ULONG dwExtensionID0; ULONG dwExtensionID1; ULONG dwExtensionID2; ULONG dwExtensionID3; }; +struct lineforward_tag{ ULONG dwForwardMode; ULONG dwCallerAddressSize; ULONG dwCallerAddressOffset; ULONG dwDestCountryCode; ULONG dwDestAddressSize; ULONG dwDestAddressOffset; }; +struct lineforwardlist_tag{ ULONG dwTotalSize; ULONG dwNumEntries; LINEFORWARD ForwardList[1]; }; +struct linegeneratetone_tag{ ULONG dwFrequency; ULONG dwCadenceOn; ULONG dwCadenceOff; ULONG dwVolume; }; +struct lineinitializeexparams_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwOptions; 4E5374477A65303852583644444747436C7955467964584E7469733D Handles; ULONG dwCompletionKey; }; +struct linelocationentry_tag{ ULONG dwPermanentLocationID; ULONG dwLocationNameSize; ULONG dwLocationNameOffset; ULONG dwCountryCode; ULONG dwCityCodeSize; ULONG dwCityCodeOffset; ULONG dwPreferredCardID; ULONG dwLocalAccessCodeSize; ULONG dwLocalAccessCodeOffset; ULONG dwLongDistanceAccessCodeSize; ULONG dwLongDistanceAccessCodeOffset; ULONG dwTollPrefixListSize; ULONG dwTollPrefixListOffset; ULONG dwCountryID; ULONG dwOptions; ULONG dwCancelCallWaitingSize; ULONG dwCancelCallWaitingOffset; }; +struct linemediacontrolcallstate_tag{ ULONG dwCallStates; ULONG dwMediaControl; }; +struct linemediacontroldigit_tag{ ULONG dwDigit; ULONG dwDigitModes; ULONG dwMediaControl; }; +struct linemediacontrolmedia_tag{ ULONG dwMediaModes; ULONG dwDuration; ULONG dwMediaControl; }; +struct linemediacontroltone_tag{ ULONG dwAppSpecific; ULONG dwDuration; ULONG dwFrequency1; ULONG dwFrequency2; ULONG dwFrequency3; ULONG dwMediaControl; }; +struct linemessage_tag{ ULONG hDevice; ULONG dwMessageID; DWORD_PTR dwCallbackInstance; DWORD_PTR dwParam1; DWORD_PTR dwParam2; DWORD_PTR dwParam3; }; +struct linemonitortone_tag{ ULONG dwAppSpecific; ULONG dwDuration; ULONG dwFrequency1; ULONG dwFrequency2; ULONG dwFrequency3; }; +struct lineproviderentry_tag{ ULONG dwPermanentProviderID; ULONG dwProviderFilenameSize; ULONG dwProviderFilenameOffset; }; +struct lineproviderlist_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumProviders; ULONG dwProviderListSize; ULONG dwProviderListOffset; }; +struct lineproxyrequest_tag{ ULONG dwSize; ULONG dwClientMachineNameSize; ULONG dwClientMachineNameOffset; ULONG dwClientUserNameSize; ULONG dwClientUserNameOffset; ULONG dwClientAppAPIVersion; ULONG dwRequestType; }; +struct linereqmakecall_tag{ char szDestAddress[80]; char szAppName[40]; char szCalledParty[40]; char szComment[80]; }; +struct linereqmakecallW_tag{ WCHAR szDestAddress[80]; WCHAR szAppName[40]; WCHAR szCalledParty[40]; WCHAR szComment[80]; }; +struct linereqmediacall_tag{ HWND hWnd; WPARAM wRequestID; char szDeviceClass[40]; unsigned char ucDeviceID[40]; ULONG dwSize; ULONG dwSecure; char szDestAddress[80]; char szAppName[40]; char szCalledParty[40]; char szComment[80]; }; +struct linereqmediacallW_tag{ HWND hWnd; WPARAM wRequestID; WCHAR szDeviceClass[40]; unsigned char ucDeviceID[40]; ULONG dwSize; ULONG dwSecure; WCHAR szDestAddress[80]; WCHAR szAppName[40]; WCHAR szCalledParty[40]; WCHAR szComment[80]; }; +struct linetermcaps_tag{ ULONG dwTermDev; ULONG dwTermModes; ULONG dwTermSharing; }; +struct linetranslatecaps_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwNumLocations; ULONG dwLocationListSize; ULONG dwLocationListOffset; ULONG dwCurrentLocationID; ULONG dwNumCards; ULONG dwCardListSize; ULONG dwCardListOffset; ULONG dwCurrentPreferredCardID; }; +struct linetranslateoutput_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwDialableStringSize; ULONG dwDialableStringOffset; ULONG dwDisplayableStringSize; ULONG dwDisplayableStringOffset; ULONG dwCurrentCountry; ULONG dwDestCountry; ULONG dwTranslateResults; }; +struct phonebuttoninfo_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwButtonMode; ULONG dwButtonFunction; ULONG dwButtonTextSize; ULONG dwButtonTextOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwButtonState; }; +struct phonecaps_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwProviderInfoSize; ULONG dwProviderInfoOffset; ULONG dwPhoneInfoSize; ULONG dwPhoneInfoOffset; ULONG dwPermanentPhoneID; ULONG dwPhoneNameSize; ULONG dwPhoneNameOffset; ULONG dwStringFormat; ULONG dwPhoneStates; ULONG dwHookSwitchDevs; ULONG dwHandsetHookSwitchModes; ULONG dwSpeakerHookSwitchModes; ULONG dwHeadsetHookSwitchModes; ULONG dwVolumeFlags; ULONG dwGainFlags; ULONG dwDisplayNumRows; ULONG dwDisplayNumColumns; ULONG dwNumRingModes; ULONG dwNumButtonLamps; ULONG dwButtonModesSize; ULONG dwButtonModesOffset; ULONG dwButtonFunctionsSize; ULONG dwButtonFunctionsOffset; ULONG dwLampModesSize; ULONG dwLampModesOffset; ULONG dwNumSetData; ULONG dwSetDataSize; ULONG dwSetDataOffset; ULONG dwNumGetData; ULONG dwGetDataSize; ULONG dwGetDataOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwDeviceClassesSize; ULONG dwDeviceClassesOffset; ULONG dwPhoneFeatures; ULONG dwSettableHandsetHookSwitchModes; ULONG dwSettableSpeakerHookSwitchModes; ULONG dwSettableHeadsetHookSwitchModes; ULONG dwMonitoredHandsetHookSwitchModes; ULONG dwMonitoredSpeakerHookSwitchModes; ULONG dwMonitoredHeadsetHookSwitchModes; GUID PermanentPhoneGuid; }; +struct phoneextensionid_tag{ ULONG dwExtensionID0; ULONG dwExtensionID1; ULONG dwExtensionID2; ULONG dwExtensionID3; }; +struct phoneinitializeexparams_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwOptions; 77526E61536869643167534437374A394B6B2B717A4D712F7732413D Handles; ULONG dwCompletionKey; }; +struct phonemessage_tag{ ULONG hDevice; ULONG dwMessageID; DWORD_PTR dwCallbackInstance; DWORD_PTR dwParam1; DWORD_PTR dwParam2; DWORD_PTR dwParam3; }; +struct phonestatus_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwStatusFlags; ULONG dwNumOwners; ULONG dwNumMonitors; ULONG dwRingMode; ULONG dwRingVolume; ULONG dwHandsetHookSwitchMode; ULONG dwHandsetVolume; ULONG dwHandsetGain; ULONG dwSpeakerHookSwitchMode; ULONG dwSpeakerVolume; ULONG dwSpeakerGain; ULONG dwHeadsetHookSwitchMode; ULONG dwHeadsetVolume; ULONG dwHeadsetGain; ULONG dwDisplaySize; ULONG dwDisplayOffset; ULONG dwLampModesSize; ULONG dwLampModesOffset; ULONG dwOwnerNameSize; ULONG dwOwnerNameOffset; ULONG dwDevSpecificSize; ULONG dwDevSpecificOffset; ULONG dwPhoneFeatures; }; +struct varstring_tag{ ULONG dwTotalSize; ULONG dwNeededSize; ULONG dwUsedSize; ULONG dwStringFormat; ULONG dwStringSize; ULONG dwStringOffset; }; +struct tagHEAPLIST32{ SIZE_T dwSize; ULONG th32ProcessID; ULONG_PTR th32HeapID; ULONG dwFlags; }; +struct tagHEAPENTRY32{ SIZE_T dwSize; HANDLE hHandle; ULONG_PTR dwAddress; SIZE_T dwBlockSize; ULONG dwFlags; ULONG dwLockCount; ULONG dwResvd; ULONG th32ProcessID; ULONG_PTR th32HeapID; }; +struct tagPROCESSENTRY32W{ ULONG dwSize; ULONG cntUsage; ULONG th32ProcessID; ULONG_PTR th32DefaultHeapID; ULONG th32ModuleID; ULONG cntThreads; ULONG th32ParentProcessID; LONG pcPriClassBase; ULONG dwFlags; WCHAR szExeFile[260]; }; +struct tagPROCESSENTRY32{ ULONG dwSize; ULONG cntUsage; ULONG th32ProcessID; ULONG_PTR th32DefaultHeapID; ULONG th32ModuleID; ULONG cntThreads; ULONG th32ParentProcessID; LONG pcPriClassBase; ULONG dwFlags; CHAR szExeFile[260]; }; +struct tagTHREADENTRY32{ ULONG dwSize; ULONG cntUsage; ULONG th32ThreadID; ULONG th32OwnerProcessID; LONG tpBasePri; LONG tpDeltaPri; ULONG dwFlags; }; +struct tagMODULEENTRY32W{ ULONG dwSize; ULONG th32ModuleID; ULONG th32ProcessID; ULONG GlblcntUsage; ULONG ProccntUsage; UCHAR* modBaseAddr; ULONG modBaseSize; HMODULE hModule; WCHAR szModule[256]; WCHAR szExePath[260]; }; +struct tagMODULEENTRY32{ ULONG dwSize; ULONG th32ModuleID; ULONG th32ProcessID; ULONG GlblcntUsage; ULONG ProccntUsage; UCHAR* modBaseAddr; ULONG modBaseSize; HMODULE hModule; char szModule[256]; char szExePath[260]; }; +struct tuispicreatedialoginstanceparams_tag{ DRV_REQUESTID dwRequestID; HDRVDIALOGINSTANCE hdDlgInst; HTAPIDIALOGINSTANCE htDlgInst; LPCWSTR lpszUIDLLName; LPVOID lpParams; ULONG dwSize; }; +struct LINEQOSSERVICELEVEL_tag{ ULONG dwMediaMode; ULONG dwQOSServiceLevel; }; +struct LINECALLQOSINFO_tag{ ULONG dwKey; ULONG dwTotalSize; ULONG dwQOSRequestType; }; +struct tagUAL_DATA_BLOB{ ULONG Size; GUID RoleGuid; GUID TenantId; SOCKADDR_STORAGE Address; WCHAR UserName[260]; }; +struct tag_SCRIPT_CONTROL{ ULONG uDefaultLanguage : 16; ULONG fContextDigits : 1; ULONG fInvertPreBoundDir : 1; ULONG fInvertPostBoundDir : 1; ULONG fLinkStringBefore : 1; ULONG fLinkStringAfter : 1; ULONG fNeutralOverride : 1; ULONG fNumericOverride : 1; ULONG fLegacyBidiClass : 1; ULONG fMergeNeutralItems : 1; ULONG fUseStandardBidi : 1; ULONG fReserved : 6; }; +struct tag_SCRIPT_STATE{ WORD uBidiLevel : 5; WORD fOverrideDirection : 1; WORD fInhibitSymSwap : 1; WORD fCharShape : 1; WORD fDigitSubstitute : 1; WORD fInhibitLigate : 1; WORD fDisplayZWG : 1; WORD fArabicNumContext : 1; WORD fGcpClusters : 1; WORD fReserved : 1; WORD fEngineReserved : 2; }; +struct tag_SCRIPT_ANALYSIS{ WORD eScript : 10; WORD fRTL : 1; WORD fLayoutRTL : 1; WORD fLinkBefore : 1; WORD fLinkAfter : 1; WORD fLogicalOrder : 1; WORD fNoGlyphIndex : 1; SCRIPT_STATE s; }; +struct tag_SCRIPT_ITEM{ int iCharPos; SCRIPT_ANALYSIS a; }; +enum tag_SCRIPT_JUSTIFY{ SCRIPT_JUSTIFY_NONE = 0, SCRIPT_JUSTIFY_ARABIC_BLANK = 1, SCRIPT_JUSTIFY_CHARACTER = 2, SCRIPT_JUSTIFY_RESERVED1 = 3, SCRIPT_JUSTIFY_BLANK = 4, SCRIPT_JUSTIFY_RESERVED2 = 5, SCRIPT_JUSTIFY_RESERVED3 = 6, SCRIPT_JUSTIFY_ARABIC_NORMAL = 7, SCRIPT_JUSTIFY_ARABIC_KASHIDA = 8, SCRIPT_JUSTIFY_ARABIC_ALEF = 9, SCRIPT_JUSTIFY_ARABIC_HA = 10, SCRIPT_JUSTIFY_ARABIC_RA = 11, SCRIPT_JUSTIFY_ARABIC_BA = 12, SCRIPT_JUSTIFY_ARABIC_BARA = 13, SCRIPT_JUSTIFY_ARABIC_SEEN = 14, SCRIPT_JUSTIFY_ARABIC_SEEN_M = 15 }; +struct tag_SCRIPT_VISATTR{ WORD uJustification : 4; WORD fClusterStart : 1; WORD fDiacritic : 1; WORD fZeroWidth : 1; WORD fReserved : 1; WORD fShapeReserved : 8; }; +struct tagGOFFSET{ LONG du; LONG dv; }; +struct tag_SCRIPT_LOGATTR{ UCHAR fSoftBreak : 1; UCHAR fWhiteSpace : 1; UCHAR fCharStop : 1; UCHAR fWordStop : 1; UCHAR fInvalid : 1; UCHAR fReserved : 3; }; +struct tag_SCRIPT_TABDEF{ int cTabStops; int iScale; int* pTabStops; int iTabOrigin; }; +struct tag_SCRIPT_DIGITSUBSTITUTE{ ULONG NationalDigitLanguage : 16; ULONG TraditionalDigitLanguage : 16; ULONG DigitSubstitute : 8; ULONG dwReserved; }; +enum tag_VDS_PARTITION_STYLE{ VDS_PARTITION_STYLE_MBR = 0, VDS_PARTITION_STYLE_GPT = 1, VDS_PARTITION_STYLE_RAW = 2 }; +struct videohdr_tag{ LPBYTE lpData; ULONG dwBufferLength; ULONG dwBytesUsed; ULONG dwTimeCaptured; DWORD_PTR dwUser; ULONG dwFlags; DWORD_PTR dwReserved[4]; }; +struct channel_caps_tag{ ULONG dwFlags; ULONG dwSrcRectXMod; ULONG dwSrcRectYMod; ULONG dwSrcRectWidthMod; ULONG dwSrcRectHeightMod; ULONG dwDstRectXMod; ULONG dwDstRectYMod; ULONG dwDstRectWidthMod; ULONG dwDstRectHeightMod; }; +struct tagCapDriverCaps{ UINT wDeviceIndex; BOOL fHasOverlay; BOOL fHasDlgVideoSource; BOOL fHasDlgVideoFormat; BOOL fHasDlgVideoDisplay; BOOL fCaptureInitialized; BOOL fDriverSuppliesPalettes; HANDLE hVideoIn; HANDLE hVideoOut; HANDLE hVideoExtIn; HANDLE hVideoExtOut; }; +struct tagCapStatus{ UINT uiImageWidth; UINT uiImageHeight; BOOL fLiveWindow; BOOL fOverlayWindow; BOOL fScale; POINT ptScroll; BOOL fUsingDefaultPalette; BOOL fAudioHardware; BOOL fCapFileExists; ULONG dwCurrentVideoFrame; ULONG dwCurrentVideoFramesDropped; ULONG dwCurrentWaveSamples; ULONG dwCurrentTimeElapsedMS; HPALETTE hPalCurrent; BOOL fCapturingNow; ULONG dwReturn; UINT wNumVideoAllocated; UINT wNumAudioAllocated; }; +struct tagCaptureParms{ ULONG dwRequestMicroSecPerFrame; BOOL fMakeUserHitOKToCapture; UINT wPercentDropForError; BOOL fYield; ULONG dwIndexSize; UINT wChunkGranularity; BOOL fUsingDOSMemory; UINT wNumVideoRequested; BOOL fCaptureAudio; UINT wNumAudioRequested; UINT vKeyAbort; BOOL fAbortLeftMouse; BOOL fAbortRightMouse; BOOL fLimitEnabled; UINT wTimeLimit; BOOL fMCIControl; BOOL fStepMCIDevice; ULONG dwMCIStartTime; ULONG dwMCIStopTime; BOOL fStepCaptureAt2x; UINT wStepCaptureAverageFrames; ULONG dwAudioBufferSize; BOOL fDisableWriteCache; UINT AVStreamMaster; }; +struct tagCapInfoChunk{ FOURCC fccInfoID; LPVOID lpData; LONG cbData; }; +enum tagUpdateImpactLevel{ UpdateImpactLevel_None = 0, UpdateImpactLevel_Low = 1, UpdateImpactLevel_Medium = 2, UpdateImpactLevel_High = 3 }; +enum tagUpdateAssessmentStatus{ UpdateAssessmentStatus_Latest = 0, UpdateAssessmentStatus_NotLatestSoftRestriction = 1, UpdateAssessmentStatus_NotLatestHardRestriction = 2, UpdateAssessmentStatus_NotLatestEndOfSupport = 3, UpdateAssessmentStatus_NotLatestServicingTrain = 4, UpdateAssessmentStatus_NotLatestDeferredFeature = 5, UpdateAssessmentStatus_NotLatestDeferredQuality = 6, UpdateAssessmentStatus_NotLatestPausedFeature = 7, UpdateAssessmentStatus_NotLatestPausedQuality = 8, UpdateAssessmentStatus_NotLatestManaged = 9, UpdateAssessmentStatus_NotLatestUnknown = 10, UpdateAssessmentStatus_NotLatestTargetedVersion = 11 }; +struct tagUpdateAssessment{ UpdateAssessmentStatus status; UpdateImpactLevel impact; ULONG daysOutOfDate; }; +struct tagOSUpdateAssessment{ BOOL isEndOfSupport; UpdateAssessment assessmentForCurrent; UpdateAssessment assessmentForUpToDate; UpdateAssessmentStatus securityStatus; FILETIME assessmentTime; FILETIME releaseInfoTime; LPWSTR currentOSBuild; FILETIME currentOSReleaseTime; LPWSTR upToDateOSBuild; FILETIME upToDateOSReleaseTime; }; +struct _tagWAB_PARAM{ ULONG cbSize; HWND hwnd; LPSTR szFileName; ULONG ulFlags; GUID guidPSExt; }; +struct tag_SIPAEVENT_VSM_IDK_RSA_INFO{ ULONG32 KeyBitLength; ULONG32 PublicExpLengthBytes; ULONG32 ModulusSizeBytes; UCHAR PublicKeyData[1]; }; +struct tag_SIPAEVENT_VSM_IDK_INFO_PAYLOAD{ ULONG32 KeyAlgID; }; +struct tag_SIPAEVENT_SI_POLICY_PAYLOAD{ ULONGLONG PolicyVersion; UINT16 PolicyNameLength; UINT16 HashAlgID; UINT32 DigestLength; UCHAR VarLengthData[1]; }; +struct tag_SIPAEVENT_REVOCATION_LIST_PAYLOAD{ LONGLONG CreationTime; UINT32 DigestLength; UINT16 HashAlgID; UCHAR Digest[1]; }; +struct tag_SIPAEVENT_KSR_SIGNATURE_PAYLOAD{ ULONG32 SignAlgID; UINT32 SignatureLength; UCHAR Signature[1]; }; +struct tag_SIPAEVENT_SBCP_INFO_PAYLOAD_V1{ UINT32 PayloadVersion; UINT32 VarDataOffset; UINT16 HashAlgID; UINT16 DigestLength; UINT32 Options; UINT32 SignersCount; UCHAR VarData[1]; }; +enum tagWCN_ATTRIBUTE_TYPE{ WCN_TYPE_AP_CHANNEL = 0, WCN_TYPE_ASSOCIATION_STATE = 1, WCN_TYPE_AUTHENTICATION_TYPE = 2, WCN_TYPE_AUTHENTICATION_TYPE_FLAGS = 3, WCN_TYPE_AUTHENTICATOR = 4, WCN_TYPE_CONFIG_METHODS = 5, WCN_TYPE_CONFIGURATION_ERROR = 6, WCN_TYPE_CONFIRMATION_URL4 = 7, WCN_TYPE_CONFIRMATION_URL6 = 8, WCN_TYPE_CONNECTION_TYPE = 9, WCN_TYPE_CONNECTION_TYPE_FLAGS = 10, WCN_TYPE_CREDENTIAL = 11, WCN_TYPE_DEVICE_NAME = 12, WCN_TYPE_DEVICE_PASSWORD_ID = 13, WCN_TYPE_E_HASH1 = 14, WCN_TYPE_E_HASH2 = 15, WCN_TYPE_E_SNONCE1 = 16, WCN_TYPE_E_SNONCE2 = 17, WCN_TYPE_ENCRYPTED_SETTINGS = 18, WCN_TYPE_ENCRYPTION_TYPE = 19, WCN_TYPE_ENCRYPTION_TYPE_FLAGS = 20, WCN_TYPE_ENROLLEE_NONCE = 21, WCN_TYPE_FEATURE_ID = 22, WCN_TYPE_IDENTITY = 23, WCN_TYPE_IDENTITY_PROOF = 24, WCN_TYPE_KEY_WRAP_AUTHENTICATOR = 25, WCN_TYPE_KEY_IDENTIFIER = 26, WCN_TYPE_MAC_ADDRESS = 27, WCN_TYPE_MANUFACTURER = 28, WCN_TYPE_MESSAGE_TYPE = 29, WCN_TYPE_MODEL_NAME = 30, WCN_TYPE_MODEL_NUMBER = 31, WCN_TYPE_NETWORK_INDEX = 32, WCN_TYPE_NETWORK_KEY = 33, WCN_TYPE_NETWORK_KEY_INDEX = 34, WCN_TYPE_NEW_DEVICE_NAME = 35, WCN_TYPE_NEW_PASSWORD = 36, WCN_TYPE_OOB_DEVICE_PASSWORD = 37, WCN_TYPE_OS_VERSION = 38, WCN_TYPE_POWER_LEVEL = 39, WCN_TYPE_PSK_CURRENT = 40, WCN_TYPE_PSK_MAX = 41, WCN_TYPE_PUBLIC_KEY = 42, WCN_TYPE_RADIO_ENABLED = 43, WCN_TYPE_REBOOT = 44, WCN_TYPE_REGISTRAR_CURRENT = 45, WCN_TYPE_REGISTRAR_ESTABLISHED = 46, WCN_TYPE_REGISTRAR_LIST = 47, WCN_TYPE_REGISTRAR_MAX = 48, WCN_TYPE_REGISTRAR_NONCE = 49, WCN_TYPE_REQUEST_TYPE = 50, WCN_TYPE_RESPONSE_TYPE = 51, WCN_TYPE_RF_BANDS = 52, WCN_TYPE_R_HASH1 = 53, WCN_TYPE_R_HASH2 = 54, WCN_TYPE_R_SNONCE1 = 55, WCN_TYPE_R_SNONCE2 = 56, WCN_TYPE_SELECTED_REGISTRAR = 57, WCN_TYPE_SERIAL_NUMBER = 58, WCN_TYPE_WI_FI_PROTECTED_SETUP_STATE = 59, WCN_TYPE_SSID = 60, WCN_TYPE_TOTAL_NETWORKS = 61, WCN_TYPE_UUID_E = 62, WCN_TYPE_UUID_R = 63 }; +enum tagWCN_VALUE_TYPE_VERSION{ WCN_VALUE_VERSION_1_0 = 16, WCN_VALUE_VERSION_2_0 = 32 }; +enum tagWCN_VALUE_TYPE_BOOLEAN{ WCN_VALUE_FALSE = 0, WCN_VALUE_TRUE = 1 }; +enum tagWCN_VALUE_TYPE_ASSOCIATION_STATE{ WCN_VALUE_AS_NOT_ASSOCIATED = 0, WCN_VALUE_AS_CONNECTION_SUCCESS = 1, WCN_VALUE_AS_CONFIGURATION_FAILURE = 2, WCN_VALUE_AS_ASSOCIATION_FAILURE = 3, WCN_VALUE_AS_IP_FAILURE = 4 }; +enum tagWCN_VALUE_TYPE_AUTHENTICATION_TYPE{ WCN_VALUE_AT_OPEN = 1, WCN_VALUE_AT_WPAPSK = 2, WCN_VALUE_AT_SHARED = 4, WCN_VALUE_AT_WPA = 8, WCN_VALUE_AT_WPA2 = 16, WCN_VALUE_AT_WPA2PSK = 32, WCN_VALUE_AT_WPAWPA2PSK_MIXED = 34 }; +enum tagWCN_VALUE_TYPE_CONFIG_METHODS{ WCN_VALUE_CM_USBA = 1, WCN_VALUE_CM_ETHERNET = 2, WCN_VALUE_CM_LABEL = 4, WCN_VALUE_CM_DISPLAY = 8, WCN_VALUE_CM_EXTERNAL_NFC = 16, WCN_VALUE_CM_INTEGRATED_NFC = 32, WCN_VALUE_CM_NFC_INTERFACE = 64, WCN_VALUE_CM_PUSHBUTTON = 128, WCN_VALUE_CM_KEYPAD = 256, WCN_VALUE_CM_VIRT_PUSHBUTTON = 640, WCN_VALUE_CM_PHYS_PUSHBUTTON = 1152, WCN_VALUE_CM_VIRT_DISPLAY = 8200, WCN_VALUE_CM_PHYS_DISPLAY = 16392 }; +enum tagWCN_VALUE_TYPE_CONFIGURATION_ERROR{ WCN_VALUE_CE_NO_ERROR = 0, WCN_VALUE_CE_OOB_INTERFACE_READ_ERROR = 1, WCN_VALUE_CE_DECRYPTION_CRC_FAILURE = 2, WCN_VALUE_CE_2_4_CHANNEL_NOT_SUPPORTED = 3, WCN_VALUE_CE_5_0_CHANNEL_NOT_SUPPORTED = 4, WCN_VALUE_CE_SIGNAL_TOO_WEAK = 5, WCN_VALUE_CE_NETWORK_AUTHENTICATION_FAILURE = 6, WCN_VALUE_CE_NETWORK_ASSOCIATION_FAILURE = 7, WCN_VALUE_CE_NO_DHCP_RESPONSE = 8, WCN_VALUE_CE_FAILED_DHCP_CONFIG = 9, WCN_VALUE_CE_IP_ADDRESS_CONFLICT = 10, WCN_VALUE_CE_COULD_NOT_CONNECT_TO_REGISTRAR = 11, WCN_VALUE_CE_MULTIPLE_PBC_SESSIONS_DETECTED = 12, WCN_VALUE_CE_ROGUE_ACTIVITY_SUSPECTED = 13, WCN_VALUE_CE_DEVICE_BUSY = 14, WCN_VALUE_CE_SETUP_LOCKED = 15, WCN_VALUE_CE_MESSAGE_TIMEOUT = 16, WCN_VALUE_CE_REGISTRATION_SESSION_TIMEOUT = 17, WCN_VALUE_CE_DEVICE_PASSWORD_AUTH_FAILURE = 18 }; +enum tagWCN_VALUE_TYPE_CONNECTION_TYPE{ WCN_VALUE_CT_ESS = 1, WCN_VALUE_CT_IBSS = 2 }; +enum tagWCN_VALUE_TYPE_DEVICE_PASSWORD_ID{ WCN_VALUE_DP_DEFAULT = 0, WCN_VALUE_DP_USER_SPECIFIED = 1, WCN_VALUE_DP_MACHINE_SPECIFIED = 2, WCN_VALUE_DP_REKEY = 3, WCN_VALUE_DP_PUSHBUTTON = 4, WCN_VALUE_DP_REGISTRAR_SPECIFIED = 5, WCN_VALUE_DP_NFC_CONNECTION_HANDOVER = 7, WCN_VALUE_DP_WFD_SERVICES = 8, WCN_VALUE_DP_OUTOFBAND_MIN = 16, WCN_VALUE_DP_OUTOFBAND_MAX = 65535 }; +enum tagWCN_VALUE_TYPE_ENCRYPTION_TYPE{ WCN_VALUE_ET_NONE = 1, WCN_VALUE_ET_WEP = 2, WCN_VALUE_ET_TKIP = 4, WCN_VALUE_ET_AES = 8, WCN_VALUE_ET_TKIP_AES_MIXED = 12 }; +enum tagWCN_VALUE_TYPE_MESSAGE_TYPE{ WCN_VALUE_MT_BEACON = 1, WCN_VALUE_MT_PROBE_REQUEST = 2, WCN_VALUE_MT_PROBE_RESPONSE = 3, WCN_VALUE_MT_M1 = 4, WCN_VALUE_MT_M2 = 5, WCN_VALUE_MT_M2D = 6, WCN_VALUE_MT_M3 = 7, WCN_VALUE_MT_M4 = 8, WCN_VALUE_MT_M5 = 9, WCN_VALUE_MT_M6 = 10, WCN_VALUE_MT_M7 = 11, WCN_VALUE_MT_M8 = 12, WCN_VALUE_MT_ACK = 13, WCN_VALUE_MT_NACK = 14, WCN_VALUE_MT_DONE = 15 }; +enum tagWCN_VALUE_TYPE_REQUEST_TYPE{ WCN_VALUE_ReqT_ENROLLEE_INFO = 0, WCN_VALUE_ReqT_ENROLLEE_OPEN_1X = 1, WCN_VALUE_ReqT_REGISTRAR = 2, WCN_VALUE_ReqT_MANAGER_REGISTRAR = 3 }; +enum tagWCN_VALUE_TYPE_RESPONSE_TYPE{ WCN_VALUE_RspT_ENROLLEE_INFO = 0, WCN_VALUE_RspT_ENROLLEE_OPEN_1X = 1, WCN_VALUE_RspT_REGISTRAR = 2, WCN_VALUE_RspT_AP = 3 }; +enum tagWCN_VALUE_TYPE_RF_BANDS{ WCN_VALUE_RB_24GHZ = 1, WCN_VALUE_RB_50GHZ = 2 }; +enum tagWCN_VALUE_TYPE_WI_FI_PROTECTED_SETUP_STATE{ WCN_VALUE_SS_RESERVED00 = 0, WCN_VALUE_SS_NOT_CONFIGURED = 1, WCN_VALUE_SS_CONFIGURED = 2 }; +struct tagWCN_VALUE_TYPE_PRIMARY_DEVICE_TYPE{ WCN_VALUE_TYPE_DEVICE_TYPE_CATEGORY Category; WCN_VALUE_TYPE_DEVICE_TYPE_SUBCATEGORY_OUI SubCategoryOUI; WCN_VALUE_TYPE_DEVICE_TYPE_SUBCATEGORY SubCategory; }; +enum tagWCN_PASSWORD_TYPE{ WCN_PASSWORD_TYPE_PUSH_BUTTON = 0, WCN_PASSWORD_TYPE_PIN = 1, WCN_PASSWORD_TYPE_PIN_REGISTRAR_SPECIFIED = 2, WCN_PASSWORD_TYPE_OOB_SPECIFIED = 3, WCN_PASSWORD_TYPE_WFDS = 4 }; +enum tagWCN_SESSION_STATUS{ WCN_SESSION_STATUS_SUCCESS = 0, WCN_SESSION_STATUS_FAILURE_GENERIC = 1, WCN_SESSION_STATUS_FAILURE_TIMEOUT = 2 }; +struct tagWCN_VENDOR_EXTENSION_SPEC{ ULONG VendorId; ULONG SubType; ULONG Index; ULONG Flags; }; +struct tagWDS_CLI_CRED{ PCWSTR pwszUserName; PCWSTR pwszDomain; PCWSTR pwszPassword; }; +struct tagPXE_DHCP_OPTION{ UCHAR OptionType; UCHAR OptionLength; UCHAR OptionValue[1]; }; +struct tagPXE_DHCP_MESSAGE{ UCHAR Operation; UCHAR HardwareAddressType; UCHAR HardwareAddressLength; UCHAR HopCount; ULONG TransactionID; WORD SecondsSinceBoot; WORD Reserved; ULONG ClientIpAddress; ULONG YourIpAddress; ULONG BootstrapServerAddress; ULONG RelayAgentIpAddress; UCHAR HardwareAddress[16]; UCHAR HostName[64]; UCHAR BootFileName[128]; PXE_DHCP_OPTION Option; }; +struct tagPXE_DHCPV6_OPTION{ WORD OptionCode; WORD DataLength; UCHAR Data[1]; }; +struct tagPXE_DHCPV6_MESSAGE_HEADER{ UCHAR MessageType; UCHAR Message[1]; }; +struct tagPXE_DHCPV6_MESSAGE{ UCHAR MessageType; UCHAR TransactionIDByte1; UCHAR TransactionIDByte2; UCHAR TransactionIDByte3; PXE_DHCPV6_OPTION Options[1]; }; +struct tagPXE_DHCPV6_RELAY_MESSAGE{ UCHAR MessageType; UCHAR HopCount; UCHAR LinkAddress[16]; UCHAR PeerAddress[16]; PXE_DHCPV6_OPTION Options[1]; }; +struct tagPXE_PROVIDER{ ULONG uSizeOfStruct; LPWSTR pwszName; LPWSTR pwszFilePath; BOOL bIsCritical; ULONG uIndex; }; +struct tagPXE_ADDRESS{ ULONG uFlags; ULONG uAddrLen; USHORT uPort; }; +struct tagPXE_DHCPV6_NESTED_RELAY_MESSAGE{ PPXE_DHCPV6_RELAY_MESSAGE pRelayMessage; ULONG cbRelayMessage; PVOID pInterfaceIdOption; WORD cbInterfaceIdOption; }; +struct tagDEVICEDIALOGDATA2{ ULONG cbSize; IWiaItem2* pIWiaItemRoot; ULONG dwFlags; HWND hwndParent; BSTR bstrFolderName; BSTR bstrFilename; LONG lNumFiles; BSTR* pbstrFilePaths; IWiaItem2* pWiaItem; }; +struct tagDEVICEDIALOGDATA{ ULONG cbSize; HWND hwndParent; IWiaItem* pIWiaItemRoot; ULONG dwFlags; LONG lIntent; LONG lItemCount; IWiaItem** ppWiaItems; }; +typedef ber_tag_t unsigned int; +enum tagSIDESHOW_SCREEN_TYPE{ SIDESHOW_SCREEN_TYPE_BITMAP = 0, SIDESHOW_SCREEN_TYPE_TEXT = 1 }; +enum tagSIDESHOW_COLOR_TYPE{ SIDESHOW_COLOR_TYPE_COLOR = 0, SIDESHOW_COLOR_TYPE_GREYSCALE = 1, SIDESHOW_COLOR_TYPE_BLACK_AND_WHITE = 2 }; +enum tagSCF_EVENT_IDS{ SCF_EVENT_NAVIGATION = 1, SCF_EVENT_MENUACTION = 2, SCF_EVENT_CONTEXTMENU = 3 }; +enum tagSCF_BUTTON_IDS{ SCF_BUTTON_MENU = 1, SCF_BUTTON_SELECT = 2, SCF_BUTTON_UP = 3, SCF_BUTTON_DOWN = 4, SCF_BUTTON_LEFT = 5, SCF_BUTTON_RIGHT = 6, SCF_BUTTON_PLAY = 7, SCF_BUTTON_PAUSE = 8, SCF_BUTTON_FASTFORWARD = 9, SCF_BUTTON_REWIND = 10, SCF_BUTTON_STOP = 11, SCF_BUTTON_BACK = 65280 }; +enum tagUSER_STATE{ AVAILABLE = 0, UNAVAILABLE = 1 }; +struct tagWINHTTP_CREDS{ LPSTR lpszUserName; LPSTR lpszPassword; LPSTR lpszRealm; ULONG dwAuthScheme; LPSTR lpszHostName; ULONG dwPort; }; +struct tagWINHTTP_CREDS_EX{ LPSTR lpszUserName; LPSTR lpszPassword; LPSTR lpszRealm; ULONG dwAuthScheme; LPSTR lpszHostName; ULONG dwPort; LPSTR lpszUrl; }; +struct _tagDATETIME{ WORD year; WORD month; WORD day; WORD hour; WORD min; WORD sec; }; +struct _tagIMEPROA{ HWND hWnd; DATETIME InstDate; UINT wVersion; UCHAR szDescription[50]; UCHAR szName[80]; UCHAR szOptions[30]; }; +struct _tagIMEPROW{ HWND hWnd; DATETIME InstDate; UINT wVersion; WCHAR szDescription[50]; WCHAR szName[80]; WCHAR szOptions[30]; }; +struct tagAecQualityMetrics_Struct{ LONGLONG i64Timestamp; UCHAR ConvergenceFlag; UCHAR MicClippedFlag; UCHAR MicSilenceFlag; UCHAR PstvFeadbackFlag; UCHAR SpkClippedFlag; UCHAR SpkMuteFlag; UCHAR GlitchFlag; UCHAR DoubleTalkFlag; ULONG uGlitchCount; ULONG uMicClipCount; float fDuration; float fTSVariance; float fTSDriftRate; float fVoiceLevel; float fNoiseLevel; float fERLE; float fAvgERLE; ULONG dwReserved; }; +enum tagWPCFLAG_OVERRIDE{ WPCFLAG_APPLICATION = 1 }; +enum tagWPCFLAG_RESTRICTION{ WPCFLAG_NO_RESTRICTION = 0, WPCFLAG_LOGGING_REQUIRED = 1, WPCFLAG_WEB_FILTERED = 2, WPCFLAG_HOURS_RESTRICTED = 4, WPCFLAG_GAMES_BLOCKED = 8, WPCFLAG_APPS_RESTRICTED = 16, WPCFLAG_TIME_ALLOWANCE_RESTRICTED = 32, WPCFLAG_GAMES_RESTRICTED = 64 }; +enum tagWPCFLAG_WEB_SETTING{ WPCFLAG_WEB_SETTING_NOTBLOCKED = 0, WPCFLAG_WEB_SETTING_DOWNLOADSBLOCKED = 1 }; +enum tagWPCFLAG_VISIBILITY{ WPCFLAG_WPC_VISIBLE = 0, WPCFLAG_WPC_HIDDEN = 1 }; +enum tagWPCFLAG_ISBLOCKED{ WPCFLAG_ISBLOCKED_NOTBLOCKED = 0, WPCFLAG_ISBLOCKED_IMBLOCKED = 1, WPCFLAG_ISBLOCKED_EMAILBLOCKED = 2, WPCFLAG_ISBLOCKED_MEDIAPLAYBACKBLOCKED = 4, WPCFLAG_ISBLOCKED_WEBBLOCKED = 8, WPCFLAG_ISBLOCKED_GAMESBLOCKED = 16, WPCFLAG_ISBLOCKED_CONTACTBLOCKED = 32, WPCFLAG_ISBLOCKED_FEATUREBLOCKED = 64, WPCFLAG_ISBLOCKED_DOWNLOADBLOCKED = 128, WPCFLAG_ISBLOCKED_RATINGBLOCKED = 256, WPCFLAG_ISBLOCKED_DESCRIPTORBLOCKED = 512, WPCFLAG_ISBLOCKED_EXPLICITBLOCK = 1024, WPCFLAG_ISBLOCKED_BADPASS = 2048, WPCFLAG_ISBLOCKED_MAXHOURS = 4096, WPCFLAG_ISBLOCKED_SPECHOURS = 8192, WPCFLAG_ISBLOCKED_SETTINGSCHANGEBLOCKED = 16384, WPCFLAG_ISBLOCKED_ATTACHMENTBLOCKED = 32768, WPCFLAG_ISBLOCKED_SENDERBLOCKED = 65536, WPCFLAG_ISBLOCKED_RECEIVERBLOCKED = 131072, WPCFLAG_ISBLOCKED_NOTEXPLICITLYALLOWED = 262144, WPCFLAG_ISBLOCKED_NOTINLIST = 524288, WPCFLAG_ISBLOCKED_CATEGORYBLOCKED = 1048576, WPCFLAG_ISBLOCKED_CATEGORYNOTINLIST = 2097152, WPCFLAG_ISBLOCKED_NOTKIDS = 4194304, WPCFLAG_ISBLOCKED_UNRATED = 8388608, WPCFLAG_ISBLOCKED_NOACCESS = 16777216, WPCFLAG_ISBLOCKED_INTERNALERROR = 4294967295 }; +enum tagWPCFLAG_LOGOFF_TYPE{ WPCFLAG_LOGOFF_TYPE_LOGOUT = 0, WPCFLAG_LOGOFF_TYPE_RESTART = 1, WPCFLAG_LOGOFF_TYPE_SHUTDOWN = 2, WPCFLAG_LOGOFF_TYPE_FUS = 4, WPCFLAG_LOGOFF_TYPE_FORCEDFUS = 8 }; +enum tagWPCFLAG_IM_LEAVE_FLAG{ WPCFLAG_IM_LEAVE_NORMAL = 0, WPCFLAG_IM_LEAVE_FORCED = 1, WPCFLAG_IM_LEAVE_CONVERSATION_END = 2 }; +enum tagWPC_ARGS_SETTINGSCHANGEEVENT{ WPC_ARGS_SETTINGSCHANGEEVENT_CLASS = 0, WPC_ARGS_SETTINGSCHANGEEVENT_SETTING = 1, WPC_ARGS_SETTINGSCHANGEEVENT_OWNER = 2, WPC_ARGS_SETTINGSCHANGEEVENT_OLDVAL = 3, WPC_ARGS_SETTINGSCHANGEEVENT_NEWVAL = 4, WPC_ARGS_SETTINGSCHANGEEVENT_REASON = 5, WPC_ARGS_SETTINGSCHANGEEVENT_OPTIONAL = 6, WPC_ARGS_SETTINGSCHANGEEVENT_CARGS = 7 }; +enum tagWPC_ARGS_SAFERAPPBLOCKED{ WPC_ARGS_SAFERAPPBLOCKED_TIMESTAMP = 0, WPC_ARGS_SAFERAPPBLOCKED_USERID = 1, WPC_ARGS_SAFERAPPBLOCKED_PATH = 2, WPC_ARGS_SAFERAPPBLOCKED_RULEID = 3, WPC_ARGS_SAFERAPPBLOCKED_CARGS = 4 }; +enum tagWPC_ARGS_EMAILRECEIEVEDEVENT{ WPC_ARGS_EMAILRECEIEVEDEVENT_SENDER = 0, WPC_ARGS_EMAILRECEIEVEDEVENT_APPNAME = 1, WPC_ARGS_EMAILRECEIEVEDEVENT_APPVERSION = 2, WPC_ARGS_EMAILRECEIEVEDEVENT_SUBJECT = 3, WPC_ARGS_EMAILRECEIEVEDEVENT_REASON = 4, WPC_ARGS_EMAILRECEIEVEDEVENT_RECIPCOUNT = 5, WPC_ARGS_EMAILRECEIEVEDEVENT_RECIPIENT = 6, WPC_ARGS_EMAILRECEIEVEDEVENT_ATTACHCOUNT = 7, WPC_ARGS_EMAILRECEIEVEDEVENT_ATTACHMENTNAME = 8, WPC_ARGS_EMAILRECEIEVEDEVENT_RECEIVEDTIME = 9, WPC_ARGS_EMAILRECEIEVEDEVENT_EMAILACCOUNT = 10, WPC_ARGS_EMAILRECEIEVEDEVENT_CARGS = 11 }; +enum tagWPC_ARGS_EMAILSENTEVENT{ WPC_ARGS_EMAILSENTEVENT_SENDER = 0, WPC_ARGS_EMAILSENTEVENT_APPNAME = 1, WPC_ARGS_EMAILSENTEVENT_APPVERSION = 2, WPC_ARGS_EMAILSENTEVENT_SUBJECT = 3, WPC_ARGS_EMAILSENTEVENT_REASON = 4, WPC_ARGS_EMAILSENTEVENT_RECIPCOUNT = 5, WPC_ARGS_EMAILSENTEVENT_RECIPIENT = 6, WPC_ARGS_EMAILSENTEVENT_ATTACHCOUNT = 7, WPC_ARGS_EMAILSENTEVENT_ATTACHMENTNAME = 8, WPC_ARGS_EMAILSENTEVENT_EMAILACCOUNT = 9, WPC_ARGS_EMAILSENTEVENT_CARGS = 10 }; +enum tagWPC_ARGS_EMAILCONTACTEVENT{ WPC_ARGS_EMAILCONTACTEVENT_APPNAME = 0, WPC_ARGS_EMAILCONTACTEVENT_APPVERSION = 1, WPC_ARGS_EMAILCONTACTEVENT_OLDNAME = 2, WPC_ARGS_EMAILCONTACTEVENT_OLDID = 3, WPC_ARGS_EMAILCONTACTEVENT_NEWNAME = 4, WPC_ARGS_EMAILCONTACTEVENT_NEWID = 5, WPC_ARGS_EMAILCONTACTEVENT_REASON = 6, WPC_ARGS_EMAILCONTACTEVENT_EMAILACCOUNT = 7, WPC_ARGS_EMAILCONTACTEVENT_CARGS = 8 }; +enum tagWPC_MEDIA_TYPE{ WPC_MEDIA_TYPE_OTHER = 0, WPC_MEDIA_TYPE_DVD = 1, WPC_MEDIA_TYPE_RECORDED_TV = 2, WPC_MEDIA_TYPE_AUDIO_FILE = 3, WPC_MEDIA_TYPE_CD_AUDIO = 4, WPC_MEDIA_TYPE_VIDEO_FILE = 5, WPC_MEDIA_TYPE_PICTURE_FILE = 6, WPC_MEDIA_TYPE_MAX = 7 }; +enum tagWPC_MEDIA_EXPLICIT_TYPE{ WPC_MEDIA_EXPLICIT_FALSE = 0, WPC_MEDIA_EXPLICIT_TRUE = 1, WPC_MEDIA_EXPLICIT_UNKNOWN = 2 }; +enum tagWPC_ARGS_MEDIAPLAYBACKEVENT{ WPC_ARGS_MEDIAPLAYBACKEVENT_APPNAME = 0, WPC_ARGS_MEDIAPLAYBACKEVENT_APPVERSION = 1, WPC_ARGS_MEDIAPLAYBACKEVENT_MEDIATYPE = 2, WPC_ARGS_MEDIAPLAYBACKEVENT_PATH = 3, WPC_ARGS_MEDIAPLAYBACKEVENT_TITLE = 4, WPC_ARGS_MEDIAPLAYBACKEVENT_PML = 5, WPC_ARGS_MEDIAPLAYBACKEVENT_ALBUM = 6, WPC_ARGS_MEDIAPLAYBACKEVENT_EXPLICIT = 7, WPC_ARGS_MEDIAPLAYBACKEVENT_REASON = 8, WPC_ARGS_MEDIAPLAYBACKEVENT_CARGS = 9 }; +enum tagWPC_ARGS_MEDIADOWNLOADEVENT{ WPC_ARGS_MEDIADOWNLOADEVENT_APPNAME = 0, WPC_ARGS_MEDIADOWNLOADEVENT_APPVERSION = 1, WPC_ARGS_MEDIADOWNLOADEVENT_MEDIATYPE = 2, WPC_ARGS_MEDIADOWNLOADEVENT_PATH = 3, WPC_ARGS_MEDIADOWNLOADEVENT_TITLE = 4, WPC_ARGS_MEDIADOWNLOADEVENT_PML = 5, WPC_ARGS_MEDIADOWNLOADEVENT_ALBUM = 6, WPC_ARGS_MEDIADOWNLOADEVENT_EXPLICIT = 7, WPC_ARGS_MEDIADOWNLOADEVENT_REASON = 8, WPC_ARGS_MEDIADOWNLOADEVENT_CARGS = 9 }; +enum tagWPC_ARGS_CONVERSATIONINITEVENT{ WPC_ARGS_CONVERSATIONINITEVENT_APPNAME = 0, WPC_ARGS_CONVERSATIONINITEVENT_APPVERSION = 1, WPC_ARGS_CONVERSATIONINITEVENT_ACCOUNTNAME = 2, WPC_ARGS_CONVERSATIONINITEVENT_CONVID = 3, WPC_ARGS_CONVERSATIONINITEVENT_REQUESTINGIP = 4, WPC_ARGS_CONVERSATIONINITEVENT_SENDER = 5, WPC_ARGS_CONVERSATIONINITEVENT_REASON = 6, WPC_ARGS_CONVERSATIONINITEVENT_RECIPCOUNT = 7, WPC_ARGS_CONVERSATIONINITEVENT_RECIPIENT = 8, WPC_ARGS_CONVERSATIONINITEVENT_CARGS = 9 }; +enum tagWPC_ARGS_CONVERSATIONJOINEVENT{ WPC_ARGS_CONVERSATIONJOINEVENT_APPNAME = 0, WPC_ARGS_CONVERSATIONJOINEVENT_APPVERSION = 1, WPC_ARGS_CONVERSATIONJOINEVENT_ACCOUNTNAME = 2, WPC_ARGS_CONVERSATIONJOINEVENT_CONVID = 3, WPC_ARGS_CONVERSATIONJOINEVENT_JOININGIP = 4, WPC_ARGS_CONVERSATIONJOINEVENT_JOININGUSER = 5, WPC_ARGS_CONVERSATIONJOINEVENT_REASON = 6, WPC_ARGS_CONVERSATIONJOINEVENT_MEMBERCOUNT = 7, WPC_ARGS_CONVERSATIONJOINEVENT_MEMBER = 8, WPC_ARGS_CONVERSATIONJOINEVENT_SENDER = 9, WPC_ARGS_CONVERSATIONJOINEVENT_CARGS = 10 }; +enum tagWPC_ARGS_CONVERSATIONLEAVEEVENT{ WPC_ARGS_CONVERSATIONLEAVEEVENT_APPNAME = 0, WPC_ARGS_CONVERSATIONLEAVEEVENT_APPVERSION = 1, WPC_ARGS_CONVERSATIONLEAVEEVENT_ACCOUNTNAME = 2, WPC_ARGS_CONVERSATIONLEAVEEVENT_CONVID = 3, WPC_ARGS_CONVERSATIONLEAVEEVENT_LEAVINGIP = 4, WPC_ARGS_CONVERSATIONLEAVEEVENT_LEAVINGUSER = 5, WPC_ARGS_CONVERSATIONLEAVEEVENT_REASON = 6, WPC_ARGS_CONVERSATIONLEAVEEVENT_MEMBERCOUNT = 7, WPC_ARGS_CONVERSATIONLEAVEEVENT_MEMBER = 8, WPC_ARGS_CONVERSATIONLEAVEEVENT_FLAGS = 9, WPC_ARGS_CONVERSATIONLEAVEEVENT_CARGS = 10 }; +enum tagWPCFLAG_IM_FEATURE{ WPCFLAG_IM_FEATURE_NONE = 0, WPCFLAG_IM_FEATURE_VIDEO = 1, WPCFLAG_IM_FEATURE_AUDIO = 2, WPCFLAG_IM_FEATURE_GAME = 4, WPCFLAG_IM_FEATURE_SMS = 8, WPCFLAG_IM_FEATURE_FILESWAP = 16, WPCFLAG_IM_FEATURE_URLSWAP = 32, WPCFLAG_IM_FEATURE_SENDING = 2147483648, WPCFLAG_IM_FEATURE_ALL = 4294967295 }; +enum tagWPC_ARGS_IMFEATUREEVENT{ WPC_ARGS_IMFEATUREEVENT_APPNAME = 0, WPC_ARGS_IMFEATUREEVENT_APPVERSION = 1, WPC_ARGS_IMFEATUREEVENT_ACCOUNTNAME = 2, WPC_ARGS_IMFEATUREEVENT_CONVID = 3, WPC_ARGS_IMFEATUREEVENT_MEDIATYPE = 4, WPC_ARGS_IMFEATUREEVENT_REASON = 5, WPC_ARGS_IMFEATUREEVENT_RECIPCOUNT = 6, WPC_ARGS_IMFEATUREEVENT_RECIPIENT = 7, WPC_ARGS_IMFEATUREEVENT_SENDER = 8, WPC_ARGS_IMFEATUREEVENT_SENDERIP = 9, WPC_ARGS_IMFEATUREEVENT_DATA = 10, WPC_ARGS_IMFEATUREEVENT_CARGS = 11 }; +enum tagWPC_ARGS_IMCONTACTEVENT{ WPC_ARGS_IMCONTACTEVENT_APPNAME = 0, WPC_ARGS_IMCONTACTEVENT_APPVERSION = 1, WPC_ARGS_IMCONTACTEVENT_ACCOUNTNAME = 2, WPC_ARGS_IMCONTACTEVENT_OLDNAME = 3, WPC_ARGS_IMCONTACTEVENT_OLDID = 4, WPC_ARGS_IMCONTACTEVENT_NEWNAME = 5, WPC_ARGS_IMCONTACTEVENT_NEWID = 6, WPC_ARGS_IMCONTACTEVENT_REASON = 7, WPC_ARGS_IMCONTACTEVENT_CARGS = 8 }; +enum tagWPC_ARGS_GAMESTARTEVENT{ WPC_ARGS_GAMESTARTEVENT_APPID = 0, WPC_ARGS_GAMESTARTEVENT_INSTANCEID = 1, WPC_ARGS_GAMESTARTEVENT_APPVERSION = 2, WPC_ARGS_GAMESTARTEVENT_PATH = 3, WPC_ARGS_GAMESTARTEVENT_RATING = 4, WPC_ARGS_GAMESTARTEVENT_RATINGSYSTEM = 5, WPC_ARGS_GAMESTARTEVENT_REASON = 6, WPC_ARGS_GAMESTARTEVENT_DESCCOUNT = 7, WPC_ARGS_GAMESTARTEVENT_DESCRIPTOR = 8, WPC_ARGS_GAMESTARTEVENT_PID = 9, WPC_ARGS_GAMESTARTEVENT_CARGS = 10 }; +enum tagWPC_ARGS_FILEDOWNLOADEVENT{ WPC_ARGS_FILEDOWNLOADEVENT_URL = 0, WPC_ARGS_FILEDOWNLOADEVENT_APPNAME = 1, WPC_ARGS_FILEDOWNLOADEVENT_VERSION = 2, WPC_ARGS_FILEDOWNLOADEVENT_BLOCKED = 3, WPC_ARGS_FILEDOWNLOADEVENT_PATH = 4, WPC_ARGS_FILEDOWNLOADEVENT_CARGS = 5 }; +enum tagWPC_ARGS_URLVISITEVENT{ WPC_ARGS_URLVISITEVENT_URL = 0, WPC_ARGS_URLVISITEVENT_APPNAME = 1, WPC_ARGS_URLVISITEVENT_VERSION = 2, WPC_ARGS_URLVISITEVENT_REASON = 3, WPC_ARGS_URLVISITEVENT_RATINGSYSTEMID = 4, WPC_ARGS_URLVISITEVENT_CATCOUNT = 5, WPC_ARGS_URLVISITEVENT_CATEGORY = 6, WPC_ARGS_URLVISITEVENT_CARGS = 7 }; +enum tagWPC_ARGS_WEBSITEVISITEVENT{ WPC_ARGS_WEBSITEVISITEVENT_URL = 0, WPC_ARGS_WEBSITEVISITEVENT_DECISION = 1, WPC_ARGS_WEBSITEVISITEVENT_CATEGORIES = 2, WPC_ARGS_WEBSITEVISITEVENT_BLOCKEDCATEGORIES = 3, WPC_ARGS_WEBSITEVISITEVENT_SERIALIZEDAPPLICATION = 4, WPC_ARGS_WEBSITEVISITEVENT_TITLE = 5, WPC_ARGS_WEBSITEVISITEVENT_CONTENTTYPE = 6, WPC_ARGS_WEBSITEVISITEVENT_REFERRER = 7, WPC_ARGS_WEBSITEVISITEVENT_TELEMETRY = 8, WPC_ARGS_WEBSITEVISITEVENT_CARGS = 9 }; +enum tagWPC_ARGS_APPLICATIONEVENT{ WPC_ARGS_APPLICATIONEVENT_SERIALIZEDAPPLICATION = 0, WPC_ARGS_APPLICATIONEVENT_DECISION = 1, WPC_ARGS_APPLICATIONEVENT_PROCESSID = 2, WPC_ARGS_APPLICATIONEVENT_CREATIONTIME = 3, WPC_ARGS_APPLICATIONEVENT_TIMEUSED = 4, WPC_ARGS_APPLICATIONEVENT_CARGS = 5 }; +enum tagWPC_ARGS_COMPUTERUSAGEEVENT{ WPC_ARGS_COMPUTERUSAGEEVENT_ID = 0, WPC_ARGS_COMPUTERUSAGEEVENT_TIMEUSED = 1, WPC_ARGS_COMPUTERUSAGEEVENT_CARGS = 2 }; +enum tagWPC_ARGS_CONTENTUSAGEEVENT{ WPC_ARGS_CONTENTUSAGEEVENT_CONTENTPROVIDERID = 0, WPC_ARGS_CONTENTUSAGEEVENT_CONTENTPROVIDERTITLE = 1, WPC_ARGS_CONTENTUSAGEEVENT_ID = 2, WPC_ARGS_CONTENTUSAGEEVENT_TITLE = 3, WPC_ARGS_CONTENTUSAGEEVENT_CATEGORY = 4, WPC_ARGS_CONTENTUSAGEEVENT_RATINGS = 5, WPC_ARGS_CONTENTUSAGEEVENT_DECISION = 6, WPC_ARGS_CONTENTUSAGEEVENT_CARGS = 7 }; +enum tagWPC_ARGS_CUSTOMEVENT{ WPC_ARGS_CUSTOMEVENT_PUBLISHER = 0, WPC_ARGS_CUSTOMEVENT_APPNAME = 1, WPC_ARGS_CUSTOMEVENT_APPVERSION = 2, WPC_ARGS_CUSTOMEVENT_EVENT = 3, WPC_ARGS_CUSTOMEVENT_VALUE1 = 4, WPC_ARGS_CUSTOMEVENT_VALUE2 = 5, WPC_ARGS_CUSTOMEVENT_VALUE3 = 6, WPC_ARGS_CUSTOMEVENT_BLOCKED = 7, WPC_ARGS_CUSTOMEVENT_REASON = 8, WPC_ARGS_CUSTOMEVENT_CARGS = 9 }; +enum tagWPC_ARGS_WEBOVERRIDEEVENT{ WPC_ARGS_WEBOVERRIDEEVENT_USERID = 0, WPC_ARGS_WEBOVERRIDEEVENT_URL = 1, WPC_ARGS_WEBOVERRIDEEVENT_REASON = 2, WPC_ARGS_WEBOVERRIDEEVENT_CARGS = 3 }; +enum tagWPC_ARGS_APPOVERRIDEEVENT{ WPC_ARGS_APPOVERRIDEEVENT_USERID = 0, WPC_ARGS_APPOVERRIDEEVENT_PATH = 1, WPC_ARGS_APPOVERRIDEEVENT_REASON = 2, WPC_ARGS_APPOVERRIDEEVENT_CARGS = 3 }; +enum tagWPC_SETTINGS{ WPC_SETTINGS_WPC_EXTENSION_PATH = 0, WPC_SETTINGS_WPC_EXTENSION_SILO = 1, WPC_SETTINGS_WPC_EXTENSION_IMAGE_PATH = 2, WPC_SETTINGS_WPC_EXTENSION_DISABLEDIMAGE_PATH = 3, WPC_SETTINGS_WPC_EXTENSION_NAME = 4, WPC_SETTINGS_WPC_EXTENSION_SUB_TITLE = 5, WPC_SETTINGS_SYSTEM_CURRENT_RATING_SYSTEM = 6, WPC_SETTINGS_SYSTEM_LAST_LOG_VIEW = 7, WPC_SETTINGS_SYSTEM_LOG_VIEW_REMINDER_INTERVAL = 8, WPC_SETTINGS_SYSTEM_HTTP_EXEMPTION_LIST = 9, WPC_SETTINGS_SYSTEM_URL_EXEMPTION_LIST = 10, WPC_SETTINGS_SYSTEM_FILTER_ID = 11, WPC_SETTINGS_SYSTEM_FILTER_NAME = 12, WPC_SETTINGS_SYSTEM_LOCALE = 13, WPC_SETTINGS_ALLOW_BLOCK = 14, WPC_SETTINGS_GAME_BLOCKED = 15, WPC_SETTINGS_GAME_ALLOW_UNRATED = 16, WPC_SETTINGS_GAME_MAX_ALLOWED = 17, WPC_SETTINGS_GAME_DENIED_DESCRIPTORS = 18, WPC_SETTINGS_USER_WPC_ENABLED = 19, WPC_SETTINGS_USER_LOGGING_REQUIRED = 20, WPC_SETTINGS_USER_HOURLY_RESTRICTIONS = 21, WPC_SETTINGS_USER_OVERRRIDE_REQUESTS = 22, WPC_SETTINGS_USER_LOGON_HOURS = 23, WPC_SETTINGS_USER_APP_RESTRICTIONS = 24, WPC_SETTINGS_WEB_FILTER_ON = 25, WPC_SETTINGS_WEB_DOWNLOAD_BLOCKED = 26, WPC_SETTINGS_WEB_FILTER_LEVEL = 27, WPC_SETTINGS_WEB_BLOCKED_CATEGORY_LIST = 28, WPC_SETTINGS_WEB_BLOCK_UNRATED = 29, WPC_SETTINGS_WPC_ENABLED = 30, WPC_SETTINGS_WPC_LOGGING_REQUIRED = 31, WPC_SETTINGS_RATING_SYSTEM_PATH = 32, WPC_SETTINGS_WPC_PROVIDER_CURRENT = 33, WPC_SETTINGS_USER_TIME_ALLOWANCE = 34, WPC_SETTINGS_USER_TIME_ALLOWANCE_RESTRICTIONS = 35, WPC_SETTINGS_GAME_RESTRICTED = 36, WPC_SETTING_COUNT = 37 }; +struct tagRFX_GFX_RECT{ INT32 left; INT32 top; INT32 right; INT32 bottom; }; +struct tagRFX_GFX_MSG_HEADER{ UINT16 uMSGType; UINT16 cbSize; }; +struct tagRFX_GFX_MONITOR_INFO{ INT32 left; INT32 top; INT32 right; INT32 bottom; UINT32 physicalWidth; UINT32 physicalHeight; UINT32 orientation; BOOL primary; }; +struct tagRFX_GFX_MSG_CLIENT_DESKTOP_INFO_REQUEST{ RFX_GFX_MSG_HEADER channelHdr; }; +struct tagRFX_GFX_MSG_CLIENT_DESKTOP_INFO_RESPONSE{ RFX_GFX_MSG_HEADER channelHdr; UINT32 reserved; UINT32 monitorCount; RFX_GFX_MONITOR_INFO MonitorData[16]; WCHAR clientUniqueId[32]; }; +struct tagRFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_NOTIFY{ RFX_GFX_MSG_HEADER channelHdr; ULONG ulWidth; ULONG ulHeight; ULONG ulBpp; ULONG Reserved; }; +struct tagRFX_GFX_MSG_DESKTOP_CONFIG_CHANGE_CONFIRM{ RFX_GFX_MSG_HEADER channelHdr; }; +struct tagRFX_GFX_MSG_DESKTOP_INPUT_RESET{ RFX_GFX_MSG_HEADER channelHdr; UINT32 ulWidth; UINT32 ulHeight; }; +struct tagRFX_GFX_MSG_DISCONNECT_NOTIFY{ RFX_GFX_MSG_HEADER channelHdr; ULONG DisconnectReason; }; +struct tagRFX_GFX_MSG_DESKTOP_RESEND_REQUEST{ RFX_GFX_MSG_HEADER channelHdr; RFX_GFX_RECT RedrawRect; }; +struct tagRFX_GFX_MSG_RDP_DATA{ RFX_GFX_MSG_HEADER channelHdr; UINT8 rdpData[1]; }; +enum tagAutomaticUpdatesNotificationLevel{ aunlNotConfigured = 0, aunlDisabled = 1, aunlNotifyBeforeDownload = 2, aunlNotifyBeforeInstallation = 3, aunlScheduledInstallation = 4 }; +enum tagAutomaticUpdatesScheduledInstallationDay{ ausidEveryDay = 0, ausidEverySunday = 1, ausidEveryMonday = 2, ausidEveryTuesday = 3, ausidEveryWednesday = 4, ausidEveryThursday = 5, ausidEveryFriday = 6, ausidEverySaturday = 7 }; +enum tagDownloadPhase{ dphInitializing = 1, dphDownloading = 2, dphVerifying = 3 }; +enum tagDownloadPriority{ dpLow = 1, dpNormal = 2, dpHigh = 3, dpExtraHigh = 4 }; +enum tagAutoSelectionMode{ asLetWindowsUpdateDecide = 0, asAutoSelectIfDownloaded = 1, asNeverAutoSelect = 2, asAlwaysAutoSelect = 3 }; +enum tagAutoDownloadMode{ adLetWindowsUpdateDecide = 0, adNeverAutoDownload = 1, adAlwaysAutoDownload = 2 }; +enum tagInstallationImpact{ iiNormal = 0, iiMinor = 1, iiRequiresExclusiveHandling = 2 }; +enum tagInstallationRebootBehavior{ irbNeverReboots = 0, irbAlwaysRequiresReboot = 1, irbCanRequestReboot = 2 }; +enum tagOperationResultCode{ orcNotStarted = 0, orcInProgress = 1, orcSucceeded = 2, orcSucceededWithErrors = 3, orcFailed = 4, orcAborted = 5 }; +enum tagServerSelection{ ssDefault = 0, ssManagedServer = 1, ssWindowsUpdate = 2, ssOthers = 3 }; +enum tagUpdateType{ utSoftware = 1, utDriver = 2 }; +enum tagUpdateOperation{ uoInstallation = 1, uoUninstallation = 2 }; +enum tagDeploymentAction{ daNone = 0, daInstallation = 1, daUninstallation = 2, daDetection = 3, daOptionalInstallation = 4 }; +enum tagUpdateExceptionContext{ uecGeneral = 1, uecWindowsDriver = 2, uecWindowsInstaller = 3, uecSearchIncomplete = 4 }; +enum tagAutomaticUpdatesUserType{ auutCurrentUser = 1, auutLocalAdministrator = 2 }; +enum tagAutomaticUpdatesPermissionType{ auptSetNotificationLevel = 1, auptDisableAutomaticUpdates = 2, auptSetIncludeRecommendedUpdates = 3, auptSetFeaturedUpdatesEnabled = 4, auptSetNonAdministratorsElevated = 5 }; +enum tagUpdateServiceRegistrationState{ usrsNotRegistered = 1, usrsRegistrationPending = 2, usrsRegistered = 3 }; +enum tagSearchScope{ searchScopeDefault = 0, searchScopeMachineOnly = 1, searchScopeCurrentUserOnly = 2, searchScopeMachineAndCurrentUser = 3, searchScopeMachineAndAllUsers = 4, searchScopeAllUsers = 5 }; +enum tagUpdateLockdownOption{ uloForWebsiteAccess = 1 }; +enum tagAddServiceFlag{ asfAllowPendingRegistration = 1, asfAllowOnlineRegistration = 2, asfRegisterServiceWithAU = 4 }; +enum tagUpdateServiceOption{ usoNonVolatileService = 1 }; +typedef __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions; +typedef __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions2 __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions2; +typedef __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptionsVtbl __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptionsVtbl; +typedef __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions2Vtbl __x_ABI_CWindows_CManagement_CDeployment_CIStagePackageOptions2Vtbl; +typedef __x_ABI_CWindows_CMedia_CImport_CPhotoImportStage __x_ABI_CWindows_CMedia_CImport_CPhotoImportStage; +typedef __x_ABI_CWindows_CWeb_CUI_CInterop_CWebViewControlAcceleratorKeyRoutingStage __x_ABI_CWindows_CWeb_CUI_CInterop_CWebViewControlAcceleratorKeyRoutingStage; +enum tagWMIACTIONCODE{ WmiGetAllData = 0, WmiGetSingleInstance = 1, WmiChangeSingleInstance = 2, WmiChangeSingleItem = 3, WmiEnableEvents = 4, WmiDisableEvents = 5, WmiEnableCollection = 6, WmiDisableCollection = 7, WmiRegisterInfo = 8, WmiExecuteMethodCall = 9 }; +enum tagWMI_CLOCK_TYPE{ WMICT_DEFAULT = 0, WMICT_SYSTEMTIME = 1, WMICT_PERFCOUNTER = 2, WMICT_PROCESS = 3, WMICT_THREAD = 4, WMICT_CPUCYCLE = 5 }; +struct tagSEARCHPATHPART{ wchar_t* pszPart; unsigned long cchPart; void* pDirectoryCache; void* pNotExistCache; _UNICODE_STRING ustrBuffer; }; +enum _tagSPCALL_FILE_INTEGRITY_STATE{ SPCALL_FILE_INTEGRITY_STATE_NOT_FOUND = 0, SPCALL_FILE_INTEGRITY_STATE_INVALID = 1, SPCALL_FILE_INTEGRITY_STATE_PARTIAL_TRUST = 2, SPCALL_FILE_INTEGRITY_STATE_FULL_TRUST = 3 }; +enum tagGlobUserSettingKinds{ GLOBALIZATIONUSERSETTINGS_TRADITIONALMULTIUSER = 0, GLOBALIZATIONUSERSETTINGS_SINGLEUSERSESSION = 1, GLOBALIZATIONUSERSETTINGS_SINGLEUSERSESSION_MULTIUSERAWARE = 2, GLOBALIZATIONUSERSETTINGS_SINGLEUSERSESSION_MULTIPLEUSERCONFIG = 3 }; +enum tagAPPHELPINFORMATIONCLASS{ ApphelpFlags = 0, ApphelpExeName = 1, ApphelpAppName = 2, ApphelpVendorName = 3, ApphelpHtmlHelpID = 4, ApphelpProblemSeverity = 5, ApphelpLinkURL = 6, ApphelpLinkText = 7, ApphelpTitle = 8, ApphelpDetails = 9, ApphelpContact = 10, ApphelpHelpCenterURL = 11, ApphelpExeTagID = 12, ApphelpDatabaseGUID = 13 }; +enum tagSDBMSILOOKUPSTATE{ LOOKUP_NONE = 0, LOOKUP_LOCAL = 1, LOOKUP_CUSTOM = 2, LOOKUP_MAIN = 3, LOOKUP_DONE = 4 }; +struct tagSWITCH_CONTEXT_DATA{ unsigned long long ullOsMaxVersionTested; unsigned long ulTargetPlatform; unsigned long long ullContextMinimum; _GUID guPlatform; _GUID guMinPlatform; unsigned long ulContextSource; unsigned long ulElementCount; _GUID guElements[1]; }; +struct tagSWITCH_CONTEXT_PLATFORM_DETAILS{ SWITCH_CONTEXT_PLATFORM_ID Id; _GUID Guid; unsigned short Major; unsigned short Minor; wchar_t* Name; }; +struct tagSWITCH_CONTEXT_CREATE_PARAM{ wchar_t* lpwzApplicationName; wchar_t* lpwzPackageMoniker; unsigned long long OsMaxVersionTested; unsigned long TargetPlatform; void* ShimData; unsigned short SubSystemMajorVersion; unsigned short SubSystemMinorVersion; unsigned short MajorOperatingSystemVersion; unsigned short MinorOperatingSystemVersion; void* SupportedOsInfo; }; +struct tagSWITCH_CONTEXT_ATTRIBUTE{ unsigned long long ulContextUpdateCounter; int fAllowContextUpdate; int fEnableTrace; unsigned long long EtwHandle; }; +struct LanguageNameDataType_tag{ unsigned short langID; wchar_t* cultureName; }; +struct tagSWITCH_CONTEXT{ tagSWITCH_CONTEXT_ATTRIBUTE Attribute; tagSWITCH_CONTEXT_DATA Data; }; +struct tagSDBBMACHINEINFO{ tagSDBDEVICEINFO* AcpiInfo; tagSDBDEVICEINFO* OemInfo; tagSDBDEVICEINFO* BiosInfo; tagSDBDEVICEINFO* CpuInfo; }; +struct tagUSERSDBLOOKUPENTRY{ _ULARGE_INTEGER liTimeStamp; _GUID guidDB; }; +struct tagSDBENTRY{ _GUID guidDB; _DB* pdb; unsigned long dwFlags; long __PADDING__[1]; }; +struct tagSDBENTRYINFO{ _GUID guidID; unsigned long dwFlags; unsigned long tiData; _GUID guidDB; }; +struct tagSDBDEVICEINFO{ wchar_t* szVendorId; wchar_t* szDeviceId; wchar_t* szSubVendorId; wchar_t* szSubSystemId; unsigned long dwModel; unsigned long dwFamily; unsigned long dwDate; unsigned long dwRevision; unsigned long dwCreatorRevision; long __PADDING__[1]; }; +struct tagSDBCONTEXT{ unsigned long dwFlags; _DB* pdbMain; _DB* pdbLocal; unsigned long dwDatabaseCount; unsigned long dwDatabaseMask; tagSDBENTRY rgSDB[16]; unsigned long dwRuntimePlatform; unsigned long dwOSSKU; unsigned long dwSPMask; unsigned long dwOSKind; tagUSERSDBLOOKUP* pLookupHead; unsigned short uExeType; _SDB_MATCHER_MAP SdbMatchers[16]; void* PfnDeviceQueryCallback; void* PfnAttributeMatchResult; void* PfnLegacyIsDeviceInstalledCallback; }; +struct tagFlagInfoEntry{ unsigned long long ullFlagMask; unsigned long dwSize; unsigned short tFlagType; wchar_t szCommandLine[1]; }; +struct tagFlagInfo{ unsigned long dwSize; unsigned long dwCount; }; +struct tagGUIDENTRY{ _LIST_ENTRY MainGEList; unsigned long Flags; long long RefCount; unsigned long Signature; unsigned long ISCount; _LIST_ENTRY ObjectHead; _LIST_ENTRY ISHead; _GUID Guid; unsigned long EventRefCount; unsigned long CollectRefCount; _WMIP_GUIDENTRY_NONPAGED* NonPaged; unsigned long long LegacyEtwHandle; unsigned long long LegacyEtwToken; unsigned long long LegacyEnableContext; _WMIP_SYNCHRONOUS_ETW_WORK* LegacyEtwSynchronous; _LIST_ENTRY LegacyWorkHead; unsigned long LegacyEtwProviderCount; long __PADDING__[1]; }; +struct tagSEARCHPATH{ unsigned long nParts; tagSEARCHPATHPART parts[1]; }; +struct tagDATASOURCE{ _LIST_ENTRY MainDSList; unsigned long Flags; long long RefCount; unsigned long Signature; _LIST_ENTRY ISHead; unsigned long ProviderId; unsigned long ProcessId; unsigned long MofResourceCount; MOFRESOURCE** MofResources; MOFRESOURCE* StaticMofResources[4]; _WMIGUIDOBJECT* RequestObject; }; +struct tagINSTIDCHUNK{ }; +struct tagInstanceSet{ _LIST_ENTRY GuidISList; unsigned long Flags; long long RefCount; unsigned long Signature; _LIST_ENTRY DSISList; tagGUIDENTRY* GuidEntry; tagDATASOURCE* DataSource; unsigned long Count; unsigned long WADInstanceNameSize; unsigned long ProviderId; }; +struct tagFlagInfoListEntry{ unsigned long long ullFlagMask; unsigned short tFlagType; wchar_t* pszCommandLine; unsigned long dwEntrySize; tagFlagInfoListEntry* pNext; }; +struct _tagSP_FILE_USN_DATA{ unsigned long long ullJournalId; long long usnFileUSN; }; +struct tagSPCALL2SERVER_PARAMETERS{ unsigned char* pbInBlob; unsigned int cbInBlob; unsigned int cbAvailableOutput; unsigned char* pbOutBlob; unsigned int cbOutBlob; long status; }; +struct tagSEARCHDBCONTEXT{ unsigned long dwFlags; unsigned long long hFileMapping; int bFastMode; wchar_t* szFullPath; wchar_t* szDir; wchar_t* szExeName; wchar_t* szModuleName; wchar_t* pEnvironment; wchar_t* szProcessHistory; tagSEARCHPATH* pSearchParts; int bBypassCache; _RTL_ARRAY* PackageAttributes; }; +struct tagUSERSDBLOOKUP{ tagUSERSDBLOOKUP* pNext; tagUSERSDBLOOKUP* pPrev; wchar_t* pwszItemName; int bLayer; unsigned long dwCount; tagUSERSDBLOOKUPENTRY rgEntries[1]; }; +struct tagAPPHELPINFOCONTEXT{ void* hSDB; _DB* pdb; _DB* pdbDetails; unsigned long dwDatabaseType; unsigned long dwContextFlags; _GUID guidDB; _GUID guidID; unsigned long dwMask; unsigned long tiExe; unsigned long tiApphelpExe; unsigned long dwHtmlHelpID; unsigned long dwSeverity; unsigned long dwFlags; unsigned long tiApphelpDetails; unsigned long tiLink; wchar_t* pwszAppName; wchar_t* pwszApphelpURL; wchar_t* pwszVendorName; wchar_t* pwszExeName; wchar_t* pwszLinkURL; wchar_t* pwszLinkText; wchar_t* pwszTitle; wchar_t* pwszDetails; wchar_t* pwszContact; wchar_t* pwszHelpCtrURL; int bOfflineContent; int bUseHtmlHelp; _UNICODE_STRING ustrChmFile; _UNICODE_STRING ustrDetailsDatabase; }; +struct tagATTRINFO{ unsigned short tAttrID; unsigned long dwFlags; }; +struct tagSDBQUERYRESULT{ unsigned long atrExes[16]; unsigned long adwExeFlags[16]; unsigned long atrLayers[8]; unsigned long dwLayerFlags; unsigned long trAppHelp; unsigned long dwExeCount; unsigned long dwLayerCount; _GUID guidID; unsigned long dwExtraFlags; unsigned long dwCustomSDBMap; _GUID rgGuidDB[16]; }; +struct tagAPPHELP_DATA{ unsigned long dwFlags; unsigned long dwSeverity; unsigned long dwHTMLHelpID; wchar_t* szAppName; unsigned long trExe; wchar_t* szURL; wchar_t* szLink; wchar_t* szAppTitle; wchar_t* szContact; wchar_t* szDetails; unsigned long dwData; int bUnused; }; +struct tagHOOKAPI{ char* pszModule; char* pszFunctionName; void* pfnNew; void* pfnOld; unsigned long dwFlags; tagHOOKAPIEX* pHookEx; }; +struct tagHOOKAPIEX{ unsigned long dwHooksetId; char* pszRedirModule; char* pszRedirFunctionName; void* pFinalModule; void* pfnFinal; int bStub; void* pStubModule; void* pfnStub; tagHOOKAPI* pTopOfChain; tagHOOKAPI* pNext; }; +struct tagMSIPACKAGEINFO{ _GUID guidID; _GUID guidMsiPackageID; _GUID guidDatabaseID; unsigned long dwPackageFlags; }; +struct tagSDBMSIFINDINFO{ unsigned long trMatch; _GUID guidID; _FIND_INFO sdbFindInfo; tagSDBMSILOOKUPSTATE sdbLookupState; unsigned long dwCustomIndex; }; +struct tagEXE_ENTRY_INFO{ unsigned long tiExe; unsigned long dwFlags; }; +struct tagSDBMSITRANSFORMINFO{ wchar_t* lpszTransformName; unsigned long trTransform; unsigned long trFile; }; +struct tagSDBDATABASEINFO{ unsigned long dwFlags; unsigned long dwVersionMajor; unsigned long dwVersionMinor; wchar_t* pszDescription; _GUID guidDB; }; +struct tagSTDGUIDSDB{ _GUID* pGuid; unsigned long dwDatabaseType; long __PADDING__[1]; }; +typedef tagSPCALL_FILE_INTEGRITY_STATE _tagSPCALL_FILE_INTEGRITY_STATE; +typedef _tagSPCALL_FILE_INTEGRITY_STATE; +typedef tagSP_FILE_USN_DATA _tagSP_FILE_USN_DATA; +typedef _tagSP_FILE_USN_DATA; +struct _tagFAMILY_TABLE{ int numHookedAPIs; void* hModShimEng; void* hMod; void** DpmMisc; void** pDpmShmTbls; void** pfn; }; +typedef tagFAMILY_TABLE _tagFAMILY_TABLE; +typedef _tagFAMILY_TABLE; +struct tagGauditParams{ HANDLE hFile; UINT32 cbSize; UINT32 cbOutSize; }; +struct tagGauditTestDef{ UINT32 ulGauditFlags; 692B514770646E555968314B372F4171374F4F316E67514A4174383D KsProp; 6E41414D706C3078486D4A39595A506F517367353530447A4B74453D ExtensionApis; UINT_PTR pReserved; UINT32 cbOutSize; }; +struct _tag_tm{ TIMEPROC Proc; char* strRep; }; +struct _tag_ksi{ LPGUID arpguidCategories[2]; UINT32 cpguidCategories; char* strRep; }; +BOOLEAN PciMultiStageResumeCapable( void ); +UCHAR StageQueue_GetUsedStageCount( PVOID Context ); +void COfferReclaimStagingSurfaceTest( void ); +struct _tagRANGE{ UINT uStart; UINT uStop; _tagRANGE* pPrev; _tagRANGE* pNext; }; +struct _tagTestList{ CTest* pTest; PTESTRANGE pTestRange; _tagTestList* pPrev; _tagTestList* pNext; }; +struct _tagIList{ IUnknown* pIUnknown; PVOID pInterface; UINT32 uRefCount; LPCTSTR szDesc; LPCTSTR szFile; int uLine; _tagIList* pNext; }; +typedef e_Stage 30774C38653754694F5A744D784764353863624E3359535A394B6B3D; +struct _tagGPUCP_CRYPTOSESSION_PAVP_KEYEXCHANGE{ GUID PAVPKeyExchangeGUID; UINT DataSize; void* pKeyExchangeParams; }; +struct _tagPAVP_FIXED_EXCHANGE_PARAMS{ UINT32 FixedKey[4]; UINT32 SessionKey[4]; }; +struct _tagPAVP_SAFEID_EXCHANGE_PARAMS{ UINT32 FixedKey[4]; UINT32 SessionKey[4]; }; +struct _tagLevelEntry{ TCHAR* LevelTag; UINT32 Level; }; +struct _tagSignalingEntry{ TCHAR* StandardTag; UINT32 Standard; }; +struct tagOPMDisplayData{ UINT32 DisplayWidth; UINT32 DisplayHeight; DXVA2_SampleFormat dsfSampleInterleaveFormat; D3DFORMAT d3dFormat; UINT32 ulFrequencyNumerator; UINT32 ulFrequencyDenominator; }; +struct tagOPMHDCPKeyData{ UINT32 HDCPFlags; GUID BKey; GUID reserved1; GUID reserved2; }; +struct tagOPMSRMPARAMETERS{ BOOLEAN IsSRMSet; UINT32 SRMVersion; }; +struct tagOPMStatusSignalData{ UINT32 AvailableTVProtectionStandards; UINT32 ActiveTVProtectionStandard; UINT32 Reserved; UINT32 AspectRatioValidMask1; UINT32 AspectRatioData1; UINT32 AspectRatioValidMask2; UINT32 AspectRatioData2; UINT32 AspectRatioValidMask3; UINT32 AspectRatioData3; UINT32 Reserved2[4]; UINT32 Reserved3[4]; }; +struct tagOPMSetSignalData{ UINT32 NewTVProtectionStandard; UINT32 AspectRatioChangeMask1; UINT32 AspectRatioData1; UINT32 AspectRatioChangeMask2; UINT32 AspectRatioData2; UINT32 AspectRatioChangeMask3; UINT32 AspectRatioData3; UINT32 Reserved[4]; UINT32 Reserved2[4]; UINT32 Reserved3; }; +struct tagOPMConfig{ UINT32 ProtectionMask; UINT32 LocalProtectionLevel[4]; UINT32 GlobalProtectionLevel[4]; UINT32 StatusFlags; LONG ConnectorType; UINT32 BusType; OPM_DISPLAYDATA DisplayData; OPM_HDCPKEYDATA HDCPKeyData; OPM_SIGNALDATA SignalData; OPM_SRMPARAMETERS SRMData; }; +struct TextureStageState{ D3DTEXTUREOP ColorOp; UINT32 ColorArg1; UINT32 ColorArg2; UINT32 ColorArg0; D3DTEXTUREOP AlphaOp; UINT32 AlphaArg1; UINT32 AlphaArg2; UINT32 AlphaArg0; UINT32 ResultTo; TextureID TexID; CycleID CycID; UINT32 TexCoordIndex; 42396951486138384356617258626868734D6F3772625A6D6D35593D OtherTexStageStates[10]; }; +typedef get_tagName get_tagName; +typedef put_tagName put_tagName; +typedef tagKS_DATARANGE_DV_AVC tagKS_DATARANGE_DV_AVC; +typedef tagKS_DATAFORMAT_DV_AVC tagKS_DATAFORMAT_DV_AVC; +typedef tagKS_DATARANGE_MPEG2TS_AVC tagKS_DATARANGE_MPEG2TS_AVC; +typedef tagKS_DATAFORMAT_MPEG2TS_AVC tagKS_DATAFORMAT_MPEG2TS_AVC; +typedef tagDRMFORWARD tagDRMFORWARD; +typedef GetGeotagAsync GetGeotagAsync; +typedef SetGeotagFromGeolocatorAsync SetGeotagFromGeolocatorAsync; +typedef SetGeotagAsync SetGeotagAsync; +typedef get_DatagramSocket get_DatagramSocket; +typedef get_LuxPercentage get_LuxPercentage; +typedef put_LuxPercentage put_LuxPercentage; +typedef RequestNewStageAsync RequestNewStageAsync; +typedef StageContentGroupsAsync StageContentGroupsAsync; +typedef StageContentGroupsWithPriorityAsync StageContentGroupsWithPriorityAsync; +typedef add_PackageStaging add_PackageStaging; +typedef remove_PackageStaging remove_PackageStaging; +typedef add_PackageContentGroupStaging add_PackageContentGroupStaging; +typedef remove_PackageContentGroupStaging remove_PackageContentGroupStaging; +typedef get_IsPartiallyStaged get_IsPartiallyStaged; +typedef GetExtensionSubtags GetExtensionSubtags; +typedef GetTextureStageState GetTextureStageState; +typedef SetTextureStageState SetTextureStageState; +typedef tags tags; +typedef put_tagUrn put_tagUrn; +typedef get_tagUrn get_tagUrn; +typedef get_tagNames get_tagNames; +typedef get_StageFiles get_StageFiles; +typedef put_StageFiles put_StageFiles; +typedef tagDOWNLOADDESIGNVECTOR tagDOWNLOADDESIGNVECTOR; +typedef tagSCF_EVENT_HEADER tagSCF_EVENT_HEADER; +typedef tagSCF_NAVIGATION_EVENT tagSCF_NAVIGATION_EVENT; +typedef tagSCF_MENUACTION_EVENT tagSCF_MENUACTION_EVENT; +typedef tagSCF_CONTEXTMENU_EVENT tagSCF_CONTEXTMENU_EVENT; +typedef GetStage GetStage; +typedef GetGamertag GetGamertag; +typedef GetModernGamertag GetModernGamertag; +typedef GetModernGamertagSuffix GetModernGamertagSuffix; +typedef GetUniqueModernGamertag GetUniqueModernGamertag; +typedef get_IsStaggeringEnabled get_IsStaggeringEnabled; +typedef put_IsStaggeringEnabled put_IsStaggeringEnabled; +typedef get_IsStaggeringEnabledProperty get_IsStaggeringEnabledProperty; +typedef get_IsStaggerElementProperty get_IsStaggerElementProperty; +typedef GetIsStaggerElement GetIsStaggerElement; +typedef SetIsStaggerElement SetIsStaggerElement; +typedef get_StageInPlace get_StageInPlace; +typedef put_StageInPlace put_StageInPlace; +typedef StagePackageAsync StagePackageAsync; +typedef StagePackageWithOptionsAsync StagePackageWithOptionsAsync; +typedef StageUserDataAsync StageUserDataAsync; +typedef StagePackageToVolumeAsync StagePackageToVolumeAsync; +typedef StageUserDataWithOptionsAsync StageUserDataWithOptionsAsync; +typedef StagePackageToVolumeAndOptionalPackagesAsync StagePackageToVolumeAndOptionalPackagesAsync; +typedef StagePackageToVolumeAndRelatedSetAsync StagePackageToVolumeAndRelatedSetAsync; +typedef StagePackageByUriAsync StagePackageByUriAsync; +typedef SetContentGroupStateWithPercentageAsync SetContentGroupStateWithPercentageAsync; +typedef get_StageButDoNotInstall get_StageButDoNotInstall; +typedef put_StageButDoNotInstall put_StageButDoNotInstall; +typedef get_IsStaged get_IsStaged; +typedef GetActiveDutyCyclePercentage GetActiveDutyCyclePercentage; +typedef SetActiveDutyCyclePercentage SetActiveDutyCyclePercentage; +typedef AddDatagramSocketAsync AddDatagramSocketAsync; +typedef get_Stage get_Stage; +typedef RegisterDatagramSocketAsync1 RegisterDatagramSocketAsync1; +typedef RegisterDatagramSocketAsync2 RegisterDatagramSocketAsync2; +typedef get_StageInfo get_StageInfo; +typedef add_AuthenticationStageChanged add_AuthenticationStageChanged; +typedef remove_AuthenticationStageChanged remove_AuthenticationStageChanged; +typedef GetAuthenticationStageInfoAsync GetAuthenticationStageInfoAsync; +typedef get_StaggerDelay get_StaggerDelay; +typedef get_StaggerDelayFactor get_StaggerDelayFactor; +typedef get_RoutingStage get_RoutingStage; +typedef HalPciMultiStageResumeCapable HalPciMultiStageResumeCapable; diff --git a/btparser/tests/jonas-small.h b/btparser/tests/jonas-small.h new file mode 100644 index 0000000..dfe3c0b --- /dev/null +++ b/btparser/tests/jonas-small.h @@ -0,0 +1,72 @@ +typedef struct _PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY { + union { + DWORD Flags; + struct { + DWORD EnableUserShadowStack : 1; + DWORD AuditUserShadowStack : 1; + DWORD SetContextIpValidation : 1; + DWORD AuditSetContextIpValidation : 1; + DWORD EnableUserShadowStackStrictMode : 1; + DWORD BlockNonCetBinaries : 1; + DWORD BlockNonCetBinariesNonEhcont : 1; + DWORD AuditBlockNonCetBinaries : 1; + DWORD CetDynamicApisOutOfProcOnly : 1; + DWORD SetContextIpValidationRelaxedMode : 1; + DWORD ReservedFlags : 22; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_USER_SHADOW_STACK_POLICY, *PPROCESS_MITIGATION_USER_SHADOW_STACK_POLICY; + +typedef struct _PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY { + union { + ULONG Flags; + struct { + + // + // Prevent branch target pollution cross-SMT-thread in user mode. + // + + ULONG SmtBranchTargetIsolation : 1; + + // + // Isolate this process into a distinct security domain, even from + // other processes running as the same security context. This + // prevents branch target injection cross-process (normally such + // branch target injection is only inhibited across different + // security contexts). + // + // Page combining is limited to processes within the same security + // domain. This flag thus also effectively limits the process to + // only being able to combine internally to the process itself, + // except for common pages (unless further restricted by the + // DisablePageCombine policy). + // + + ULONG IsolateSecurityDomain : 1; + + // + // Disable all page combining for this process, even internally to + // the process itself, except for common pages (zeroes or ones). + // + + ULONG DisablePageCombine : 1; + + // + // Memory Disambiguation Disable. + // + + ULONG SpeculativeStoreBypassDisable : 1; + + // + // Prevent this process' threads from being scheduled on the same + // core as threads outside its security domain. + // + + ULONG RestrictCoreSharing : 1; + + ULONG ReservedFlags : 27; + + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY, *PPROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY; +