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 src/core/sys/windows/_oaidl.d)
   8  */
   9 module core.sys.windows.oaidl;
  10 version (Windows):
  11
  12 private 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 }