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 */
9module core.sys.windows.oaidl;
10version (Windows):
11@system:
12
13import core.sys.windows.basetyps, core.sys.windows.unknwn, core.sys.windows.windef, core.sys.windows.wtypes;
14
15enum DISPID_UNKNOWN = -1;
16enum DISPID_VALUE = 0;
17enum DISPID_PROPERTYPUT = -3;
18enum DISPID_NEWENUM = -4;
19enum DISPID_EVALUATE = -5;
20enum DISPID_CONSTRUCTOR = -6;
21enum DISPID_DESTRUCTOR = -7;
22enum DISPID_COLLECT = -8;
23
24enum FADF_AUTO = 1;
25enum FADF_STATIC = 2;
26enum FADF_EMBEDDED = 4;
27enum FADF_FIXEDSIZE = 16;
28enum FADF_RECORD = 32;
29enum FADF_HAVEIID = 64;
30enum FADF_HAVEVARTYPE = 128;
31enum FADF_BSTR = 256;
32enum FADF_UNKNOWN = 512;
33enum FADF_DISPATCH = 1024;
34enum FADF_VARIANT = 2048;
35enum FADF_RESERVED = 0xf0e8;
36enum FADF_DATADELETED = 0x1000;
37enum FADF_CREATEVECTOR = 0x2000;
38
39enum PARAMFLAG_NONE = 0;
40enum PARAMFLAG_FIN = 1;
41enum PARAMFLAG_FOUT = 2;
42enum PARAMFLAG_FLCID = 4;
43enum PARAMFLAG_FRETVAL = 8;
44enum PARAMFLAG_FOPT = 16;
45enum PARAMFLAG_FHASDEFAULT = 32;
46enum PARAMFLAG_FHASCUSTDATA = 64;
47
48enum IDLFLAG_NONE = PARAMFLAG_NONE;
49enum IDLFLAG_FIN = PARAMFLAG_FIN;
50enum IDLFLAG_FOUT = PARAMFLAG_FOUT;
51enum IDLFLAG_FLCID = PARAMFLAG_FLCID;
52enum IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;
53
54enum IMPLTYPEFLAG_FDEFAULT       = 1;
55enum IMPLTYPEFLAG_FSOURCE        = 2;
56enum IMPLTYPEFLAG_FRESTRICTED    = 4;
57enum IMPLTYPEFLAG_FDEFAULTVTABLE = 8;
58
59
60enum SYSKIND {
61    SYS_WIN16,
62    SYS_WIN32,
63    SYS_MAC
64}
65
66enum LIBFLAGS {
67    LIBFLAG_FRESTRICTED   = 1,
68    LIBFLAG_FCONTROL      = 2,
69    LIBFLAG_FHIDDEN       = 4,
70    LIBFLAG_FHASDISKIMAGE = 8
71}
72
73struct TLIBATTR {
74    GUID guid;
75    LCID lcid;
76    SYSKIND syskind;
77    WORD wMajorVerNum;
78    WORD wMinorVerNum;
79    WORD wLibFlags;
80}
81alias TLIBATTR* LPTLIBATTR;
82
83alias CY CURRENCY;
84
85struct SAFEARRAYBOUND {
86    ULONG cElements;
87    LONG lLbound;
88}
89alias SAFEARRAYBOUND* LPSAFEARRAYBOUND;
90
91struct SAFEARR_BSTR {
92    ULONG Size;
93    wireBSTR* aBstr;
94}
95
96struct SAFEARR_UNKNOWN {
97    ULONG Size;
98    IUnknown* apUnknown;
99}
100
101struct SAFEARR_DISPATCH {
102    ULONG Size;
103    LPDISPATCH* apDispatch;
104}
105
106struct SAFEARR_VARIANT {
107    ULONG Size;
108    _wireVARIANT* aVariant;
109}
110
111enum 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
123struct _wireBRECORD {
124    ULONG fFlags;
125    ULONG clSize;
126    LPRECORDINFO* pRecInfo;
127    byte* pRecord;
128}
129alias _wireBRECORD* wireBRECORD;
130
131struct SAFEARR_BRECORD {
132    ULONG Size;
133    wireBRECORD* aRecord;
134}
135
136struct SAFEARR_HAVEIID {
137    ULONG Size;
138    IUnknown* apUnknown;
139    IID iid;
140}
141
142struct 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
159struct _wireSAFEARRAY {
160    USHORT cDims;
161    USHORT fFeatures;
162    ULONG cbElements;
163    ULONG cLocks;
164    SAFEARRAYUNION uArrayStructs;
165    SAFEARRAYBOUND[1] rgsabound;
166}
167alias _wireSAFEARRAY* wireSAFEARRAY;
168
169alias wireSAFEARRAY* wirePSAFEARRAY;
170
171struct SAFEARRAY {
172    USHORT cDims;
173    USHORT fFeatures;
174    ULONG cbElements;
175    ULONG cLocks;
176    PVOID pvData;
177    SAFEARRAYBOUND[1] rgsabound;
178}
179alias SAFEARRAY* LPSAFEARRAY;
180
181struct 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}
242alias VARIANT* LPVARIANT;
243
244alias VARIANT VARIANTARG;
245alias VARIANT* LPVARIANTARG;
246
247struct _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}
301alias _wireVARIANT* wireVARIANT;
302
303alias LONG DISPID;
304alias DISPID MEMBERID;
305alias DWORD HREFTYPE;
306
307enum TYPEKIND {
308    TKIND_ENUM, TKIND_RECORD, TKIND_MODULE, TKIND_INTERFACE, TKIND_DISPATCH,
309    TKIND_COCLASS, TKIND_ALIAS, TKIND_UNION, TKIND_MAX
310}
311
312struct TYPEDESC {
313    union {
314        TYPEDESC* lptdesc;
315        ARRAYDESC* lpadesc;
316        HREFTYPE hreftype;
317    }
318    VARTYPE vt;
319}
320
321struct ARRAYDESC {
322    TYPEDESC tdescElem;
323    USHORT cDims;
324    SAFEARRAYBOUND[1] rgbounds;
325}
326
327struct PARAMDESCEX {
328    ULONG cBytes;
329    VARIANTARG varDefaultValue;
330}
331alias PARAMDESCEX* LPPARAMDESCEX;
332
333struct PARAMDESC {
334    LPPARAMDESCEX pparamdescex;
335    USHORT wParamFlags;
336}
337alias PARAMDESC* LPPARAMDESC;
338
339struct IDLDESC {
340    ULONG_PTR dwReserved;
341    USHORT wIDLFlags;
342}
343alias IDLDESC* LPIDLDESC;
344
345struct ELEMDESC {
346    TYPEDESC tdesc;
347    union {
348        IDLDESC idldesc;
349        PARAMDESC paramdesc;
350    }
351}
352alias ELEMDESC* LPELEMDESC;
353
354struct 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}
374alias TYPEATTR* LPTYPEATTR;
375
376struct DISPPARAMS {
377    VARIANTARG* rgvarg;
378    DISPID* rgdispidNamedArgs;
379    UINT cArgs;
380    UINT cNamedArgs;
381}
382
383struct 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}
396alias EXCEPINFO* LPEXCEPINFO;
397
398enum 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
412enum FUNCKIND {
413    FUNC_VIRTUAL,
414    FUNC_PUREVIRTUAL,
415    FUNC_NONVIRTUAL,
416    FUNC_STATIC,
417    FUNC_DISPATCH
418}
419
420enum INVOKEKIND {
421    INVOKE_FUNC           = 1,
422    INVOKE_PROPERTYGET    = 2,
423    INVOKE_PROPERTYPUT    = 4,
424    INVOKE_PROPERTYPUTREF = 8
425}
426
427struct 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}
441alias FUNCDESC* LPFUNCDESC;
442
443enum VARKIND {
444    VAR_PERINSTANCE, VAR_STATIC, VAR_CONST, VAR_DISPATCH
445}
446
447struct 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}
458alias VARDESC* LPVARDESC;
459
460enum 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
477enum 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
493enum 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
509struct CLEANLOCALSTORAGE {
510    IUnknown pInterface;
511    PVOID pStorage;
512    DWORD flags;
513}
514
515struct CUSTDATAITEM {
516    GUID guid;
517    VARIANTARG varValue;
518}
519alias CUSTDATAITEM* LPCUSTDATAITEM;
520
521struct CUSTDATA {
522    DWORD cCustData;
523    LPCUSTDATAITEM prgCustData;
524}
525alias CUSTDATA* LPCUSTDATA;
526
527enum 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
536union BINDPTR {
537    LPFUNCDESC lpfuncdesc;
538    LPVARDESC lpvardesc;
539    LPTYPECOMP lptcomp;
540}
541alias BINDPTR* LPBINDPTR;
542
543interface 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}
549alias IDispatch LPDISPATCH;
550
551interface IEnumVARIANT : IUnknown {
552    HRESULT Next(ULONG, VARIANT*, ULONG*);
553    HRESULT Skip(ULONG);
554    HRESULT Reset();
555    HRESULT Clone(IEnumVARIANT*);
556}
557alias IEnumVARIANT LPENUMVARIANT;
558
559interface ITypeComp : IUnknown {
560    HRESULT Bind(LPOLESTR, ULONG, WORD, LPTYPEINFO*, DESCKIND*, LPBINDPTR);
561    HRESULT BindType(LPOLESTR, ULONG, LPTYPEINFO*, LPTYPECOMP*);
562}
563alias ITypeComp LPTYPECOMP;
564
565interface 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}
587alias ITypeInfo LPTYPEINFO;
588
589interface 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}
606alias ITypeInfo2 LPTYPEINFO2;
607
608interface 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}
620alias ITypeLib LPTYPELIB;
621
622interface 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}
628alias ITypeLib2 LPTYPELIB2;
629
630interface IErrorInfo : IUnknown {
631    HRESULT GetGUID(GUID*);
632    HRESULT GetSource(BSTR*);
633    HRESULT GetDescription(BSTR*);
634    HRESULT GetHelpFile(BSTR*);
635    HRESULT GetHelpContext(DWORD*);
636}
637alias IErrorInfo LPERRORINFO;
638
639interface ICreateErrorInfo : IUnknown {
640    HRESULT SetGUID(REFGUID);
641    HRESULT SetSource(LPOLESTR);
642    HRESULT SetDescription(LPOLESTR);
643    HRESULT SetHelpFile(LPOLESTR);
644    HRESULT SetHelpContext(DWORD);
645}
646alias ICreateErrorInfo LPCREATEERRORINFO;
647
648interface ISupportErrorInfo : IUnknown {
649    HRESULT InterfaceSupportsErrorInfo(REFIID);
650}
651alias ISupportErrorInfo LPSUPPORTERRORINFO;
652
653interface 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}
671alias IRecordInfo LPRECORDINFO;
672
673interface 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