libphobos/libdruntime/core/sys/windows/oaidl.d

   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 @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 }