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