1 /**
2  * Windows API header module
3  *
4  * Translated from MinGW Windows headers
5  *
6  * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
7  * Source: $(DRUNTIMESRC core/sys/windows/_oaidl.d)
8  */
9 module core.sys.windows.oaidl;
10 version (Windows):
11 
12 import core.sys.windows.basetyps, core.sys.windows.unknwn, core.sys.windows.windef, core.sys.windows.wtypes;
13 
14 enum DISPID_UNKNOWN = -1;
15 enum DISPID_VALUE = 0;
16 enum DISPID_PROPERTYPUT = -3;
17 enum DISPID_NEWENUM = -4;
18 enum DISPID_EVALUATE = -5;
19 enum DISPID_CONSTRUCTOR = -6;
20 enum DISPID_DESTRUCTOR = -7;
21 enum DISPID_COLLECT = -8;
22 
23 enum FADF_AUTO = 1;
24 enum FADF_STATIC = 2;
25 enum FADF_EMBEDDED = 4;
26 enum FADF_FIXEDSIZE = 16;
27 enum FADF_RECORD = 32;
28 enum FADF_HAVEIID = 64;
29 enum FADF_HAVEVARTYPE = 128;
30 enum FADF_BSTR = 256;
31 enum FADF_UNKNOWN = 512;
32 enum FADF_DISPATCH = 1024;
33 enum FADF_VARIANT = 2048;
34 enum FADF_RESERVED = 0xf0e8;
35 enum FADF_DATADELETED = 0x1000;
36 enum FADF_CREATEVECTOR = 0x2000;
37 
38 enum PARAMFLAG_NONE = 0;
39 enum PARAMFLAG_FIN = 1;
40 enum PARAMFLAG_FOUT = 2;
41 enum PARAMFLAG_FLCID = 4;
42 enum PARAMFLAG_FRETVAL = 8;
43 enum PARAMFLAG_FOPT = 16;
44 enum PARAMFLAG_FHASDEFAULT = 32;
45 enum PARAMFLAG_FHASCUSTDATA = 64;
46 
47 enum IDLFLAG_NONE = PARAMFLAG_NONE;
48 enum IDLFLAG_FIN = PARAMFLAG_FIN;
49 enum IDLFLAG_FOUT = PARAMFLAG_FOUT;
50 enum IDLFLAG_FLCID = PARAMFLAG_FLCID;
51 enum IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;
52 
53 enum IMPLTYPEFLAG_FDEFAULT       = 1;
54 enum IMPLTYPEFLAG_FSOURCE        = 2;
55 enum IMPLTYPEFLAG_FRESTRICTED    = 4;
56 enum IMPLTYPEFLAG_FDEFAULTVTABLE = 8;
57 
58 
59 enum SYSKIND {
60     SYS_WIN16,
61     SYS_WIN32,
62     SYS_MAC
63 }
64 
65 enum LIBFLAGS {
66     LIBFLAG_FRESTRICTED   = 1,
67     LIBFLAG_FCONTROL      = 2,
68     LIBFLAG_FHIDDEN       = 4,
69     LIBFLAG_FHASDISKIMAGE = 8
70 }
71 
72 struct TLIBATTR {
73     GUID guid;
74     LCID lcid;
75     SYSKIND syskind;
76     WORD wMajorVerNum;
77     WORD wMinorVerNum;
78     WORD wLibFlags;
79 }
80 alias TLIBATTR* LPTLIBATTR;
81 
82 alias CY CURRENCY;
83 
84 struct SAFEARRAYBOUND {
85     ULONG cElements;
86     LONG lLbound;
87 }
88 alias SAFEARRAYBOUND* LPSAFEARRAYBOUND;
89 
90 struct SAFEARR_BSTR {
91     ULONG Size;
92     wireBSTR* aBstr;
93 }
94 
95 struct SAFEARR_UNKNOWN {
96     ULONG Size;
97     IUnknown* apUnknown;
98 }
99 
100 struct SAFEARR_DISPATCH {
101     ULONG Size;
102     LPDISPATCH* apDispatch;
103 }
104 
105 struct SAFEARR_VARIANT {
106     ULONG Size;
107     _wireVARIANT* aVariant;
108 }
109 
110 enum SF_TYPE {
111     SF_ERROR=VARENUM.VT_ERROR,
112     SF_I1=VARENUM.VT_I1,
113     SF_I2=VARENUM.VT_I2,
114     SF_I4=VARENUM.VT_I4,
115     SF_I8=VARENUM.VT_I8,
116     SF_BSTR=VARENUM.VT_BSTR,
117     SF_UNKNOWN=VARENUM.VT_UNKNOWN,
118     SF_DISPATCH=VARENUM.VT_DISPATCH,
119     SF_VARIANT=VARENUM.VT_VARIANT
120 }
121 
122 struct _wireBRECORD {
123     ULONG fFlags;
124     ULONG clSize;
125     LPRECORDINFO* pRecInfo;
126     byte* pRecord;
127 }
128 alias _wireBRECORD* wireBRECORD;
129 
130 struct SAFEARR_BRECORD {
131     ULONG Size;
132     wireBRECORD* aRecord;
133 }
134 
135 struct SAFEARR_HAVEIID {
136     ULONG Size;
137     IUnknown* apUnknown;
138     IID iid;
139 }
140 
141 struct SAFEARRAYUNION {
142     ULONG sfType;
143     union _u {
144         SAFEARR_BSTR BstrStr;
145         SAFEARR_UNKNOWN UnknownStr;
146         SAFEARR_DISPATCH DispatchStr;
147         SAFEARR_VARIANT VariantStr;
148         SAFEARR_BRECORD RecordStr;
149         SAFEARR_HAVEIID HaveIidStr;
150         BYTE_SIZEDARR ByteStr;
151         WORD_SIZEDARR WordStr;
152         DWORD_SIZEDARR LongStr;
153         HYPER_SIZEDARR HyperStr;
154     }
155     _u u;
156 }
157 
158 struct _wireSAFEARRAY {
159     USHORT cDims;
160     USHORT fFeatures;
161     ULONG cbElements;
162     ULONG cLocks;
163     SAFEARRAYUNION uArrayStructs;
164     SAFEARRAYBOUND[1] rgsabound;
165 }
166 alias _wireSAFEARRAY* wireSAFEARRAY;
167 
168 alias wireSAFEARRAY* wirePSAFEARRAY;
169 
170 struct SAFEARRAY {
171     USHORT cDims;
172     USHORT fFeatures;
173     ULONG cbElements;
174     ULONG cLocks;
175     PVOID pvData;
176     SAFEARRAYBOUND[1] rgsabound;
177 }
178 alias SAFEARRAY* LPSAFEARRAY;
179 
180 struct VARIANT {
181     union {
182         struct {
183             VARTYPE vt;
184             WORD wReserved1;
185             WORD wReserved2;
186             WORD wReserved3;
187             union {
188                 int lVal;
189                 LONGLONG llVal;
190                 ubyte bVal;
191                 short iVal;
192                 float fltVal;
193                 double dblVal;
194                 VARIANT_BOOL  boolVal;
195                 SCODE scode;
196                 CY cyVal;
197                 DATE date;
198                 BSTR bstrVal;
199                 IUnknown punkVal;
200                 IDispatch pdispVal;
201                 SAFEARRAY* parray;
202                 ubyte* pbVal;
203                 short* piVal;
204                 int* plVal;
205                 LONGLONG* pllVal;
206                 float* pfltVal;
207                 double* pdblVal;
208                 VARIANT_BOOL* pboolVal;
209                 _VARIANT_BOOL*  pbool;
210                 SCODE* pscode;
211                 CY* pcyVal;
212                 DATE* pdate;
213                 BSTR* pbstrVal;
214                 IUnknown* ppunkVal;
215                 IDispatch* ppdispVal;
216                 SAFEARRAY** pparray;
217                 VARIANT* pvarVal;
218                 void* byref;
219                 CHAR cVal;
220                 USHORT uiVal;
221                 ULONG ulVal;
222                 ULONGLONG ullVal;
223                 INT intVal;
224                 UINT uintVal;
225                 DECIMAL* pdecVal;
226                 CHAR*  pcVal;
227                 USHORT*  puiVal;
228                 ULONG*  pulVal;
229                 ULONGLONG* pullVal;
230                 INT*  pintVal;
231                 UINT*  puintVal;
232                 struct {
233                     PVOID pvRecord;
234                     IRecordInfo pRecInfo;
235                 }
236             }
237         }
238         DECIMAL decVal;
239     }
240 }
241 alias VARIANT* LPVARIANT;
242 
243 alias VARIANT VARIANTARG;
244 alias VARIANT* LPVARIANTARG;
245 
246 struct _wireVARIANT {
247     DWORD clSize;
248     DWORD rpcReserved;
249     USHORT vt;
250     USHORT wReserved1;
251     USHORT wReserved2;
252     USHORT wReserved3;
253     union {
254         LONG lVal;
255         LONGLONG llVal;
256         BYTE bVal;
257         SHORT iVal;
258         FLOAT fltVal;
259         DOUBLE dblVal;
260         VARIANT_BOOL boolVal;
261         SCODE scode;
262         CY cyVal;
263         DATE date;
264         wireBSTR bstrVal;
265         IUnknown punkVal;
266         LPDISPATCH pdispVal;
267         wirePSAFEARRAY parray;
268         wireBRECORD brecVal;
269         BYTE* pbVal;
270         SHORT* piVal;
271         LONG* plVal;
272         LONGLONG* pllVal;
273         FLOAT* pfltVal;
274         DOUBLE* pdblVal;
275         VARIANT_BOOL* pboolVal;
276         SCODE* pscode;
277         CY* pcyVal;
278         DATE* pdate;
279         wireBSTR* pbstrVal;
280         IUnknown* ppunkVal;
281         LPDISPATCH* ppdispVal;
282         wirePSAFEARRAY* pparray;
283         wireVARIANT* pvarVal;
284         CHAR cVal;
285         USHORT uiVal;
286         ULONG ulVal;
287         ULONGLONG ullVal;
288         INT intVal;
289         UINT uintVal;
290         DECIMAL decVal;
291         DECIMAL* pdecVal;
292         CHAR* pcVal;
293         USHORT* puiVal;
294         ULONG* pulVal;
295         ULONGLONG* pullVal;
296         INT* pintVal;
297         UINT* puintVal;
298     }
299 }
300 alias _wireVARIANT* wireVARIANT;
301 
302 alias LONG DISPID;
303 alias DISPID MEMBERID;
304 alias DWORD HREFTYPE;
305 
306 enum TYPEKIND {
307     TKIND_ENUM, TKIND_RECORD, TKIND_MODULE, TKIND_INTERFACE, TKIND_DISPATCH,
308     TKIND_COCLASS, TKIND_ALIAS, TKIND_UNION, TKIND_MAX
309 }
310 
311 struct TYPEDESC {
312     union {
313         TYPEDESC* lptdesc;
314         ARRAYDESC* lpadesc;
315         HREFTYPE hreftype;
316     }
317     VARTYPE vt;
318 }
319 
320 struct ARRAYDESC {
321     TYPEDESC tdescElem;
322     USHORT cDims;
323     SAFEARRAYBOUND[1] rgbounds;
324 }
325 
326 struct PARAMDESCEX {
327     ULONG cBytes;
328     VARIANTARG varDefaultValue;
329 }
330 alias PARAMDESCEX* LPPARAMDESCEX;
331 
332 struct PARAMDESC {
333     LPPARAMDESCEX pparamdescex;
334     USHORT wParamFlags;
335 }
336 alias PARAMDESC* LPPARAMDESC;
337 
338 struct IDLDESC {
339     ULONG_PTR dwReserved;
340     USHORT wIDLFlags;
341 }
342 alias IDLDESC* LPIDLDESC;
343 
344 struct ELEMDESC {
345     TYPEDESC tdesc;
346     union {
347         IDLDESC idldesc;
348         PARAMDESC paramdesc;
349     }
350 }
351 alias ELEMDESC* LPELEMDESC;
352 
353 struct TYPEATTR {
354     GUID guid;
355     LCID lcid;
356     DWORD dwReserved;
357     MEMBERID memidConstructor;
358     MEMBERID memidDestructor;
359     LPOLESTR lpstrSchema;
360     ULONG cbSizeInstance;
361     TYPEKIND typekind;
362     WORD cFuncs;
363     WORD cVars;
364     WORD cImplTypes;
365     WORD cbSizeVft;
366     WORD cbAlignment;
367     WORD wTypeFlags;
368     WORD wMajorVerNum;
369     WORD wMinorVerNum;
370     TYPEDESC tdescAlias;
371     IDLDESC idldescType;
372 }
373 alias TYPEATTR* LPTYPEATTR;
374 
375 struct DISPPARAMS {
376     VARIANTARG* rgvarg;
377     DISPID* rgdispidNamedArgs;
378     UINT cArgs;
379     UINT cNamedArgs;
380 }
381 
382 struct EXCEPINFO {
383     WORD wCode;
384     WORD wReserved;
385     BSTR bstrSource;
386     BSTR bstrDescription;
387     BSTR bstrHelpFile;
388     DWORD dwHelpContext;
389     PVOID pvReserved;
390     extern (Windows) {
391     HRESULT function (EXCEPINFO* ) pfnDeferredFillIn;
392     }
393     SCODE scode;
394 }
395 alias EXCEPINFO* LPEXCEPINFO;
396 
397 enum CALLCONV {
398     CC_FASTCALL,
399     CC_CDECL,
400     CC_MSCPASCAL,
401     CC_PASCAL=CC_MSCPASCAL,
402     CC_MACPASCAL,
403     CC_STDCALL,
404     CC_FPFASTCALL,
405     CC_SYSCALL,
406     CC_MPWCDECL,
407     CC_MPWPASCAL,
408     CC_MAX=CC_MPWPASCAL
409 }
410 
411 enum FUNCKIND {
412     FUNC_VIRTUAL,
413     FUNC_PUREVIRTUAL,
414     FUNC_NONVIRTUAL,
415     FUNC_STATIC,
416     FUNC_DISPATCH
417 }
418 
419 enum INVOKEKIND {
420     INVOKE_FUNC           = 1,
421     INVOKE_PROPERTYGET    = 2,
422     INVOKE_PROPERTYPUT    = 4,
423     INVOKE_PROPERTYPUTREF = 8
424 }
425 
426 struct FUNCDESC {
427     MEMBERID memid;
428     SCODE* lprgscode;
429     ELEMDESC* lprgelemdescParam;
430     FUNCKIND funckind;
431     INVOKEKIND invkind;
432     CALLCONV callconv;
433     SHORT cParams;
434     SHORT cParamsOpt;
435     SHORT oVft;
436     SHORT cScodes;
437     ELEMDESC elemdescFunc;
438     WORD wFuncFlags;
439 }
440 alias FUNCDESC* LPFUNCDESC;
441 
442 enum VARKIND {
443     VAR_PERINSTANCE, VAR_STATIC, VAR_CONST, VAR_DISPATCH
444 }
445 
446 struct VARDESC {
447     MEMBERID memid;
448     LPOLESTR lpstrSchema;
449     union {
450         ULONG oInst;
451         VARIANT* lpvarValue;
452     }
453     ELEMDESC elemdescVar;
454     WORD wVarFlags;
455     VARKIND varkind;
456 }
457 alias VARDESC* LPVARDESC;
458 
459 enum TYPEFLAGS {
460     TYPEFLAG_FAPPOBJECT     = 1,
461     TYPEFLAG_FCANCREATE     = 2,
462     TYPEFLAG_FLICENSED      = 4,
463     TYPEFLAG_FPREDECLID     = 8,
464     TYPEFLAG_FHIDDEN        = 16,
465     TYPEFLAG_FCONTROL       = 32,
466     TYPEFLAG_FDUAL          = 64,
467     TYPEFLAG_FNONEXTENSIBLE = 128,
468     TYPEFLAG_FOLEAUTOMATION = 256,
469     TYPEFLAG_FRESTRICTED    = 512,
470     TYPEFLAG_FAGGREGATABLE  = 1024,
471     TYPEFLAG_FREPLACEABLE   = 2048,
472     TYPEFLAG_FDISPATCHABLE  = 4096,
473     TYPEFLAG_FREVERSEBIND   = 8192
474 }
475 
476 enum FUNCFLAGS {
477     FUNCFLAG_FRESTRICTED = 1,
478     FUNCFLAG_FSOURCE = 2,
479     FUNCFLAG_FBINDABLE = 4,
480     FUNCFLAG_FREQUESTEDIT = 8,
481     FUNCFLAG_FDISPLAYBIND = 16,
482     FUNCFLAG_FDEFAULTBIND = 32,
483     FUNCFLAG_FHIDDEN = 64,
484     FUNCFLAG_FUSESGETLASTERROR = 128,
485     FUNCFLAG_FDEFAULTCOLLELEM = 256,
486     FUNCFLAG_FUIDEFAULT = 512,
487     FUNCFLAG_FNONBROWSABLE = 1024,
488     FUNCFLAG_FREPLACEABLE = 2048,
489     FUNCFLAG_FIMMEDIATEBIND = 4096
490 }
491 
492 enum VARFLAGS {
493     VARFLAG_FREADONLY = 1,
494     VARFLAG_FSOURCE = 2,
495     VARFLAG_FBINDABLE = 4,
496     VARFLAG_FREQUESTEDIT = 8,
497     VARFLAG_FDISPLAYBIND = 16,
498     VARFLAG_FDEFAULTBIND = 32,
499     VARFLAG_FHIDDEN = 64,
500     VARFLAG_FRESTRICTED = 128,
501     VARFLAG_FDEFAULTCOLLELEM = 256,
502     VARFLAG_FUIDEFAULT = 512,
503     VARFLAG_FNONBROWSABLE = 1024,
504     VARFLAG_FREPLACEABLE = 2048,
505     VARFLAG_FIMMEDIATEBIND = 4096
506 }
507 
508 struct CLEANLOCALSTORAGE {
509     IUnknown pInterface;
510     PVOID pStorage;
511     DWORD flags;
512 }
513 
514 struct CUSTDATAITEM {
515     GUID guid;
516     VARIANTARG varValue;
517 }
518 alias CUSTDATAITEM* LPCUSTDATAITEM;
519 
520 struct CUSTDATA {
521     DWORD cCustData;
522     LPCUSTDATAITEM prgCustData;
523 }
524 alias CUSTDATA* LPCUSTDATA;
525 
526 enum DESCKIND {
527     DESCKIND_NONE = 0,
528     DESCKIND_FUNCDESC = DESCKIND_NONE+1,
529     DESCKIND_VARDESC = DESCKIND_FUNCDESC+1,
530     DESCKIND_TYPECOMP = DESCKIND_VARDESC+1,
531     DESCKIND_IMPLICITAPPOBJ = DESCKIND_TYPECOMP+1,
532     DESCKIND_MAX = DESCKIND_IMPLICITAPPOBJ+1
533 }
534 
535 union BINDPTR {
536     LPFUNCDESC lpfuncdesc;
537     LPVARDESC lpvardesc;
538     LPTYPECOMP lptcomp;
539 }
540 alias BINDPTR* LPBINDPTR;
541 
542 interface IDispatch : IUnknown {
543     HRESULT GetTypeInfoCount(UINT*);
544     HRESULT GetTypeInfo(UINT, LCID, LPTYPEINFO*);
545     HRESULT GetIDsOfNames(REFIID, LPOLESTR*, UINT, LCID, DISPID*);
546     HRESULT Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*, UINT*);
547 }
548 alias IDispatch LPDISPATCH;
549 
550 interface IEnumVARIANT : IUnknown {
551     HRESULT Next(ULONG, VARIANT*, ULONG*);
552     HRESULT Skip(ULONG);
553     HRESULT Reset();
554     HRESULT Clone(IEnumVARIANT*);
555 }
556 alias IEnumVARIANT LPENUMVARIANT;
557 
558 interface ITypeComp : IUnknown {
559     HRESULT Bind(LPOLESTR, ULONG, WORD, LPTYPEINFO*, DESCKIND*, LPBINDPTR);
560     HRESULT BindType(LPOLESTR, ULONG, LPTYPEINFO*, LPTYPECOMP*);
561 }
562 alias ITypeComp LPTYPECOMP;
563 
564 interface ITypeInfo : IUnknown {
565     HRESULT GetTypeAttr(LPTYPEATTR*);
566     HRESULT GetTypeComp(LPTYPECOMP*);
567     HRESULT GetFuncDesc(UINT, LPFUNCDESC*);
568     HRESULT GetVarDesc(UINT, LPVARDESC*);
569     HRESULT GetNames(MEMBERID, BSTR*, UINT, UINT*);
570     HRESULT GetRefTypeOfImplType(UINT, HREFTYPE*);
571     HRESULT GetImplTypeFlags(UINT, INT*);
572     HRESULT GetIDsOfNames(LPOLESTR*, UINT, MEMBERID*);
573     HRESULT Invoke(PVOID, MEMBERID, WORD, DISPPARAMS*, VARIANT*, EXCEPINFO*,
574       UINT*);
575     HRESULT GetDocumentation(MEMBERID, BSTR*, BSTR*, DWORD*, BSTR*);
576     HRESULT GetDllEntry(MEMBERID, INVOKEKIND, BSTR*, BSTR*, WORD*);
577     HRESULT GetRefTypeInfo(HREFTYPE, LPTYPEINFO*);
578     HRESULT AddressOfMember(MEMBERID, INVOKEKIND, PVOID*);
579     HRESULT CreateInstance(LPUNKNOWN, REFIID, PVOID*);
580     HRESULT GetMops(MEMBERID, BSTR*);
581     HRESULT GetContainingTypeLib(LPTYPELIB*, UINT*);
582     void ReleaseTypeAttr(LPTYPEATTR);
583     void ReleaseFuncDesc(LPFUNCDESC);
584     void ReleaseVarDesc(LPVARDESC);
585 }
586 alias ITypeInfo LPTYPEINFO;
587 
588 interface ITypeInfo2 : ITypeInfo {
589     HRESULT GetTypeKind(TYPEKIND*);
590     HRESULT GetTypeFlags(ULONG*);
591     HRESULT GetFuncIndexOfMemId(MEMBERID, INVOKEKIND, UINT*);
592     HRESULT GetVarIndexOfMemId(MEMBERID, UINT*);
593     HRESULT GetCustData(REFGUID, VARIANT*);
594     HRESULT GetFuncCustData(UINT, REFGUID, VARIANT*);
595     HRESULT GetParamCustData(UINT, UINT, REFGUID, VARIANT*);
596     HRESULT GetVarCustData(UINT, REFGUID, VARIANT*);
597     HRESULT GetImplTypeCustData(UINT, REFGUID, VARIANT*);
598     HRESULT GetDocumentation2(MEMBERID, LCID, BSTR*, DWORD*, BSTR*);
599     HRESULT GetAllCustData(CUSTDATA*);
600     HRESULT GetAllFuncCustData(UINT, CUSTDATA*);
601     HRESULT GetAllParamCustData(UINT, UINT, CUSTDATA*);
602     HRESULT GetAllVarCustData(UINT, CUSTDATA*);
603     HRESULT GetAllImplTypeCustData(UINT, CUSTDATA*);
604 }
605 alias ITypeInfo2 LPTYPEINFO2;
606 
607 interface ITypeLib : IUnknown {
608     UINT GetTypeInfoCount();
609     HRESULT GetTypeInfo(UINT, ITypeInfo*);
610     HRESULT GetTypeInfoType(UINT, TYPEKIND*);
611     HRESULT GetTypeInfoOfGuid(REFGUID, ITypeInfo*);
612     HRESULT GetLibAttr(TLIBATTR**);
613     HRESULT GetTypeComp(ITypeComp);
614     HRESULT GetDocumentation(INT, BSTR*, BSTR*, DWORD*, BSTR*);
615     HRESULT IsName(LPOLESTR, ULONG, BOOL*);
616     HRESULT FindName(LPOLESTR, ULONG, ITypeInfo*, MEMBERID*, USHORT*);
617     void ReleaseTLibAttr(TLIBATTR*);
618 }
619 alias ITypeLib LPTYPELIB;
620 
621 interface ITypeLib2 : ITypeLib {
622     HRESULT GetCustData(REFGUID, VARIANT*);
623     HRESULT GetLibStatistics(ULONG*, ULONG*);
624     HRESULT GetDocumentation2(INT, LCID, BSTR*, DWORD*, BSTR*);
625     HRESULT GetAllCustData(CUSTDATA*);
626 }
627 alias ITypeLib2 LPTYPELIB2;
628 
629 interface IErrorInfo : IUnknown {
630     HRESULT GetGUID(GUID*);
631     HRESULT GetSource(BSTR*);
632     HRESULT GetDescription(BSTR*);
633     HRESULT GetHelpFile(BSTR*);
634     HRESULT GetHelpContext(DWORD*);
635 }
636 alias IErrorInfo LPERRORINFO;
637 
638 interface ICreateErrorInfo : IUnknown {
639     HRESULT SetGUID(REFGUID);
640     HRESULT SetSource(LPOLESTR);
641     HRESULT SetDescription(LPOLESTR);
642     HRESULT SetHelpFile(LPOLESTR);
643     HRESULT SetHelpContext(DWORD);
644 }
645 alias ICreateErrorInfo LPCREATEERRORINFO;
646 
647 interface ISupportErrorInfo : IUnknown {
648     HRESULT InterfaceSupportsErrorInfo(REFIID);
649 }
650 alias ISupportErrorInfo LPSUPPORTERRORINFO;
651 
652 interface IRecordInfo : IUnknown {
653     HRESULT RecordInit(PVOID);
654     HRESULT RecordClear(PVOID);
655     HRESULT RecordCopy(PVOID, PVOID);
656     HRESULT GetGuid(GUID*);
657     HRESULT GetName(BSTR*);
658     HRESULT GetSize(ULONG*);
659     HRESULT GetTypeInfo(ITypeInfo*);
660     HRESULT GetField(PVOID, LPCOLESTR, VARIANT*);
661     HRESULT GetFieldNoCopy(PVOID, LPCOLESTR, VARIANT*, PVOID*);
662     HRESULT PutField (ULONG, PVOID, LPCOLESTR, VARIANT*);
663     HRESULT PutFieldNoCopy(ULONG, PVOID, LPCOLESTR, VARIANT*);
664     HRESULT GetFieldNames(ULONG*, BSTR*);
665     BOOL IsMatchingType();
666     PVOID RecordCreate();
667     HRESULT RecordCreateCopy(PVOID, PVOID*);
668     HRESULT RecordDestroy (PVOID);
669 }
670 alias IRecordInfo LPRECORDINFO;
671 
672 interface ITypeMarshal : IUnknown {
673     HRESULT Size(PVOID, DWORD, PVOID, ULONG*);
674     HRESULT Marshal(PVOID, DWORD, PVOID, ULONG, BYTE*, ULONG*);
675     HRESULT Unmarshal(PVOID, DWORD, ULONG, BYTE*, ULONG*);
676     HRESULT Free(PVOID);
677 }